Source: lib/offline/download_manager.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.DownloadManager');
  9. goog.require('shaka.net.NetworkingEngine');
  10. goog.require('shaka.offline.DownloadProgressEstimator');
  11. goog.require('shaka.util.ArrayUtils');
  12. goog.require('shaka.util.BufferUtils');
  13. goog.require('shaka.util.Destroyer');
  14. goog.require('shaka.util.Error');
  15. goog.require('shaka.util.IDestroyable');
  16. goog.require('shaka.util.Pssh');
  19. /**
  20.  * This manages downloading segments.
  21.  *
  22.  * @implements {shaka.util.IDestroyable}
  23.  * @final
  24.  */
  25. shaka.offline.DownloadManager = class {
  26.   /**
  27.    * Create a new download manager. It will use (but not own) |networkingEngine|
  28.    * and call |onProgress| after each download.
  29.    *
  30.    * @param {!shaka.net.NetworkingEngine} networkingEngine
  31.    */
  32.   constructor(networkingEngine) {
  33.     /** @private {shaka.net.NetworkingEngine} */
  34.     this.networkingEngine_ = networkingEngine;
  36.     /**
  37.      * We group downloads. Within each group, the requests are executed in
  38.      * series. Between groups, the requests are executed in parallel. We store
  39.      * the promise chain that is doing the work.
  40.      *
  41.      * @private {!Map<number, !Promise>}
  42.      */
  43.     this.groups_ = new Map();
  45.     /** @private {!shaka.util.Destroyer} */
  46.     this.destroyer_ = new shaka.util.Destroyer(() => {
  47.       // Add a "catch" block to stop errors from being returned.
  48.       return this.abortAll().catch(() => {});
  49.     });
  51.     /**
  52.      * A list of callback functions to cancel any in-progress downloads.
  53.      *
  54.      * @private {!Array<function(): !Promise>}
  55.      */
  56.     this.abortCallbacks_ = [];
  58.     /**
  59.      * A callback for when a segment has been downloaded. The first parameter
  60.      * is the progress of all segments, a number between 0.0 (0% complete) and
  61.      * 1.0 (100% complete). The second parameter is the total number of bytes
  62.      * that have been downloaded.
  63.      *
  64.      * @private {function(number, number)}
  65.      */
  66.     this.onProgress_ = (progress, size) => {};
  68.     /**
  69.      * A callback for when a segment has new PSSH data and we pass
  70.      * on the initData to storage
  71.      *
  72.      * @private {function(!Uint8Array, string)}
  73.      */
  74.     this.onInitData_ = (initData, systemId) => {};
  76.     /** @private {shaka.offline.DownloadProgressEstimator} */
  77.     this.estimator_ = new shaka.offline.DownloadProgressEstimator();
  79.     /** @private {boolean} */
  80.     this.aborted_ = false;
  81.   }
  83.   /** @override */
  84.   destroy() {
  85.     return this.destroyer_.destroy();
  86.   }
  88.   /**
  89.    * @param {function(number, number)} onProgress
  90.    * @param {function(!Uint8Array, string)} onInitData
  91.    */
  92.   setCallbacks(onProgress, onInitData) {
  93.     this.onProgress_ = onProgress;
  94.     this.onInitData_ = onInitData;
  95.   }
  97.   /**
  98.    * Aborts all in-progress downloads.
  99.    * @return {!Promise} A promise that will resolve once the downloads are fully
  100.    *   aborted.
  101.    */
  102.   abortAll() {
  103.     this.aborted_ = true;
  104.     const promises = this.abortCallbacks_.map((callback) => callback());
  105.     this.abortCallbacks_ = [];
  106.     return Promise.all(promises);
  107.   }
  109.   /**
  110.    * @return {boolean}
  111.    */
  112.   isAborted() {
  113.     return this.aborted_;
  114.   }
  116.   /**
  117.    * Adds a byte length to the download estimate.
  118.    *
  119.    * @param {number} estimatedByteLength
  120.    * @return {number} estimateId
  121.    */
  122.   addDownloadEstimate(estimatedByteLength) {
  123.     return this.estimator_.open(estimatedByteLength);
  124.   }
  126.   /**
  127.    * Add a request to be downloaded as part of a group.
  128.    *
  129.    * @param {number} groupId
  130.    *    The group to add this segment to. If the group does not exist, a new
  131.    *    group will be created.
  132.    * @param {shaka.extern.Request} request
  133.    * @param {number} estimateId
  134.    * @param {boolean} isInitSegment
  135.    * @param {function(BufferSource):!Promise} onDownloaded
  136.    *   The callback for when this request has been downloaded. Downloading for
  137.    *   |group| will pause until the promise returned by |onDownloaded| resolves.
  138.    * @return {!Promise} Resolved when this request is complete.
  139.    */
  140.   queue(groupId, request, estimateId, isInitSegment, onDownloaded) {
  141.     this.destroyer_.ensureNotDestroyed();
  143.     const group = this.groups_.get(groupId) || Promise.resolve();
  145.     // Add another download to the group.
  146.     const newPromise = group.then(async () => {
  147.       const response = await this.fetchSegment_(request);
  149.       // Make sure we stop downloading if we have been destroyed.
  150.       if (this.destroyer_.destroyed()) {
  151.         throw new shaka.util.Error(
  152.             shaka.util.Error.Severity.CRITICAL,
  153.             shaka.util.Error.Category.STORAGE,
  154.             shaka.util.Error.Code.OPERATION_ABORTED);
  155.       }
  157.       // Update initData
  158.       if (isInitSegment) {
  159.         const segmentBytes = shaka.util.BufferUtils.toUint8(response);
  160.         const pssh = new shaka.util.Pssh(segmentBytes);
  161.         for (const key in pssh.data) {
  162.           const index = Number(key);
  163.           const data = pssh.data[index];
  164.           const systemId = pssh.systemIds[index];
  165.           this.onInitData_(data, systemId);
  166.         }
  167.       }
  169.       // Update all our internal stats.
  170.       this.estimator_.close(estimateId, response.byteLength);
  171.       this.onProgress_(
  172.           this.estimator_.getEstimatedProgress(),
  173.           this.estimator_.getTotalDownloaded());
  175.       return onDownloaded(response);
  176.     });
  178.     this.groups_.set(groupId, newPromise);
  179.     return newPromise;
  180.   }
  182.   /**
  183.    * Add already-downloaded data to a group.
  184.    *
  185.    * @param {number} groupId
  186.    *    The group to add this segment to. If the group does not exist, a new
  187.    *    group will be created.
  188.    * @param {!BufferSource} queueData
  189.    * @param {number} estimateId
  190.    * @param {boolean} isInitSegment
  191.    * @param {function(BufferSource):!Promise} onDownloaded
  192.    *   The callback for when this request has been downloaded. Downloading for
  193.    *   |group| will pause until the promise returned by |onDownloaded| resolves.
  194.    * @return {!Promise} Resolved when this request is complete.
  195.    */
  196.   queueData(groupId, queueData, estimateId, isInitSegment, onDownloaded) {
  197.     this.destroyer_.ensureNotDestroyed();
  199.     const group = this.groups_.get(groupId) || Promise.resolve();
  201.     // Add another download to the group.
  202.     const newPromise = group.then(() => {
  203.       // Make sure we stop downloading if we have been destroyed.
  204.       if (this.destroyer_.destroyed()) {
  205.         throw new shaka.util.Error(
  206.             shaka.util.Error.Severity.CRITICAL,
  207.             shaka.util.Error.Category.STORAGE,
  208.             shaka.util.Error.Code.OPERATION_ABORTED);
  209.       }
  211.       // Update initData
  212.       if (isInitSegment) {
  213.         const segmentBytes = shaka.util.BufferUtils.toUint8(queueData);
  214.         const pssh = new shaka.util.Pssh(segmentBytes);
  215.         for (const key in pssh.data) {
  216.           const index = Number(key);
  217.           const data = pssh.data[index];
  218.           const systemId = pssh.systemIds[index];
  219.           this.onInitData_(data, systemId);
  220.         }
  221.       }
  223.       // Update all our internal stats.
  224.       this.estimator_.close(estimateId, queueData.byteLength);
  225.       this.onProgress_(
  226.           this.estimator_.getEstimatedProgress(),
  227.           this.estimator_.getTotalDownloaded());
  229.       return onDownloaded(queueData);
  230.     });
  232.     this.groups_.set(groupId, newPromise);
  233.     return newPromise;
  234.   }
  236.   /**
  237.    * Add additional async work to the group work queue.
  238.    *
  239.    * @param {number} groupId
  240.    *    The group to add this group to. If the group does not exist, a new
  241.    *    group will be created.
  242.    * @param {function():!Promise} callback
  243.    *   The callback for the async work.  Downloading for this group will be
  244.    *   blocked until the Promise returned by |callback| resolves.
  245.    * @return {!Promise} Resolved when this work is complete.
  246.    */
  247.   queueWork(groupId, callback) {
  248.     this.destroyer_.ensureNotDestroyed();
  249.     const group = this.groups_.get(groupId) || Promise.resolve();
  250.     const newPromise = group.then(async () => {
  251.       await callback();
  252.     });
  253.     this.groups_.set(groupId, newPromise);
  254.     return newPromise;
  255.   }
  257.   /**
  258.    * Get a promise that will resolve when all currently queued downloads have
  259.    * finished.
  260.    *
  261.    * @return {!Promise<number>}
  262.    */
  263.   async waitToFinish() {
  264.     await Promise.all(this.groups_.values());
  265.     return this.estimator_.getTotalDownloaded();
  266.   }
  268.   /**
  269.    * Download a segment and return the data in the response.
  270.    *
  271.    * @param {shaka.extern.Request} request
  272.    * @return {!Promise<BufferSource>}
  273.    * @private
  274.    */
  275.   async fetchSegment_(request) {
  276.     const type = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  277.     /** @type {!shaka.net.NetworkingEngine.PendingRequest} */
  278.     const action = this.networkingEngine_.request(type, request);
  279.     const abortCallback = () => {
  280.       return action.abort();
  281.     };
  282.     this.abortCallbacks_.push(abortCallback);
  283.     const response = await action.promise;
  284.     shaka.util.ArrayUtils.remove(this.abortCallbacks_, abortCallback);
  285.     return response.data;
  286.   }
  287. };