Source: lib/offline/storage.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.Storage');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.Player');
  11. goog.require('shaka.log');
  12. goog.require('shaka.media.DrmEngine');
  13. goog.require('shaka.media.ManifestParser');
  14. goog.require('shaka.net.NetworkingEngine');
  15. goog.require('shaka.offline.DownloadInfo');
  16. goog.require('shaka.offline.DownloadManager');
  17. goog.require('shaka.offline.OfflineUri');
  18. goog.require('shaka.offline.SessionDeleter');
  19. goog.require('shaka.offline.StorageMuxer');
  20. goog.require('shaka.offline.StoredContentUtils');
  21. goog.require('shaka.offline.StreamBandwidthEstimator');
  22. goog.require('shaka.util.AbortableOperation');
  23. goog.require('shaka.util.ArrayUtils');
  24. goog.require('shaka.util.ConfigUtils');
  25. goog.require('shaka.util.Destroyer');
  26. goog.require('shaka.util.Error');
  27. goog.require('shaka.util.IDestroyable');
  28. goog.require('shaka.util.Iterables');
  29. goog.require('shaka.util.MimeUtils');
  30. goog.require('shaka.util.Platform');
  31. goog.require('shaka.util.PlayerConfiguration');
  32. goog.require('shaka.util.StreamUtils');
  33. goog.requireType('shaka.media.SegmentReference');
  34. goog.requireType('shaka.offline.StorageCellHandle');
  37. /**
  38.  * @summary
  39.  * This manages persistent offline data including storage, listing, and deleting
  40.  * stored manifests.  Playback of offline manifests are done through the Player
  41.  * using a special URI (see shaka.offline.OfflineUri).
  42.  *
  43.  * First, check support() to see if offline is supported by the platform.
  44.  * Second, configure() the storage object with callbacks to your application.
  45.  * Third, call store(), remove(), or list() as needed.
  46.  * When done, call destroy().
  47.  *
  48.  * @implements {shaka.util.IDestroyable}
  49.  * @export
  50.  */
  51. shaka.offline.Storage = class {
  52.   /**
  53.    * @param {!shaka.Player=} player
  54.    *    A player instance to share a networking engine and configuration with.
  55.    *    When initializing with a player, storage is only valid as long as
  56.    *    |destroy| has not been called on the player instance. When omitted,
  57.    *    storage will manage its own networking engine and configuration.
  58.    */
  59.   constructor(player) {
  60.     // It is an easy mistake to make to pass a Player proxy from CastProxy.
  61.     // Rather than throw a vague exception later, throw an explicit and clear
  62.     // one now.
  63.     //
  64.     // TODO(vaage): After we decide whether or not we want to support
  65.     //  initializing storage with a player proxy, we should either remove
  66.     //  this error or rename the error.
  67.     if (player && player.constructor != shaka.Player) {
  68.       throw new shaka.util.Error(
  69.           shaka.util.Error.Severity.CRITICAL,
  70.           shaka.util.Error.Category.STORAGE,
  71.           shaka.util.Error.Code.LOCAL_PLAYER_INSTANCE_REQUIRED);
  72.     }
  74.     /** @private {?shaka.extern.PlayerConfiguration} */
  75.     this.config_ = null;
  77.     /** @private {shaka.net.NetworkingEngine} */
  78.     this.networkingEngine_ = null;
  80.     // Initialize |config_| and |networkingEngine_| based on whether or not
  81.     // we were given a player instance.
  82.     if (player) {
  83.       this.config_ = player.getSharedConfiguration();
  84.       this.networkingEngine_ = player.getNetworkingEngine();
  86.       goog.asserts.assert(
  87.           this.networkingEngine_,
  88.           'Storage should not be initialized with a player that had ' +
  89.               '|destroy| called on it.');
  90.     } else {
  91.       this.config_ = shaka.util.PlayerConfiguration.createDefault();
  92.       this.networkingEngine_ = new shaka.net.NetworkingEngine();
  93.     }
  95.     /**
  96.      * A list of open operations that are being performed by this instance of
  97.      * |shaka.offline.Storage|.
  98.      *
  99.      * @private {!Array.<!Promise>}
  100.      */
  101.     this.openOperations_ = [];
  103.     /**
  104.      * A list of open download managers that are being used to download things.
  105.      *
  106.      * @private {!Array.<!shaka.offline.DownloadManager>}
  107.      */
  108.     this.openDownloadManagers_ = [];
  110.     /**
  111.      * Storage should only destroy the networking engine if it was initialized
  112.      * without a player instance. Store this as a flag here to avoid including
  113.      * the player object in the destoyer's closure.
  114.      *
  115.      * @type {boolean}
  116.      */
  117.     const destroyNetworkingEngine = !player;
  119.     /** @private {!shaka.util.Destroyer} */
  120.     this.destroyer_ = new shaka.util.Destroyer(async () => {
  121.       // Cancel all in-progress store operations.
  122.       await Promise.all(this.openDownloadManagers_.map((dl) => dl.abortAll()));
  124.       // Wait for all remaining open operations to end. Wrap each operations so
  125.       // that a single rejected promise won't cause |Promise.all| to return
  126.       // early or to return a rejected Promise.
  127.       const noop = () => {};
  128.       const awaits = [];
  129.       for (const op of this.openOperations_) {
  130.         awaits.push(op.then(noop, noop));
  131.       }
  132.       await Promise.all(awaits);
  134.       // Wait until after all the operations have finished before we destroy
  135.       // the networking engine to avoid any unexpected errors.
  136.       if (destroyNetworkingEngine) {
  137.         await this.networkingEngine_.destroy();
  138.       }
  140.       // Drop all references to internal objects to help with GC.
  141.       this.config_ = null;
  142.       this.networkingEngine_ = null;
  143.     });
  144.   }
  147.   /**
  148.    * Gets whether offline storage is supported.  Returns true if offline storage
  149.    * is supported for clear content.  Support for offline storage of encrypted
  150.    * content will not be determined until storage is attempted.
  151.    *
  152.    * @return {boolean}
  153.    * @export
  154.    */
  155.   static support() {
  156.     // Our Storage system is useless without MediaSource.  MediaSource allows us
  157.     // to pull data from anywhere (including our Storage system) and feed it to
  158.     // the video element.
  159.     if (!shaka.util.Platform.supportsMediaSource()) {
  160.       return false;
  161.     }
  163.     return shaka.offline.StorageMuxer.support();
  164.   }
  166.   /**
  167.    * @override
  168.    * @export
  169.    */
  170.   destroy() {
  171.     return this.destroyer_.destroy();
  172.   }
  174.   /**
  175.    * Sets configuration values for Storage.  This is associated with
  176.    * Player.configure and will change the player instance given at
  177.    * initialization.
  178.    *
  179.    * @param {string|!Object} config This should either be a field name or an
  180.    *   object following the form of {@link shaka.extern.PlayerConfiguration},
  181.    *   where you may omit any field you do not wish to change.
  182.    * @param {*=} value This should be provided if the previous parameter
  183.    *   was a string field name.
  184.    * @return {boolean}
  185.    * @export
  186.    */
  187.   configure(config, value) {
  188.     goog.asserts.assert(typeof(config) == 'object' || arguments.length == 2,
  189.         'String configs should have values!');
  191.     // ('fieldName', value) format
  192.     if (arguments.length == 2 && typeof(config) == 'string') {
  193.       config = shaka.util.ConfigUtils.convertToConfigObject(config, value);
  194.     }
  195.     goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
  197.     goog.asserts.assert(
  198.         this.config_, 'Cannot reconfigure storage after calling destroy.');
  199.     return shaka.util.PlayerConfiguration.mergeConfigObjects(
  200.         /* destination= */ this.config_, /* updates= */ config );
  201.   }
  203.   /**
  204.    * Return a copy of the current configuration.  Modifications of the returned
  205.    * value will not affect the Storage instance's active configuration.  You
  206.    * must call storage.configure() to make changes.
  207.    *
  208.    * @return {shaka.extern.PlayerConfiguration}
  209.    * @export
  210.    */
  211.   getConfiguration() {
  212.     goog.asserts.assert(this.config_, 'Config must not be null!');
  214.     const ret = shaka.util.PlayerConfiguration.createDefault();
  215.     shaka.util.PlayerConfiguration.mergeConfigObjects(
  216.         ret, this.config_, shaka.util.PlayerConfiguration.createDefault());
  217.     return ret;
  218.   }
  220.   /**
  221.    * Return the networking engine that storage is using. If storage was
  222.    * initialized with a player instance, then the networking engine returned
  223.    * will be the same as |player.getNetworkingEngine()|.
  224.    *
  225.    * The returned value will only be null if |destroy| was called before
  226.    * |getNetworkingEngine|.
  227.    *
  228.    * @return {shaka.net.NetworkingEngine}
  229.    * @export
  230.    */
  231.   getNetworkingEngine() {
  232.     return this.networkingEngine_;
  233.   }
  235.   /**
  236.    * Stores the given manifest.  If the content is encrypted, and encrypted
  237.    * content cannot be stored on this platform, the Promise will be rejected
  238.    * with error code 6001, REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE.
  239.    * Multiple assets can be downloaded at the same time, but note that since
  240.    * the storage instance has a single networking engine, multiple storage
  241.    * objects will be necessary if some assets require unique network filters.
  242.    * This snapshots the storage config at the time of the call, so it will not
  243.    * honor any changes to config mid-store operation.
  244.    *
  245.    * @param {string} uri The URI of the manifest to store.
  246.    * @param {!Object=} appMetadata An arbitrary object from the application
  247.    *   that will be stored along-side the offline content.  Use this for any
  248.    *   application-specific metadata you need associated with the stored
  249.    *   content.  For details on the data types that can be stored here, please
  250.    *   refer to {@link https://bit.ly/StructClone}
  251.    * @param {string=} mimeType
  252.    *   The mime type for the content |manifestUri| points to.
  253.    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.StoredContent>}
  254.    *   An AbortableOperation that resolves with a structure representing what
  255.    *   was stored.  The "offlineUri" member is the URI that should be given to
  256.    *   Player.load() to play this piece of content offline.  The "appMetadata"
  257.    *   member is the appMetadata argument you passed to store().
  258.    *   If you want to cancel this download, call the "abort" method on
  259.    *   AbortableOperation.
  260.    * @export
  261.    */
  262.   store(uri, appMetadata, mimeType) {
  263.     goog.asserts.assert(
  264.         this.networkingEngine_,
  265.         'Cannot call |store| after calling |destroy|.');
  267.     // Get a copy of the current config.
  268.     const config = this.getConfiguration();
  270.     const getParser = async () => {
  271.       goog.asserts.assert(
  272.           this.networkingEngine_, 'Should not call |store| after |destroy|');
  274.       const factory = await shaka.media.ManifestParser.getFactory(
  275.           uri,
  276.           this.networkingEngine_,
  277.           config.manifest.retryParameters,
  278.           mimeType || null);
  280.       return factory();
  281.     };
  283.     /** @type {!shaka.offline.DownloadManager} */
  284.     const downloader =
  285.         new shaka.offline.DownloadManager(this.networkingEngine_);
  286.     this.openDownloadManagers_.push(downloader);
  288.     const storeOp = this.store_(
  289.         uri, appMetadata || {}, getParser, config, downloader);
  290.     const abortableStoreOp = new shaka.util.AbortableOperation(storeOp, () => {
  291.       return downloader.abortAll();
  292.     });
  293.     abortableStoreOp.finally(() => {
  294.       shaka.util.ArrayUtils.remove(this.openDownloadManagers_, downloader);
  295.     });
  297.     return this.startAbortableOperation_(abortableStoreOp);
  298.   }
  300.   /**
  301.    * See |shaka.offline.Storage.store| for details.
  302.    *
  303.    * @param {string} uri
  304.    * @param {!Object} appMetadata
  305.    * @param {function():!Promise.<shaka.extern.ManifestParser>} getParser
  306.    * @param {shaka.extern.PlayerConfiguration} config
  307.    * @param {!shaka.offline.DownloadManager} downloader
  308.    * @return {!Promise.<shaka.extern.StoredContent>}
  309.    * @private
  310.    */
  311.   async store_(uri, appMetadata, getParser, config, downloader) {
  312.     this.requireSupport_();
  314.     // Since we will need to use |parser|, |drmEngine|, |activeHandle|, and
  315.     // |muxer| in the catch/finally blocks, we need to define them out here.
  316.     // Since they may not get initialized when we enter the catch/finally block,
  317.     // we need to assume that they may be null/undefined when we get there.
  319.     /** @type {?shaka.extern.ManifestParser} */
  320.     let parser = null;
  321.     /** @type {?shaka.media.DrmEngine} */
  322.     let drmEngine = null;
  323.     /** @type {shaka.offline.StorageMuxer} */
  324.     const muxer = new shaka.offline.StorageMuxer();
  325.     /** @type {?shaka.offline.StorageCellHandle} */
  326.     let activeHandle = null;
  327.     /** @type {?number} */
  328.     let manifestId = null;
  330.     // This will be used to store any errors from drm engine. Whenever drm
  331.     // engine is passed to another function to do work, we should check if this
  332.     // was set.
  333.     let drmError = null;
  335.     try {
  336.       parser = await getParser();
  338.       const manifest = await this.parseManifest(uri, parser, config);
  340.       // Check if we were asked to destroy ourselves while we were "away"
  341.       // downloading the manifest.
  342.       this.ensureNotDestroyed_();
  344.       // Check if we can even download this type of manifest before trying to
  345.       // create the drm engine.
  346.       const canDownload = !manifest.presentationTimeline.isLive() &&
  347.                           !manifest.presentationTimeline.isInProgress();
  348.       if (!canDownload) {
  349.         throw new shaka.util.Error(
  350.             shaka.util.Error.Severity.CRITICAL,
  351.             shaka.util.Error.Category.STORAGE,
  352.             shaka.util.Error.Code.CANNOT_STORE_LIVE_OFFLINE,
  353.             uri);
  354.       }
  356.       // Create the DRM engine, and load the keys in the manifest.
  357.       drmEngine = await this.createDrmEngine(
  358.           manifest,
  359.           (e) => { drmError = drmError || e; },
  360.           config);
  362.       // We could have been asked to destroy ourselves while we were "away"
  363.       // creating the drm engine.
  364.       this.ensureNotDestroyed_();
  365.       if (drmError) {
  366.         throw drmError;
  367.       }
  369.       await this.filterManifest_(manifest, drmEngine, config);
  371.       await muxer.init();
  372.       this.ensureNotDestroyed_();
  374.       // Get the cell that we are saving the manifest to. Once we get a cell
  375.       // we will only reference the cell and not the muxer so that the manifest
  376.       // and segments will all be saved to the same cell.
  377.       activeHandle = await muxer.getActive();
  378.       this.ensureNotDestroyed_();
  380.       goog.asserts.assert(drmEngine, 'drmEngine should be non-null here.');
  381.       const {manifestDB, toDownload} = this.makeManifestDB_(
  382.           drmEngine, manifest, uri, appMetadata, config, downloader);
  384.       // Store the empty manifest, before downloading the segments.
  385.       const ids = await activeHandle.cell.addManifests([manifestDB]);
  386.       this.ensureNotDestroyed_();
  387.       manifestId = ids[0];
  389.       goog.asserts.assert(drmEngine, 'drmEngine should be non-null here.');
  390.       this.ensureNotDestroyed_();
  391.       if (drmError) {
  392.         throw drmError;
  393.       }
  395.       await this.downloadSegments_(toDownload, manifestId, manifestDB,
  396.           downloader, config, activeHandle.cell, manifest, drmEngine);
  397.       this.ensureNotDestroyed_();
  399.       const offlineUri = shaka.offline.OfflineUri.manifest(
  400.           activeHandle.path.mechanism, activeHandle.path.cell, manifestId);
  402.       return shaka.offline.StoredContentUtils.fromManifestDB(
  403.           offlineUri, manifestDB);
  404.     } catch (e) {
  405.       if (manifestId != null) {
  406.         await shaka.offline.Storage.cleanStoredManifest(manifestId);
  407.       }
  409.       // If we already had an error, ignore this error to avoid hiding
  410.       // the original error.
  411.       throw drmError || e;
  412.     } finally {
  413.       await muxer.destroy();
  415.       if (parser) {
  416.         await parser.stop();
  417.       }
  419.       if (drmEngine) {
  420.         await drmEngine.destroy();
  421.       }
  422.     }
  423.   }
  425.   /**
  426.    * Download and then store the contents of each segment.
  427.    * The promise this returns will wait for local downloads.
  428.    *
  429.    * @param {!Array.<!shaka.offline.DownloadInfo>} toDownload
  430.    * @param {number} manifestId
  431.    * @param {shaka.extern.ManifestDB} manifestDB
  432.    * @param {!shaka.offline.DownloadManager} downloader
  433.    * @param {shaka.extern.PlayerConfiguration} config
  434.    * @param {shaka.extern.StorageCell} storage
  435.    * @param {shaka.extern.Manifest} manifest
  436.    * @param {!shaka.media.DrmEngine} drmEngine
  437.    * @return {!Promise}
  438.    * @private
  439.    */
  440.   async downloadSegments_(
  441.       toDownload, manifestId, manifestDB, downloader, config, storage,
  442.       manifest, drmEngine) {
  443.     let pendingManifestUpdates = {};
  444.     let pendingDataSize = 0;
  446.     /**
  447.      * @param {!Array.<!shaka.offline.DownloadInfo>} toDownload
  448.      * @param {boolean} updateDRM
  449.      */
  450.     const download = async (toDownload, updateDRM) => {
  451.       for (const download of toDownload) {
  452.         const request = download.makeSegmentRequest(config);
  453.         const estimateId = download.estimateId;
  454.         const isInitSegment = download.isInitSegment;
  456.         const onDownloaded = async (data) => {
  457.           // Store the data.
  458.           const dataKeys = await storage.addSegments([{data}]);
  459.           this.ensureNotDestroyed_();
  461.           // Store the necessary update to the manifest, to be processed later.
  462.           const ref = /** @type {!shaka.media.SegmentReference} */ (
  463.             download.ref);
  464.           const id = shaka.offline.DownloadInfo.idForSegmentRef(ref);
  465.           pendingManifestUpdates[id] = dataKeys[0];
  466.           pendingDataSize += data.byteLength;
  467.         };
  469.         downloader.queue(download.groupId,
  470.             request, estimateId, isInitSegment, onDownloaded);
  471.       }
  472.       await downloader.waitToFinish();
  474.       if (updateDRM) {
  475.         // Re-store the manifest, to attach session IDs.
  476.         // These were (maybe) discovered inside the downloader; we can only add
  477.         // them now, at the end, since the manifestDB is in flux during the
  478.         // process of downloading and storing, and assignSegmentsToManifest
  479.         // does not know about the DRM engine.
  480.         this.ensureNotDestroyed_();
  481.         this.setManifestDrmFields_(manifest, manifestDB, drmEngine, config);
  482.         await storage.updateManifest(manifestId, manifestDB);
  483.       }
  484.     };
  486.     const usingBgFetch = false; // TODO: Get.
  488.     try {
  489.       if (this.getManifestIsEncrypted_(manifest) && usingBgFetch &&
  490.           !this.getManifestIncludesInitData_(manifest)) {
  491.         // Background fetch can't make DRM sessions, so if we have to get the
  492.         // init data from the init segments, download those first before
  493.         // anything else.
  494.         await download(toDownload.filter((info) => info.isInitSegment), true);
  495.         this.ensureNotDestroyed_();
  496.         toDownload = toDownload.filter((info) => !info.isInitSegment);
  498.         // Copy these and reset them now, before calling await.
  499.         const manifestUpdates = pendingManifestUpdates;
  500.         const dataSize = pendingDataSize;
  501.         pendingManifestUpdates = {};
  502.         pendingDataSize = 0;
  504.         await shaka.offline.Storage.assignSegmentsToManifest(
  505.             storage, manifestId, manifestDB, manifestUpdates, dataSize,
  506.             () => this.ensureNotDestroyed_());
  507.         this.ensureNotDestroyed_();
  508.       }
  510.       if (!usingBgFetch) {
  511.         await download(toDownload, false);
  512.         this.ensureNotDestroyed_();
  514.         // Copy these and reset them now, before calling await.
  515.         const manifestUpdates = pendingManifestUpdates;
  516.         const dataSize = pendingDataSize;
  517.         pendingManifestUpdates = {};
  518.         pendingDataSize = 0;
  520.         await shaka.offline.Storage.assignSegmentsToManifest(
  521.             storage, manifestId, manifestDB, manifestUpdates, dataSize,
  522.             () => this.ensureNotDestroyed_());
  523.         this.ensureNotDestroyed_();
  525.         goog.asserts.assert(
  526.             !manifestDB.isIncomplete, 'The manifest should be complete by now');
  527.       } else {
  528.         // TODO: Send the request to the service worker. Don't await the result.
  529.       }
  530.     } catch (error) {
  531.       const dataKeys = Object.values(pendingManifestUpdates);
  532.       // Remove these pending segments that are not yet linked to the manifest.
  533.       await storage.removeSegments(dataKeys, (key) => {});
  535.       throw error;
  536.     }
  537.   }
  539.   /**
  540.    * Removes all of the contents for a given manifest, statelessly.
  541.    *
  542.    * @param {number} manifestId
  543.    * @return {!Promise}
  544.    */
  545.   static async cleanStoredManifest(manifestId) {
  546.     const muxer = new shaka.offline.StorageMuxer();
  547.     await muxer.init();
  548.     const activeHandle = await muxer.getActive();
  549.     const uri = shaka.offline.OfflineUri.manifest(
  550.         activeHandle.path.mechanism,
  551.         activeHandle.path.cell,
  552.         manifestId);
  553.     await muxer.destroy();
  554.     const storage = new shaka.offline.Storage();
  555.     await storage.remove(uri.toString());
  556.   }
  558.   /**
  559.    * Updates the given manifest, assigns database keys to segments, then stores
  560.    * the updated manifest.
  561.    *
  562.    * It is up to the caller to ensure that this method is not called
  563.    * concurrently on the same manifest.
  564.    *
  565.    * @param {shaka.extern.StorageCell} storage
  566.    * @param {number} manifestId
  567.    * @param {!shaka.extern.ManifestDB} manifestDB
  568.    * @param {!Object.<string, number>} manifestUpdates
  569.    * @param {number} dataSizeUpdate
  570.    * @param {function()} throwIfAbortedFn  A function that should throw if the
  571.    *   download has been aborted.
  572.    * @return {!Promise}
  573.    */
  574.   static async assignSegmentsToManifest(
  575.       storage, manifestId, manifestDB, manifestUpdates, dataSizeUpdate,
  576.       throwIfAbortedFn) {
  577.     let manifestUpdated = false;
  579.     try {
  580.       // Assign the stored data to the manifest.
  581.       let complete = true;
  582.       for (const stream of manifestDB.streams) {
  583.         for (const segment of stream.segments) {
  584.           let dataKey = segment.pendingSegmentRefId ?
  585.               manifestUpdates[segment.pendingSegmentRefId] : null;
  586.           if (dataKey != null) {
  587.             segment.dataKey = dataKey;
  588.             // Now that the segment has been associated with the appropriate
  589.             // dataKey, the pendingSegmentRefId is no longer necessary.
  590.             segment.pendingSegmentRefId = undefined;
  591.           }
  593.           dataKey = segment.pendingInitSegmentRefId ?
  594.               manifestUpdates[segment.pendingInitSegmentRefId] : null;
  595.           if (dataKey != null) {
  596.             segment.initSegmentKey = dataKey;
  597.             // Now that the init segment has been associated with the
  598.             // appropriate initSegmentKey, the pendingInitSegmentRefId is no
  599.             // longer necessary.
  600.             segment.pendingInitSegmentRefId = undefined;
  601.           }
  603.           if (segment.pendingSegmentRefId) {
  604.             complete = false;
  605.           }
  606.           if (segment.pendingInitSegmentRefId) {
  607.             complete = false;
  608.           }
  609.         }
  610.       }
  612.       // Update the size of the manifest.
  613.       manifestDB.size += dataSizeUpdate;
  615.       // Mark the manifest as complete, if all segments are downloaded.
  616.       if (complete) {
  617.         manifestDB.isIncomplete = false;
  618.       }
  620.       // Update the manifest.
  621.       await storage.updateManifest(manifestId, manifestDB);
  622.       manifestUpdated = true;
  623.       throwIfAbortedFn();
  624.     } catch (e) {
  625.       await shaka.offline.Storage.cleanStoredManifest(manifestId);
  627.       if (!manifestUpdated) {
  628.         const dataKeys = Object.values(manifestUpdates);
  629.         // The cleanStoredManifest method will not "see" any segments that have
  630.         // been downloaded but not assigned to the manifest yet. So un-store
  631.         // them separately.
  632.         await storage.removeSegments(dataKeys, (key) => {});
  633.       }
  635.       throw e;
  636.     }
  637.   }
  639.   /**
  640.    * Filter |manifest| such that it will only contain the variants and text
  641.    * streams that we want to store and can actually play.
  642.    *
  643.    * @param {shaka.extern.Manifest} manifest
  644.    * @param {!shaka.media.DrmEngine} drmEngine
  645.    * @param {shaka.extern.PlayerConfiguration} config
  646.    * @return {!Promise}
  647.    * @private
  648.    */
  649.   async filterManifest_(manifest, drmEngine, config) {
  650.     // Filter the manifest based on the restrictions given in the player
  651.     // configuration.
  652.     const maxHwRes = {width: Infinity, height: Infinity};
  653.     shaka.util.StreamUtils.filterByRestrictions(
  654.         manifest, config.restrictions, maxHwRes);
  656.     // Filter the manifest based on what we know MediaCapabilities will be able
  657.     // to play later (no point storing something we can't play).
  658.     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
  659.         manifest, config.offline.usePersistentLicense);
  661.     // Gather all tracks.
  662.     const allTracks = [];
  664.     // Choose the codec that has the lowest average bandwidth.
  665.     const preferredAudioChannelCount = config.preferredAudioChannelCount;
  666.     const preferredDecodingAttributes = config.preferredDecodingAttributes;
  667.     const preferredVideoCodecs = config.preferredVideoCodecs;
  668.     const preferredAudioCodecs = config.preferredAudioCodecs;
  670.     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  671.         manifest, preferredVideoCodecs, preferredAudioCodecs,
  672.         preferredAudioChannelCount, preferredDecodingAttributes);
  674.     for (const variant of manifest.variants) {
  675.       goog.asserts.assert(
  676.           shaka.util.StreamUtils.isPlayable(variant),
  677.           'We should have already filtered by "is playable"');
  679.       allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
  680.     }
  682.     for (const text of manifest.textStreams) {
  683.       allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
  684.     }
  686.     for (const image of manifest.imageStreams) {
  687.       allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
  688.     }
  690.     // Let the application choose which tracks to store.
  691.     const chosenTracks =
  692.         await config.offline.trackSelectionCallback(allTracks);
  693.     const duration = manifest.presentationTimeline.getDuration();
  694.     let sizeEstimate = 0;
  695.     for (const track of chosenTracks) {
  696.       const trackSize = track.bandwidth * duration / 8;
  697.       sizeEstimate += trackSize;
  698.     }
  699.     try {
  700.       const allowedDownload =
  701.           await config.offline.downloadSizeCallback(sizeEstimate);
  702.       if (!allowedDownload) {
  703.         throw new shaka.util.Error(
  704.             shaka.util.Error.Severity.CRITICAL,
  705.             shaka.util.Error.Category.STORAGE,
  706.             shaka.util.Error.Code.STORAGE_LIMIT_REACHED);
  707.       }
  708.     } catch (e) {
  709.       // It is necessary to be able to catch the STORAGE_LIMIT_REACHED error
  710.       if (e instanceof shaka.util.Error) {
  711.         throw e;
  712.       }
  713.       shaka.log.warning(
  714.           'downloadSizeCallback has produced an unexpected error', e);
  715.       throw new shaka.util.Error(
  716.           shaka.util.Error.Severity.CRITICAL,
  717.           shaka.util.Error.Category.STORAGE,
  718.           shaka.util.Error.Code.DOWNLOAD_SIZE_CALLBACK_ERROR);
  719.     }
  721.     /** @type {!Set.<number>} */
  722.     const variantIds = new Set();
  723.     /** @type {!Set.<number>} */
  724.     const textIds = new Set();
  725.     /** @type {!Set.<number>} */
  726.     const imageIds = new Set();
  728.     // Collect the IDs of the chosen tracks.
  729.     for (const track of chosenTracks) {
  730.       if (track.type == 'variant') {
  731.         variantIds.add(track.id);
  732.       }
  733.       if (track.type == 'text') {
  734.         textIds.add(track.id);
  735.       }
  736.       if (track.type == 'image') {
  737.         imageIds.add(track.id);
  738.       }
  739.     }
  741.     // Filter the manifest to keep only what the app chose.
  742.     manifest.variants =
  743.         manifest.variants.filter((variant) => variantIds.has(variant.id));
  744.     manifest.textStreams =
  745.         manifest.textStreams.filter((stream) => textIds.has(stream.id));
  746.     manifest.imageStreams =
  747.         manifest.imageStreams.filter((stream) => imageIds.has(stream.id));
  749.     // Check the post-filtered manifest for characteristics that may indicate
  750.     // issues with how the app selected tracks.
  751.     shaka.offline.Storage.validateManifest_(manifest);
  752.   }
  754.   /**
  755.    * Create a download manager and download the manifest.
  756.    * This also sets up download infos for each segment to be downloaded.
  757.    *
  758.    * @param {!shaka.media.DrmEngine} drmEngine
  759.    * @param {shaka.extern.Manifest} manifest
  760.    * @param {string} uri
  761.    * @param {!Object} metadata
  762.    * @param {shaka.extern.PlayerConfiguration} config
  763.    * @param {!shaka.offline.DownloadManager} downloader
  764.    * @return {{
  765.    *   manifestDB: shaka.extern.ManifestDB,
  766.    *   toDownload: !Array.<!shaka.offline.DownloadInfo>
  767.    * }}
  768.    * @private
  769.    */
  770.   makeManifestDB_(drmEngine, manifest, uri, metadata, config, downloader) {
  771.     const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
  772.         uri, manifest, /* size= */ 0, metadata);
  773.     // In https://github.com/shaka-project/shaka-player/issues/2652, we found
  774.     // that this callback would be removed by the compiler if we reference the
  775.     // config in the onProgress closure below.  Reading it into a local
  776.     // variable first seems to work around this apparent compiler bug.
  777.     const progressCallback = config.offline.progressCallback;
  779.     const onProgress = (progress, size) => {
  780.       // Update the size of the stored content before issuing a progress
  781.       // update.
  782.       pendingContent.size = size;
  783.       progressCallback(pendingContent, progress);
  784.     };
  785.     const onInitData = (initData, systemId) => {
  786.       if (needsInitData && config.offline.usePersistentLicense &&
  787.           currentSystemId == systemId) {
  788.         drmEngine.newInitData('cenc', initData);
  789.       }
  790.     };
  791.     downloader.setCallbacks(onProgress, onInitData);
  793.     const needsInitData = this.getManifestIsEncrypted_(manifest) &&
  794.                           !this.getManifestIncludesInitData_(manifest);
  796.     let currentSystemId = null;
  797.     if (needsInitData) {
  798.       const drmInfo = drmEngine.getDrmInfo();
  799.       currentSystemId =
  800.           shaka.offline.Storage.defaultSystemIds_.get(drmInfo.keySystem);
  801.     }
  803.     // Make the estimator, which is used to make the download registries.
  804.     const estimator = new shaka.offline.StreamBandwidthEstimator();
  805.     for (const stream of manifest.textStreams) {
  806.       estimator.addText(stream);
  807.     }
  808.     for (const stream of manifest.imageStreams) {
  809.       estimator.addImage(stream);
  810.     }
  811.     for (const variant of manifest.variants) {
  812.       estimator.addVariant(variant);
  813.     }
  814.     const {streams, toDownload} = this.createStreams_(
  815.         downloader, estimator, drmEngine, manifest, config);
  817.     const drmInfo = drmEngine.getDrmInfo();
  818.     const usePersistentLicense = config.offline.usePersistentLicense;
  819.     if (drmInfo && usePersistentLicense) {
  820.       // Don't store init data, since we have stored sessions.
  821.       drmInfo.initData = [];
  822.     }
  824.     const manifestDB = {
  825.       creationTime: Date.now(),
  826.       originalManifestUri: uri,
  827.       duration: manifest.presentationTimeline.getDuration(),
  828.       size: 0,
  829.       expiration: drmEngine.getExpiration(),
  830.       streams,
  831.       sessionIds: usePersistentLicense ? drmEngine.getSessionIds() : [],
  832.       drmInfo,
  833.       appMetadata: metadata,
  834.       isIncomplete: true,
  835.       sequenceMode: manifest.sequenceMode,
  836.     };
  838.     return {manifestDB, toDownload};
  839.   }
  841.   /**
  842.    * @param {shaka.extern.Manifest} manifest
  843.    * @return {boolean}
  844.    * @private
  845.    */
  846.   getManifestIsEncrypted_(manifest) {
  847.     return manifest.variants.some((variant) => {
  848.       const videoEncrypted = variant.video && variant.video.encrypted;
  849.       const audioEncrypted = variant.audio && variant.audio.encrypted;
  850.       return videoEncrypted || audioEncrypted;
  851.     });
  852.   }
  854.   /**
  855.    * @param {shaka.extern.Manifest} manifest
  856.    * @return {boolean}
  857.    * @private
  858.    */
  859.   getManifestIncludesInitData_(manifest) {
  860.     return manifest.variants.some((variant) => {
  861.       const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  862.       const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  863.       const drmInfos = videoDrmInfos.concat(audioDrmInfos);
  864.       return drmInfos.some((drmInfos) => {
  865.         return drmInfos.initData && drmInfos.initData.length;
  866.       });
  867.     });
  868.   }
  870.   /**
  871.    * @param {shaka.extern.Manifest} manifest
  872.    * @param {shaka.extern.ManifestDB} manifestDB
  873.    * @param {!shaka.media.DrmEngine} drmEngine
  874.    * @param {shaka.extern.PlayerConfiguration} config
  875.    * @private
  876.    */
  877.   setManifestDrmFields_(manifest, manifestDB, drmEngine, config) {
  878.     manifestDB.expiration = drmEngine.getExpiration();
  880.     const sessions = drmEngine.getSessionIds();
  881.     manifestDB.sessionIds = config.offline.usePersistentLicense ?
  882.         sessions : [];
  884.     if (this.getManifestIsEncrypted_(manifest) &&
  885.         config.offline.usePersistentLicense && !sessions.length) {
  886.       throw new shaka.util.Error(
  887.           shaka.util.Error.Severity.CRITICAL,
  888.           shaka.util.Error.Category.STORAGE,
  889.           shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE);
  890.     }
  891.   }
  893.   /**
  894.    * Removes the given stored content.  This will also attempt to release the
  895.    * licenses, if any.
  896.    *
  897.    * @param {string} contentUri
  898.    * @return {!Promise}
  899.    * @export
  900.    */
  901.   remove(contentUri) {
  902.     return this.startOperation_(this.remove_(contentUri));
  903.   }
  905.   /**
  906.    * See |shaka.offline.Storage.remove| for details.
  907.    *
  908.    * @param {string} contentUri
  909.    * @return {!Promise}
  910.    * @private
  911.    */
  912.   async remove_(contentUri) {
  913.     this.requireSupport_();
  915.     const nullableUri = shaka.offline.OfflineUri.parse(contentUri);
  916.     if (nullableUri == null || !nullableUri.isManifest()) {
  917.       throw new shaka.util.Error(
  918.           shaka.util.Error.Severity.CRITICAL,
  919.           shaka.util.Error.Category.STORAGE,
  920.           shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  921.           contentUri);
  922.     }
  924.     /** @type {!shaka.offline.OfflineUri} */
  925.     const uri = nullableUri;
  927.     /** @type {!shaka.offline.StorageMuxer} */
  928.     const muxer = new shaka.offline.StorageMuxer();
  930.     try {
  931.       await muxer.init();
  933.       const cell = await muxer.getCell(uri.mechanism(), uri.cell());
  934.       const manifests = await cell.getManifests([uri.key()]);
  935.       const manifest = manifests[0];
  937.       await Promise.all([
  938.         this.removeFromDRM_(uri, manifest, muxer),
  939.         this.removeFromStorage_(cell, uri, manifest),
  940.       ]);
  941.     } finally {
  942.       await muxer.destroy();
  943.     }
  944.   }
  946.   /**
  947.    * @param {shaka.extern.ManifestDB} manifestDb
  948.    * @param {boolean} isVideo
  949.    * @return {!Array.<MediaKeySystemMediaCapability>}
  950.    * @private
  951.    */
  952.   static getCapabilities_(manifestDb, isVideo) {
  953.     const MimeUtils = shaka.util.MimeUtils;
  955.     const ret = [];
  956.     for (const stream of manifestDb.streams) {
  957.       if (isVideo && stream.type == 'video') {
  958.         ret.push({
  959.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  960.           robustness: manifestDb.drmInfo.videoRobustness,
  961.         });
  962.       } else if (!isVideo && stream.type == 'audio') {
  963.         ret.push({
  964.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  965.           robustness: manifestDb.drmInfo.audioRobustness,
  966.         });
  967.       }
  968.     }
  969.     return ret;
  970.   }
  972.   /**
  973.    * @param {!shaka.offline.OfflineUri} uri
  974.    * @param {shaka.extern.ManifestDB} manifestDb
  975.    * @param {!shaka.offline.StorageMuxer} muxer
  976.    * @return {!Promise}
  977.    * @private
  978.    */
  979.   async removeFromDRM_(uri, manifestDb, muxer) {
  980.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  981.     await shaka.offline.Storage.deleteLicenseFor_(
  982.         this.networkingEngine_, this.config_.drm, muxer, manifestDb);
  983.   }
  985.   /**
  986.    * @param {shaka.extern.StorageCell} storage
  987.    * @param {!shaka.offline.OfflineUri} uri
  988.    * @param {shaka.extern.ManifestDB} manifest
  989.    * @return {!Promise}
  990.    * @private
  991.    */
  992.   removeFromStorage_(storage, uri, manifest) {
  993.     /** @type {!Array.<number>} */
  994.     const segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
  996.     // Count(segments) + Count(manifests)
  997.     const toRemove = segmentIds.length + 1;
  998.     let removed = 0;
  1000.     const pendingContent = shaka.offline.StoredContentUtils.fromManifestDB(
  1001.         uri, manifest);
  1003.     const onRemove = (key) => {
  1004.       removed += 1;
  1005.       this.config_.offline.progressCallback(pendingContent, removed / toRemove);
  1006.     };
  1008.     return Promise.all([
  1009.       storage.removeSegments(segmentIds, onRemove),
  1010.       storage.removeManifests([uri.key()], onRemove),
  1011.     ]);
  1012.   }
  1014.   /**
  1015.    * Removes any EME sessions that were not successfully removed before.  This
  1016.    * returns whether all the sessions were successfully removed.
  1017.    *
  1018.    * @return {!Promise.<boolean>}
  1019.    * @export
  1020.    */
  1021.   removeEmeSessions() {
  1022.     return this.startOperation_(this.removeEmeSessions_());
  1023.   }
  1025.   /**
  1026.    * @return {!Promise.<boolean>}
  1027.    * @private
  1028.    */
  1029.   async removeEmeSessions_() {
  1030.     this.requireSupport_();
  1032.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  1033.     const net = this.networkingEngine_;
  1034.     const config = this.config_.drm;
  1036.     /** @type {!shaka.offline.StorageMuxer} */
  1037.     const muxer = new shaka.offline.StorageMuxer();
  1038.     /** @type {!shaka.offline.SessionDeleter} */
  1039.     const deleter = new shaka.offline.SessionDeleter();
  1041.     let hasRemaining = false;
  1043.     try {
  1044.       await muxer.init();
  1046.       /** @type {!Array.<shaka.extern.EmeSessionStorageCell>} */
  1047.       const cells = [];
  1048.       muxer.forEachEmeSessionCell((c) => cells.push(c));
  1050.       // Run these sequentially to avoid creating too many DrmEngine instances
  1051.       // and having multiple CDMs alive at once.  Some embedded platforms may
  1052.       // not support that.
  1053.       for (const sessionIdCell of cells) {
  1054.         /* eslint-disable no-await-in-loop */
  1055.         const sessions = await sessionIdCell.getAll();
  1056.         const deletedSessionIds = await deleter.delete(config, net, sessions);
  1057.         await sessionIdCell.remove(deletedSessionIds);
  1059.         if (deletedSessionIds.length != sessions.length) {
  1060.           hasRemaining = true;
  1061.         }
  1062.         /* eslint-enable no-await-in-loop */
  1063.       }
  1064.     } finally {
  1065.       await muxer.destroy();
  1066.     }
  1068.     return !hasRemaining;
  1069.   }
  1071.   /**
  1072.    * Lists all the stored content available.
  1073.    *
  1074.    * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}  A Promise to an
  1075.    *   array of structures representing all stored content.  The "offlineUri"
  1076.    *   member of the structure is the URI that should be given to Player.load()
  1077.    *   to play this piece of content offline.  The "appMetadata" member is the
  1078.    *   appMetadata argument you passed to store().
  1079.    * @export
  1080.    */
  1081.   list() {
  1082.     return this.startOperation_(this.list_());
  1083.   }
  1085.   /**
  1086.    * See |shaka.offline.Storage.list| for details.
  1087.    *
  1088.    * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}
  1089.    * @private
  1090.    */
  1091.   async list_() {
  1092.     this.requireSupport_();
  1094.     /** @type {!Array.<shaka.extern.StoredContent>} */
  1095.     const result = [];
  1097.     /** @type {!shaka.offline.StorageMuxer} */
  1098.     const muxer = new shaka.offline.StorageMuxer();
  1099.     try {
  1100.       await muxer.init();
  1102.       let p = Promise.resolve();
  1103.       muxer.forEachCell((path, cell) => {
  1104.         p = p.then(async () => {
  1105.           const manifests = await cell.getAllManifests();
  1107.           manifests.forEach((manifest, key) => {
  1108.             const uri = shaka.offline.OfflineUri.manifest(
  1109.                 path.mechanism,
  1110.                 path.cell,
  1111.                 key);
  1113.             const content = shaka.offline.StoredContentUtils.fromManifestDB(
  1114.                 uri,
  1115.                 manifest);
  1117.             result.push(content);
  1118.           });
  1119.         });
  1120.       });
  1122.       await p;
  1123.     } finally {
  1124.       await muxer.destroy();
  1125.     }
  1127.     return result;
  1128.   }
  1131.   /**
  1132.    * This method is public so that it can be overridden in testing.
  1133.    *
  1134.    * @param {string} uri
  1135.    * @param {shaka.extern.ManifestParser} parser
  1136.    * @param {shaka.extern.PlayerConfiguration} config
  1137.    * @return {!Promise.<shaka.extern.Manifest>}
  1138.    */
  1139.   async parseManifest(uri, parser, config) {
  1140.     let error = null;
  1142.     const networkingEngine = this.networkingEngine_;
  1143.     goog.asserts.assert(networkingEngine, 'Should be initialized!');
  1145.     /** @type {shaka.extern.ManifestParser.PlayerInterface} */
  1146.     const playerInterface = {
  1147.       networkingEngine: networkingEngine,
  1149.       // No need to apply CMCD data for offline requests
  1150.       modifyManifestRequest: (request, manifestInfo) => {},
  1151.       modifySegmentRequest: (request, segmentInfo) => {},
  1153.       // Don't bother filtering now. We will do that later when we have all the
  1154.       // information we need to filter.
  1155.       filter: () => Promise.resolve(),
  1157.       // The responsibility for making mock text streams for closed captions is
  1158.       // handled inside shaka.offline.OfflineManifestParser, before playback.
  1159.       makeTextStreamsForClosedCaptions: (manifest) => {},
  1161.       onTimelineRegionAdded: () => {},
  1162.       onEvent: () => {},
  1164.       // Used to capture an error from the manifest parser. We will check the
  1165.       // error before returning.
  1166.       onError: (e) => {
  1167.         error = e;
  1168.       },
  1169.       isLowLatencyMode: () => false,
  1170.       isAutoLowLatencyMode: () => false,
  1171.       enableLowLatencyMode: () => {},
  1172.     };
  1174.     parser.configure(config.manifest);
  1176.     // We may have been destroyed while we were waiting on |getParser| to
  1177.     // resolve.
  1178.     this.ensureNotDestroyed_();
  1180.     const manifest = await parser.start(uri, playerInterface);
  1182.     // We may have been destroyed while we were waiting on |start| to
  1183.     // resolve.
  1184.     this.ensureNotDestroyed_();
  1186.     // Get all the streams that are used in the manifest.
  1187.     const streams =
  1188.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1190.     // Wait for each stream to create their segment indexes.
  1191.     await Promise.all(shaka.util.Iterables.map(streams, (stream) => {
  1192.       return stream.createSegmentIndex();
  1193.     }));
  1195.     // We may have been destroyed while we were waiting on
  1196.     // |createSegmentIndex| to resolve for each stream.
  1197.     this.ensureNotDestroyed_();
  1199.     // If we saw an error while parsing, surface the error.
  1200.     if (error) {
  1201.       throw error;
  1202.     }
  1204.     return manifest;
  1205.   }
  1207.   /**
  1208.    * This method is public so that it can be override in testing.
  1209.    *
  1210.    * @param {shaka.extern.Manifest} manifest
  1211.    * @param {function(shaka.util.Error)} onError
  1212.    * @param {shaka.extern.PlayerConfiguration} config
  1213.    * @return {!Promise.<!shaka.media.DrmEngine>}
  1214.    */
  1215.   async createDrmEngine(manifest, onError, config) {
  1216.     goog.asserts.assert(
  1217.         this.networkingEngine_,
  1218.         'Cannot call |createDrmEngine| after |destroy|');
  1220.     /** @type {!shaka.media.DrmEngine} */
  1221.     const drmEngine = new shaka.media.DrmEngine({
  1222.       netEngine: this.networkingEngine_,
  1223.       onError: onError,
  1224.       onKeyStatus: () => {},
  1225.       onExpirationUpdated: () => {},
  1226.       onEvent: () => {},
  1227.     });
  1229.     drmEngine.configure(config.drm);
  1230.     await drmEngine.initForStorage(
  1231.         manifest.variants, config.offline.usePersistentLicense);
  1232.     await drmEngine.setServerCertificate();
  1233.     await drmEngine.createOrLoad();
  1235.     return drmEngine;
  1236.   }
  1238.   /**
  1239.    * Converts manifest Streams to database Streams.
  1240.    *
  1241.    * @param {!shaka.offline.DownloadManager} downloader
  1242.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1243.    * @param {!shaka.media.DrmEngine} drmEngine
  1244.    * @param {shaka.extern.Manifest} manifest
  1245.    * @param {shaka.extern.PlayerConfiguration} config
  1246.    * @return {{
  1247.    *   streams: !Array.<shaka.extern.StreamDB>,
  1248.    *   toDownload: !Array.<!shaka.offline.DownloadInfo>
  1249.    * }}
  1250.    * @private
  1251.    */
  1252.   createStreams_(downloader, estimator, drmEngine, manifest, config) {
  1253.     // Download infos are stored based on their refId, to dedup them.
  1254.     /** @type {!Map.<string, !shaka.offline.DownloadInfo>} */
  1255.     const toDownload = new Map();
  1257.     // Find the streams we want to download and create a stream db instance
  1258.     // for each of them.
  1259.     const streamSet =
  1260.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1261.     const streamDBs = new Map();
  1263.     for (const stream of streamSet) {
  1264.       const streamDB = this.createStream_(
  1265.           downloader, estimator, manifest, stream, config, toDownload);
  1266.       streamDBs.set(stream.id, streamDB);
  1267.     }
  1269.     // Connect streams and variants together.
  1270.     for (const variant of manifest.variants) {
  1271.       if (variant.audio) {
  1272.         streamDBs.get(variant.audio.id).variantIds.push(variant.id);
  1273.       }
  1274.       if (variant.video) {
  1275.         streamDBs.get(variant.video.id).variantIds.push(variant.id);
  1276.       }
  1277.     }
  1279.     return {
  1280.       streams: Array.from(streamDBs.values()),
  1281.       toDownload: Array.from(toDownload.values()),
  1282.     };
  1283.   }
  1285.   /**
  1286.    * Converts a manifest stream to a database stream.  This will search the
  1287.    * segment index and add all the segments to the download infos.
  1288.    *
  1289.    * @param {!shaka.offline.DownloadManager} downloader
  1290.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1291.    * @param {shaka.extern.Manifest} manifest
  1292.    * @param {shaka.extern.Stream} stream
  1293.    * @param {shaka.extern.PlayerConfiguration} config
  1294.    * @param {!Map.<string, !shaka.offline.DownloadInfo>} toDownload
  1295.    * @return {shaka.extern.StreamDB}
  1296.    * @private
  1297.    */
  1298.   createStream_(downloader, estimator, manifest, stream, config, toDownload) {
  1299.     /** @type {shaka.extern.StreamDB} */
  1300.     const streamDb = {
  1301.       id: stream.id,
  1302.       originalId: stream.originalId,
  1303.       primary: stream.primary,
  1304.       type: stream.type,
  1305.       mimeType: stream.mimeType,
  1306.       codecs: stream.codecs,
  1307.       frameRate: stream.frameRate,
  1308.       pixelAspectRatio: stream.pixelAspectRatio,
  1309.       hdr: stream.hdr,
  1310.       kind: stream.kind,
  1311.       language: stream.language,
  1312.       label: stream.label,
  1313.       width: stream.width || null,
  1314.       height: stream.height || null,
  1315.       encrypted: stream.encrypted,
  1316.       keyIds: stream.keyIds,
  1317.       segments: [],
  1318.       variantIds: [],
  1319.       roles: stream.roles,
  1320.       forced: stream.forced,
  1321.       channelsCount: stream.channelsCount,
  1322.       audioSamplingRate: stream.audioSamplingRate,
  1323.       spatialAudio: stream.spatialAudio,
  1324.       closedCaptions: stream.closedCaptions,
  1325.       tilesLayout: stream.tilesLayout,
  1326.     };
  1328.     const startTime =
  1329.         manifest.presentationTimeline.getSegmentAvailabilityStart();
  1331.     const numberOfParallelDownloads = config.offline.numberOfParallelDownloads;
  1332.     let groupId = 0;
  1334.     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
  1335.       const pendingSegmentRefId =
  1336.           shaka.offline.DownloadInfo.idForSegmentRef(segment);
  1337.       let pendingInitSegmentRefId = undefined;
  1339.       // Set up the download for the segment, which will be downloaded later,
  1340.       // perhaps in a service worker.
  1341.       if (!toDownload.has(pendingSegmentRefId)) {
  1342.         const estimateId = downloader.addDownloadEstimate(
  1343.             estimator.getSegmentEstimate(stream.id, segment));
  1344.         const segmentDownload = new shaka.offline.DownloadInfo(
  1345.             segment,
  1346.             estimateId,
  1347.             groupId,
  1348.             /* isInitSegment= */ false);
  1349.         toDownload.set(pendingSegmentRefId, segmentDownload);
  1350.       }
  1352.       // Set up the download for the init segment, similarly, if there is one.
  1353.       if (segment.initSegmentReference) {
  1354.         pendingInitSegmentRefId = shaka.offline.DownloadInfo.idForSegmentRef(
  1355.             segment.initSegmentReference);
  1356.         if (!toDownload.has(pendingInitSegmentRefId)) {
  1357.           const estimateId = downloader.addDownloadEstimate(
  1358.               estimator.getInitSegmentEstimate(stream.id));
  1359.           const initDownload = new shaka.offline.DownloadInfo(
  1360.               segment.initSegmentReference,
  1361.               estimateId,
  1362.               groupId,
  1363.               /* isInitSegment= */ true);
  1364.           toDownload.set(pendingInitSegmentRefId, initDownload);
  1365.         }
  1366.       }
  1368.       /** @type {!shaka.extern.SegmentDB} */
  1369.       const segmentDB = {
  1370.         pendingInitSegmentRefId,
  1371.         initSegmentKey: pendingInitSegmentRefId ? 0 : null,
  1372.         startTime: segment.startTime,
  1373.         endTime: segment.endTime,
  1374.         appendWindowStart: segment.appendWindowStart,
  1375.         appendWindowEnd: segment.appendWindowEnd,
  1376.         timestampOffset: segment.timestampOffset,
  1377.         tilesLayout: segment.tilesLayout,
  1378.         pendingSegmentRefId,
  1379.         dataKey: 0,
  1380.       };
  1381.       streamDb.segments.push(segmentDB);
  1382.       groupId = (groupId + 1) % numberOfParallelDownloads;
  1383.     });
  1385.     return streamDb;
  1386.   }
  1388.   /**
  1389.    * @param {shaka.extern.Stream} stream
  1390.    * @param {number} startTime
  1391.    * @param {function(!shaka.media.SegmentReference)} callback
  1392.    * @private
  1393.    */
  1394.   static forEachSegment_(stream, startTime, callback) {
  1395.     /** @type {?number} */
  1396.     let i = stream.segmentIndex.find(startTime);
  1398.     if (i == null) {
  1399.       return;
  1400.     }
  1402.     /** @type {?shaka.media.SegmentReference} */
  1403.     let ref = stream.segmentIndex.get(i);
  1404.     while (ref) {
  1405.       callback(ref);
  1406.       ref = stream.segmentIndex.get(++i);
  1407.     }
  1408.   }
  1410.   /**
  1411.    * Throws an error if the object is destroyed.
  1412.    * @private
  1413.    */
  1414.   ensureNotDestroyed_() {
  1415.     if (this.destroyer_.destroyed()) {
  1416.       throw new shaka.util.Error(
  1417.           shaka.util.Error.Severity.CRITICAL,
  1418.           shaka.util.Error.Category.STORAGE,
  1419.           shaka.util.Error.Code.OPERATION_ABORTED);
  1420.     }
  1421.   }
  1423.   /**
  1424.    * Used by functions that need storage support to ensure that the current
  1425.    * platform has storage support before continuing. This should only be
  1426.    * needed to be used at the start of public methods.
  1427.    *
  1428.    * @private
  1429.    */
  1430.   requireSupport_() {
  1431.     if (!shaka.offline.Storage.support()) {
  1432.       throw new shaka.util.Error(
  1433.           shaka.util.Error.Severity.CRITICAL,
  1434.           shaka.util.Error.Category.STORAGE,
  1435.           shaka.util.Error.Code.STORAGE_NOT_SUPPORTED);
  1436.     }
  1437.   }
  1439.   /**
  1440.    * Perform an action. Track the action's progress so that when we destroy
  1441.    * we will wait until all the actions have completed before allowing destroy
  1442.    * to resolve.
  1443.    *
  1444.    * @param {!Promise<T>} action
  1445.    * @return {!Promise<T>}
  1446.    * @template T
  1447.    * @private
  1448.    */
  1449.   async startOperation_(action) {
  1450.     this.openOperations_.push(action);
  1452.     try {
  1453.       // Await |action| so we can use the finally statement to remove |action|
  1454.       // from |openOperations_| when we still have a reference to |action|.
  1455.       return await action;
  1456.     } finally {
  1457.       shaka.util.ArrayUtils.remove(this.openOperations_, action);
  1458.     }
  1459.   }
  1461.   /**
  1462.    * The equivalent of startOperation_, but for abortable operations.
  1463.    *
  1464.    * @param {!shaka.extern.IAbortableOperation<T>} action
  1465.    * @return {!shaka.extern.IAbortableOperation<T>}
  1466.    * @template T
  1467.    * @private
  1468.    */
  1469.   startAbortableOperation_(action) {
  1470.     const promise = action.promise;
  1471.     this.openOperations_.push(promise);
  1473.     // Remove the open operation once the action has completed. So that we
  1474.     // can still return the AbortableOperation, this is done using a |finally|
  1475.     // block, rather than awaiting the result.
  1476.     return action.finally(() => {
  1477.       shaka.util.ArrayUtils.remove(this.openOperations_, promise);
  1478.     });
  1479.   }
  1481.   /**
  1482.    * @param {shaka.extern.ManifestDB} manifest
  1483.    * @return {!Array.<number>}
  1484.    * @private
  1485.    */
  1486.   static getAllSegmentIds_(manifest) {
  1487.     /** @type {!Set.<number>} */
  1488.     const ids = new Set();
  1490.     // Get every segment for every stream in the manifest.
  1491.     for (const stream of manifest.streams) {
  1492.       for (const segment of stream.segments) {
  1493.         if (segment.initSegmentKey != null) {
  1494.           ids.add(segment.initSegmentKey);
  1495.         }
  1497.         ids.add(segment.dataKey);
  1498.       }
  1499.     }
  1501.     return Array.from(ids);
  1502.   }
  1504.   /**
  1505.    * Delete the on-disk storage and all the content it contains. This should not
  1506.    * be done in normal circumstances. Only do it when storage is rendered
  1507.    * unusable, such as by a version mismatch. No business logic will be run, and
  1508.    * licenses will not be released.
  1509.    *
  1510.    * @return {!Promise}
  1511.    * @export
  1512.    */
  1513.   static async deleteAll() {
  1514.     /** @type {!shaka.offline.StorageMuxer} */
  1515.     const muxer = new shaka.offline.StorageMuxer();
  1516.     try {
  1517.       // Wipe all content from all storage mechanisms.
  1518.       await muxer.erase();
  1519.     } finally {
  1520.       // Destroy the muxer, whether or not erase() succeeded.
  1521.       await muxer.destroy();
  1522.     }
  1523.   }
  1525.   /**
  1526.    * @param {!shaka.net.NetworkingEngine} net
  1527.    * @param {!shaka.extern.DrmConfiguration} drmConfig
  1528.    * @param {!shaka.offline.StorageMuxer} muxer
  1529.    * @param {shaka.extern.ManifestDB} manifestDb
  1530.    * @return {!Promise}
  1531.    * @private
  1532.    */
  1533.   static async deleteLicenseFor_(net, drmConfig, muxer, manifestDb) {
  1534.     if (!manifestDb.drmInfo) {
  1535.       return;
  1536.     }
  1538.     const sessionIdCell = muxer.getEmeSessionCell();
  1540.     /** @type {!Array.<shaka.extern.EmeSessionDB>} */
  1541.     const sessions = manifestDb.sessionIds.map((sessionId) => {
  1542.       return {
  1543.         sessionId: sessionId,
  1544.         keySystem: manifestDb.drmInfo.keySystem,
  1545.         licenseUri: manifestDb.drmInfo.licenseServerUri,
  1546.         serverCertificate: manifestDb.drmInfo.serverCertificate,
  1547.         audioCapabilities: shaka.offline.Storage.getCapabilities_(
  1548.             manifestDb,
  1549.             /* isVideo= */ false),
  1550.         videoCapabilities: shaka.offline.Storage.getCapabilities_(
  1551.             manifestDb,
  1552.             /* isVideo= */ true),
  1553.       };
  1554.     });
  1555.     // Try to delete the sessions; any sessions that weren't deleted get stored
  1556.     // in the database so we can try to remove them again later.  This allows us
  1557.     // to still delete the stored content but not "forget" about these sessions.
  1558.     // Later, we can remove the sessions to free up space.
  1559.     const deleter = new shaka.offline.SessionDeleter();
  1560.     const deletedSessionIds = await deleter.delete(drmConfig, net, sessions);
  1561.     await sessionIdCell.remove(deletedSessionIds);
  1562.     await sessionIdCell.add(sessions.filter(
  1563.         (session) => !deletedSessionIds.includes(session.sessionId)));
  1564.   }
  1566.   /**
  1567.    * Get the set of all streams in |manifest|.
  1568.    *
  1569.    * @param {shaka.extern.Manifest} manifest
  1570.    * @return {!Set.<shaka.extern.Stream>}
  1571.    * @private
  1572.    */
  1573.   static getAllStreamsFromManifest_(manifest) {
  1574.     /** @type {!Set.<shaka.extern.Stream>} */
  1575.     const set = new Set();
  1577.     for (const text of manifest.textStreams) {
  1578.       set.add(text);
  1579.     }
  1581.     for (const image of manifest.imageStreams) {
  1582.       set.add(image);
  1583.     }
  1585.     for (const variant of manifest.variants) {
  1586.       if (variant.audio) {
  1587.         set.add(variant.audio);
  1588.       }
  1589.       if (variant.video) {
  1590.         set.add(variant.video);
  1591.       }
  1592.     }
  1594.     return set;
  1595.   }
  1597.   /**
  1598.    * Go over a manifest and issue warnings for any suspicious properties.
  1599.    *
  1600.    * @param {shaka.extern.Manifest} manifest
  1601.    * @private
  1602.    */
  1603.   static validateManifest_(manifest) {
  1604.     const videos = new Set(manifest.variants.map((v) => v.video));
  1605.     const audios = new Set(manifest.variants.map((v) => v.audio));
  1606.     const texts = manifest.textStreams;
  1608.     if (videos.size > 1) {
  1609.       shaka.log.warning('Multiple video tracks selected to be stored');
  1610.     }
  1612.     for (const audio1 of audios) {
  1613.       for (const audio2 of audios) {
  1614.         if (audio1 != audio2 && audio1.language == audio2.language) {
  1615.           shaka.log.warning(
  1616.               'Similar audio tracks were selected to be stored',
  1617.               audio1.id,
  1618.               audio2.id);
  1619.         }
  1620.       }
  1621.     }
  1623.     for (const text1 of texts) {
  1624.       for (const text2 of texts) {
  1625.         if (text1 != text2 && text1.language == text2.language) {
  1626.           shaka.log.warning(
  1627.               'Similar text tracks were selected to be stored',
  1628.               text1.id,
  1629.               text2.id);
  1630.         }
  1631.       }
  1632.     }
  1633.   }
  1634. };
  1636. shaka.offline.Storage.defaultSystemIds_ = new Map()
  1637.     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
  1638.     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')
  1639.     .set('com.microsoft.playready', '9a04f07998404286ab92e65be0885f95')
  1640.     .set('com.microsoft.playready.recommendation',
  1641.         '9a04f07998404286ab92e65be0885f95')
  1642.     .set('com.microsoft.playready.software',
  1643.         '9a04f07998404286ab92e65be0885f95')
  1644.     .set('com.microsoft.playready.hardware',
  1645.         '9a04f07998404286ab92e65be0885f95')
  1646.     .set('com.adobe.primetime', 'f239e769efa348509c16a903c6932efb');
  1648. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);