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.Deprecate');
  11. goog.require('shaka.Player');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.DrmEngine');
  14. goog.require('shaka.media.ManifestParser');
  15. goog.require('shaka.net.NetworkingEngine');
  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.Functional');
  28. goog.require('shaka.util.IDestroyable');
  29. goog.require('shaka.util.Iterables');
  30. goog.require('shaka.util.MimeUtils');
  31. goog.require('shaka.util.Networking');
  32. goog.require('shaka.util.Platform');
  33. goog.require('shaka.util.PlayerConfiguration');
  34. goog.require('shaka.util.StreamUtils');
  35. goog.requireType('shaka.media.InitSegmentReference');
  36. goog.requireType('shaka.media.SegmentReference');
  37. goog.requireType('shaka.offline.StorageCellHandle');
  40. /**
  41.  * @summary
  42.  * This manages persistent offline data including storage, listing, and deleting
  43.  * stored manifests.  Playback of offline manifests are done through the Player
  44.  * using a special URI (see shaka.offline.OfflineUri).
  45.  *
  46.  * First, check support() to see if offline is supported by the platform.
  47.  * Second, configure() the storage object with callbacks to your application.
  48.  * Third, call store(), remove(), or list() as needed.
  49.  * When done, call destroy().
  50.  *
  51.  * @implements {shaka.util.IDestroyable}
  52.  * @export
  53.  */
  54. shaka.offline.Storage = class {
  55.   /**
  56.    * @param {!shaka.Player=} player
  57.    *    A player instance to share a networking engine and configuration with.
  58.    *    When initializing with a player, storage is only valid as long as
  59.    *    |destroy| has not been called on the player instance. When omitted,
  60.    *    storage will manage its own networking engine and configuration.
  61.    */
  62.   constructor(player) {
  63.     // It is an easy mistake to make to pass a Player proxy from CastProxy.
  64.     // Rather than throw a vague exception later, throw an explicit and clear
  65.     // one now.
  66.     //
  67.     // TODO(vaage): After we decide whether or not we want to support
  68.     //  initializing storage with a player proxy, we should either remove
  69.     //  this error or rename the error.
  70.     if (player && player.constructor != shaka.Player) {
  71.       throw new shaka.util.Error(
  72.           shaka.util.Error.Severity.CRITICAL,
  73.           shaka.util.Error.Category.STORAGE,
  74.           shaka.util.Error.Code.LOCAL_PLAYER_INSTANCE_REQUIRED);
  75.     }
  77.     /** @private {?shaka.extern.PlayerConfiguration} */
  78.     this.config_ = null;
  80.     /** @private {shaka.net.NetworkingEngine} */
  81.     this.networkingEngine_ = null;
  83.     // Initialize |config_| and |networkingEngine_| based on whether or not
  84.     // we were given a player instance.
  85.     if (player) {
  86.       this.config_ = player.getSharedConfiguration();
  87.       this.networkingEngine_ = player.getNetworkingEngine();
  89.       goog.asserts.assert(
  90.           this.networkingEngine_,
  91.           'Storage should not be initialized with a player that had ' +
  92.               '|destroy| called on it.');
  93.     } else {
  94.       this.config_ = shaka.util.PlayerConfiguration.createDefault();
  95.       this.networkingEngine_ = new shaka.net.NetworkingEngine();
  96.     }
  98.     /**
  99.      * A list of segment ids for all the segments that were added during the
  100.      * current store. If the store fails or is aborted, these need to be
  101.      * removed from storage.
  102.      * @private {!Array.<number>}
  103.      */
  104.     this.segmentsFromStore_ = [];
  106.     /**
  107.      * A list of open operations that are being performed by this instance of
  108.      * |shaka.offline.Storage|.
  109.      *
  110.      * @private {!Array.<!Promise>}
  111.      */
  112.     this.openOperations_ = [];
  114.     /**
  115.      * A list of open download managers that are being used to download things.
  116.      *
  117.      * @private {!Array.<!shaka.offline.DownloadManager>}
  118.      */
  119.     this.openDownloadManagers_ = [];
  121.     /**
  122.      * Storage should only destroy the networking engine if it was initialized
  123.      * without a player instance. Store this as a flag here to avoid including
  124.      * the player object in the destoyer's closure.
  125.      *
  126.      * @type {boolean}
  127.      */
  128.     const destroyNetworkingEngine = !player;
  130.     /** @private {!shaka.util.Destroyer} */
  131.     this.destroyer_ = new shaka.util.Destroyer(async () => {
  132.       // Cancel all in-progress store operations.
  133.       await Promise.all(this.openDownloadManagers_.map((dl) => dl.abortAll()));
  135.       // Wait for all remaining open operations to end. Wrap each operations so
  136.       // that a single rejected promise won't cause |Promise.all| to return
  137.       // early or to return a rejected Promise.
  138.       const noop = () => {};
  139.       const awaits = [];
  140.       for (const op of this.openOperations_) {
  141.         awaits.push(op.then(noop, noop));
  142.       }
  143.       await Promise.all(awaits);
  145.       // Wait until after all the operations have finished before we destroy
  146.       // the networking engine to avoid any unexpected errors.
  147.       if (destroyNetworkingEngine) {
  148.         await this.networkingEngine_.destroy();
  149.       }
  151.       // Drop all references to internal objects to help with GC.
  152.       this.config_ = null;
  153.       this.networkingEngine_ = null;
  154.     });
  155.   }
  158.   /**
  159.    * Gets whether offline storage is supported.  Returns true if offline storage
  160.    * is supported for clear content.  Support for offline storage of encrypted
  161.    * content will not be determined until storage is attempted.
  162.    *
  163.    * @return {boolean}
  164.    * @export
  165.    */
  166.   static support() {
  167.     // Our Storage system is useless without MediaSource.  MediaSource allows us
  168.     // to pull data from anywhere (including our Storage system) and feed it to
  169.     // the video element.
  170.     if (!shaka.util.Platform.supportsMediaSource()) {
  171.       return false;
  172.     }
  174.     return shaka.offline.StorageMuxer.support();
  175.   }
  177.   /**
  178.    * @override
  179.    * @export
  180.    */
  181.   destroy() {
  182.     return this.destroyer_.destroy();
  183.   }
  185.   /**
  186.    * Sets configuration values for Storage.  This is associated with
  187.    * Player.configure and will change the player instance given at
  188.    * initialization.
  189.    *
  190.    * @param {string|!Object} config This should either be a field name or an
  191.    *   object following the form of {@link shaka.extern.PlayerConfiguration},
  192.    *   where you may omit any field you do not wish to change.
  193.    * @param {*=} value This should be provided if the previous parameter
  194.    *   was a string field name.
  195.    * @return {boolean}
  196.    * @export
  197.    */
  198.   configure(config, value) {
  199.     goog.asserts.assert(typeof(config) == 'object' || arguments.length == 2,
  200.         'String configs should have values!');
  202.     // ('fieldName', value) format
  203.     if (arguments.length == 2 && typeof(config) == 'string') {
  204.       config = shaka.util.ConfigUtils.convertToConfigObject(config, value);
  205.     }
  207.     goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
  209.     // Deprecate 'manifest.dash.defaultPresentationDelay' configuration.
  210.     if (config['manifest'] && config['manifest']['dash'] &&
  211.           'defaultPresentationDelay' in config['manifest']['dash']) {
  212.       shaka.Deprecate.deprecateFeature(4,
  213.           'manifest.dash.defaultPresentationDelay configuration',
  214.           'Please Use manifest.defaultPresentationDelay instead.');
  215.       config['manifest']['defaultPresentationDelay'] =
  216.           config['manifest']['dash']['defaultPresentationDelay'];
  217.       delete config['manifest']['dash']['defaultPresentationDelay'];
  218.     }
  220.     goog.asserts.assert(
  221.         this.config_, 'Cannot reconfigure stroage after calling destroy.');
  222.     return shaka.util.PlayerConfiguration.mergeConfigObjects(
  223.         /* destination= */ this.config_, /* updates= */ config );
  224.   }
  226.   /**
  227.    * Return a copy of the current configuration.  Modifications of the returned
  228.    * value will not affect the Storage instance's active configuration.  You
  229.    * must call storage.configure() to make changes.
  230.    *
  231.    * @return {shaka.extern.PlayerConfiguration}
  232.    * @export
  233.    */
  234.   getConfiguration() {
  235.     goog.asserts.assert(this.config_, 'Config must not be null!');
  237.     const ret = shaka.util.PlayerConfiguration.createDefault();
  238.     shaka.util.PlayerConfiguration.mergeConfigObjects(
  239.         ret, this.config_, shaka.util.PlayerConfiguration.createDefault());
  240.     return ret;
  241.   }
  243.   /**
  244.    * Return the networking engine that storage is using. If storage was
  245.    * initialized with a player instance, then the networking engine returned
  246.    * will be the same as |player.getNetworkingEngine()|.
  247.    *
  248.    * The returned value will only be null if |destroy| was called before
  249.    * |getNetworkingEngine|.
  250.    *
  251.    * @return {shaka.net.NetworkingEngine}
  252.    * @export
  253.    */
  254.   getNetworkingEngine() {
  255.     return this.networkingEngine_;
  256.   }
  258.   /**
  259.    * Stores the given manifest.  If the content is encrypted, and encrypted
  260.    * content cannot be stored on this platform, the Promise will be rejected
  261.    * with error code 6001, REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE.
  262.    * Multiple assets can be downloaded at the same time, but note that since
  263.    * the storage instance has a single networking engine, multiple storage
  264.    * objects will be necessary if some assets require unique network filters.
  265.    * This snapshots the storage config at the time of the call, so it will not
  266.    * honor any changes to config mid-store operation.
  267.    *
  268.    * @param {string} uri The URI of the manifest to store.
  269.    * @param {!Object=} appMetadata An arbitrary object from the application
  270.    *   that will be stored along-side the offline content.  Use this for any
  271.    *   application-specific metadata you need associated with the stored
  272.    *   content.  For details on the data types that can be stored here, please
  273.    *   refer to {@link https://bit.ly/StructClone}
  274.    * @param {string=} mimeType
  275.    *   The mime type for the content |manifestUri| points to.
  276.    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.StoredContent>}
  277.    *   An AbortableOperation that resolves with a structure representing what
  278.    *   was stored.  The "offlineUri" member is the URI that should be given to
  279.    *   Player.load() to play this piece of content offline.  The "appMetadata"
  280.    *   member is the appMetadata argument you passed to store().
  281.    *   If you want to cancel this download, call the "abort" method on
  282.    *   AbortableOperation.
  283.    * @export
  284.    */
  285.   store(uri, appMetadata, mimeType) {
  286.     goog.asserts.assert(
  287.         this.networkingEngine_,
  288.         'Cannot call |downloadManifest_| after calling |destroy|.');
  290.     // Get a copy of the current config.
  291.     const config = this.getConfiguration();
  293.     const getParser = async () => {
  294.       goog.asserts.assert(
  295.           this.networkingEngine_, 'Should not call |store| after |destroy|');
  297.       const factory = await shaka.media.ManifestParser.getFactory(
  298.           uri,
  299.           this.networkingEngine_,
  300.           config.manifest.retryParameters,
  301.           mimeType || null);
  303.       return shaka.util.Functional.callFactory(factory);
  304.     };
  306.     /** @type {!shaka.offline.DownloadManager} */
  307.     const downloader =
  308.         new shaka.offline.DownloadManager(this.networkingEngine_);
  309.     this.openDownloadManagers_.push(downloader);
  311.     const storeOp = this.store_(
  312.         uri, appMetadata || {}, getParser, config, downloader);
  313.     const abortableStoreOp = new shaka.util.AbortableOperation(storeOp, () => {
  314.       return downloader.abortAll();
  315.     });
  316.     abortableStoreOp.finally(() => {
  317.       shaka.util.ArrayUtils.remove(this.openDownloadManagers_, downloader);
  318.     });
  320.     // Provide a temporary shim for "then" for backward compatibility.
  321.     /** @type {!Object} */ (abortableStoreOp)['then'] = (onSuccess) => {
  322.       shaka.Deprecate.deprecateFeature(4,
  323.           'shaka.offline.Storage.store.then',
  324.           'Storage operations now return a shaka.util.AbortableOperation, ' +
  325.           'rather than a promise.  Please update to conform to this new API; ' +
  326.           'you can use the |chain| method instead.');
  327.       return abortableStoreOp.promise.then(onSuccess);
  328.     };
  330.     return this.startAbortableOperation_(abortableStoreOp);
  331.   }
  333.   /**
  334.    * Returns true if an asset is currently downloading.
  335.    *
  336.    * @return {boolean}
  337.    * @deprecated
  338.    * @export
  339.    */
  340.   getStoreInProgress() {
  341.     shaka.Deprecate.deprecateFeature(4,
  342.         'shaka.offline.Storage.getStoreInProgress',
  343.         'Multiple concurrent downloads are now supported.');
  344.     return false;
  345.   }
  347.   /**
  348.    * See |shaka.offline.Storage.store| for details.
  349.    *
  350.    * @param {string} uri
  351.    * @param {!Object} appMetadata
  352.    * @param {function():!Promise.<shaka.extern.ManifestParser>} getParser
  353.    * @param {shaka.extern.PlayerConfiguration} config
  354.    * @param {!shaka.offline.DownloadManager} downloader
  355.    * @return {!Promise.<shaka.extern.StoredContent>}
  356.    * @private
  357.    */
  358.   async store_(uri, appMetadata, getParser, config, downloader) {
  359.     this.requireSupport_();
  361.     // Since we will need to use |parser|, |drmEngine|, |activeHandle|, and
  362.     // |muxer| in the catch/finally blocks, we need to define them out here.
  363.     // Since they may not get initialized when we enter the catch/finally block,
  364.     // we need to assume that they may be null/undefined when we get there.
  366.     /** @type {?shaka.extern.ManifestParser} */
  367.     let parser = null;
  368.     /** @type {?shaka.media.DrmEngine} */
  369.     let drmEngine = null;
  370.     /** @type {shaka.offline.StorageMuxer} */
  371.     const muxer = new shaka.offline.StorageMuxer();
  372.     /** @type {?shaka.offline.StorageCellHandle} */
  373.     let activeHandle = null;
  375.     // This will be used to store any errors from drm engine. Whenever drm
  376.     // engine is passed to another function to do work, we should check if this
  377.     // was set.
  378.     let drmError = null;
  380.     try {
  381.       parser = await getParser();
  383.       const manifest = await this.parseManifest(uri, parser, config);
  385.       // Check if we were asked to destroy ourselves while we were "away"
  386.       // downloading the manifest.
  387.       this.ensureNotDestroyed_();
  389.       // Check if we can even download this type of manifest before trying to
  390.       // create the drm engine.
  391.       const canDownload = !manifest.presentationTimeline.isLive() &&
  392.                           !manifest.presentationTimeline.isInProgress();
  393.       if (!canDownload) {
  394.         throw new shaka.util.Error(
  395.             shaka.util.Error.Severity.CRITICAL,
  396.             shaka.util.Error.Category.STORAGE,
  397.             shaka.util.Error.Code.CANNOT_STORE_LIVE_OFFLINE,
  398.             uri);
  399.       }
  401.       drmEngine = await this.createDrmEngine(
  402.           manifest,
  403.           (e) => { drmError = drmError || e; },
  404.           config);
  406.       // We could have been asked to destroy ourselves while we were "away"
  407.       // creating the drm engine.
  408.       this.ensureNotDestroyed_();
  409.       if (drmError) {
  410.         throw drmError;
  411.       }
  413.       await this.filterManifest_(manifest, drmEngine, config);
  415.       await muxer.init();
  416.       this.ensureNotDestroyed_();
  418.       // Get the cell that we are saving the manifest to. Once we get a cell
  419.       // we will only reference the cell and not the muxer so that the manifest
  420.       // and segments will all be saved to the same cell.
  421.       activeHandle = await muxer.getActive();
  422.       this.ensureNotDestroyed_();
  424.       goog.asserts.assert(drmEngine, 'drmEngine should be non-null here.');
  426.       const manifestDB = await this.downloadManifest_(
  427.           activeHandle.cell, drmEngine, manifest, uri, appMetadata, config,
  428.           downloader);
  429.       this.ensureNotDestroyed_();
  430.       if (drmError) {
  431.         throw drmError;
  432.       }
  434.       const ids = await activeHandle.cell.addManifests([manifestDB]);
  435.       this.ensureNotDestroyed_();
  437.       const offlineUri = shaka.offline.OfflineUri.manifest(
  438.           activeHandle.path.mechanism, activeHandle.path.cell, ids[0]);
  440.       return shaka.offline.StoredContentUtils.fromManifestDB(
  441.           offlineUri, manifestDB);
  442.     } catch (e) {
  443.       // If we did start saving some data, we need to remove it all to avoid
  444.       // wasting storage. However if the muxer did not manage to initialize,
  445.       // then we won't have an active cell to remove the segments from.
  446.       if (activeHandle) {
  447.         await activeHandle.cell.removeSegments(
  448.             this.segmentsFromStore_, () => {});
  449.       }
  451.       // If we already had an error, ignore this error to avoid hiding
  452.       // the original error.
  453.       throw drmError || e;
  454.     } finally {
  455.       this.segmentsFromStore_ = [];
  457.       await muxer.destroy();
  459.       if (parser) {
  460.         await parser.stop();
  461.       }
  463.       if (drmEngine) {
  464.         await drmEngine.destroy();
  465.       }
  466.     }
  467.   }
  469.   /**
  470.    * Filter |manifest| such that it will only contain the variants and text
  471.    * streams that we want to store and can actually play.
  472.    *
  473.    * @param {shaka.extern.Manifest} manifest
  474.    * @param {!shaka.media.DrmEngine} drmEngine
  475.    * @param {shaka.extern.PlayerConfiguration} config
  476.    * @return {!Promise}
  477.    * @private
  478.    */
  479.   async filterManifest_(manifest, drmEngine, config) {
  480.     // Filter the manifest based on the restrictions given in the player
  481.     // configuration.
  482.     const maxHwRes = {width: Infinity, height: Infinity};
  483.     shaka.util.StreamUtils.filterByRestrictions(
  484.         manifest, config.restrictions, maxHwRes);
  486.     // Filter the manifest based on what we know media source will be able to
  487.     // play later (no point storing something we can't play).
  488.     if (config.useMediaCapabilities) {
  489.       await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
  490.           manifest, config.offline.usePersistentLicense);
  491.     } else {
  492.       shaka.util.StreamUtils.filterManifestByMediaSource(manifest);
  493.       // Filter the manifest based on what we know our drm system will support
  494.       // playing later.
  495.       shaka.util.StreamUtils.filterManifestByDrm(manifest, drmEngine);
  496.     }
  498.     // Gather all tracks.
  499.     const allTracks = [];
  501.     // Choose the codec that has the lowest average bandwidth.
  502.     const preferredAudioChannelCount = config.preferredAudioChannelCount;
  503.     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  504.         manifest, preferredAudioChannelCount);
  506.     for (const variant of manifest.variants) {
  507.       goog.asserts.assert(
  508.           shaka.util.StreamUtils.isPlayable(variant),
  509.           'We should have already filtered by "is playable"');
  511.       allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
  512.     }
  514.     for (const text of manifest.textStreams) {
  515.       allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
  516.     }
  518.     for (const image of manifest.imageStreams) {
  519.       allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
  520.     }
  522.     // Let the application choose which tracks to store.
  523.     const chosenTracks =
  524.         await config.offline.trackSelectionCallback(allTracks);
  525.     const duration = manifest.presentationTimeline.getDuration();
  526.     let sizeEstimate = 0;
  527.     for (const track of chosenTracks) {
  528.       const trackSize = track.bandwidth * duration / 8;
  529.       sizeEstimate += trackSize;
  530.     }
  531.     try {
  532.       const allowedDownload =
  533.           await config.offline.downloadSizeCallback(sizeEstimate);
  534.       if (!allowedDownload) {
  535.         throw new shaka.util.Error(
  536.             shaka.util.Error.Severity.CRITICAL,
  537.             shaka.util.Error.Category.STORAGE,
  538.             shaka.util.Error.Code.STORAGE_LIMIT_REACHED);
  539.       }
  540.     } catch (e) {
  541.       // It is necessary to be able to catch the STORAGE_LIMIT_REACHED error
  542.       if (e instanceof shaka.util.Error) {
  543.         throw e;
  544.       }
  545.       shaka.log.warning(
  546.           'downloadSizeCallback has produced an unexpected error', e);
  547.       throw new shaka.util.Error(
  548.           shaka.util.Error.Severity.CRITICAL,
  549.           shaka.util.Error.Category.STORAGE,
  550.           shaka.util.Error.Code.DOWNLOAD_SIZE_CALLBACK_ERROR);
  551.     }
  553.     /** @type {!Set.<number>} */
  554.     const variantIds = new Set();
  555.     /** @type {!Set.<number>} */
  556.     const textIds = new Set();
  557.     /** @type {!Set.<number>} */
  558.     const imageIds = new Set();
  560.     // Collect the IDs of the chosen tracks.
  561.     for (const track of chosenTracks) {
  562.       if (track.type == 'variant') {
  563.         variantIds.add(track.id);
  564.       }
  565.       if (track.type == 'text') {
  566.         textIds.add(track.id);
  567.       }
  568.       if (track.type == 'image') {
  569.         imageIds.add(track.id);
  570.       }
  571.     }
  573.     // Filter the manifest to keep only what the app chose.
  574.     manifest.variants =
  575.         manifest.variants.filter((variant) => variantIds.has(variant.id));
  576.     manifest.textStreams =
  577.         manifest.textStreams.filter((stream) => textIds.has(stream.id));
  578.     manifest.imageStreams =
  579.         manifest.imageStreams.filter((stream) => imageIds.has(stream.id));
  581.     // Check the post-filtered manifest for characteristics that may indicate
  582.     // issues with how the app selected tracks.
  583.     shaka.offline.Storage.validateManifest_(manifest);
  584.   }
  586.   /**
  587.    * Create a download manager and download the manifest.
  588.    *
  589.    * @param {shaka.extern.StorageCell} storage
  590.    * @param {!shaka.media.DrmEngine} drmEngine
  591.    * @param {shaka.extern.Manifest} manifest
  592.    * @param {string} uri
  593.    * @param {!Object} metadata
  594.    * @param {shaka.extern.PlayerConfiguration} config
  595.    * @param {!shaka.offline.DownloadManager} downloader
  596.    * @return {!Promise.<shaka.extern.ManifestDB>}
  597.    * @private
  598.    */
  599.   async downloadManifest_(
  600.       storage, drmEngine, manifest, uri, metadata, config, downloader) {
  601.     const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
  602.         uri, manifest, /* size= */ 0, metadata);
  603.     // In https://github.com/shaka-project/shaka-player/issues/2652, we found
  604.     // that this callback would be removed by the compiler if we reference the
  605.     // config in the onProgress closure below.  Reading it into a local
  606.     // variable first seems to work around this apparent compiler bug.
  607.     const progressCallback = config.offline.progressCallback;
  609.     const onProgress = (progress, size) => {
  610.       // Update the size of the stored content before issuing a progress
  611.       // update.
  612.       pendingContent.size = size;
  613.       progressCallback(pendingContent, progress);
  614.     };
  615.     const onInitData = (initData, systemId) => {
  616.       if (needsInitData && config.offline.usePersistentLicense &&
  617.           currentSystemId == systemId) {
  618.         drmEngine.newInitData('cenc', initData);
  619.       }
  620.     };
  621.     downloader.setCallbacks(onProgress, onInitData);
  623.     const isEncrypted = manifest.variants.some((variant) => {
  624.       const videoEncrypted = variant.video && variant.video.encrypted;
  625.       const audioEncrypted = variant.audio && variant.audio.encrypted;
  626.       return videoEncrypted || audioEncrypted;
  627.     });
  628.     const includesInitData = manifest.variants.some((variant) => {
  629.       const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  630.       const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  631.       const drmInfos = videoDrmInfos.concat(audioDrmInfos);
  632.       return drmInfos.some((drmInfos) => {
  633.         return drmInfos.initData && drmInfos.initData.length;
  634.       });
  635.     });
  636.     const needsInitData = isEncrypted && !includesInitData;
  638.     let currentSystemId = null;
  639.     if (needsInitData) {
  640.       const drmInfo = drmEngine.getDrmInfo();
  641.       currentSystemId =
  642.           shaka.offline.Storage.defaultSystemIds_.get(drmInfo.keySystem);
  643.     }
  645.     try {
  646.       const manifestDB = this.createOfflineManifest_(
  647.           downloader, storage, drmEngine, manifest, uri, metadata, config);
  649.       manifestDB.size = await downloader.waitToFinish();
  650.       manifestDB.expiration = drmEngine.getExpiration();
  651.       const sessions = drmEngine.getSessionIds();
  652.       manifestDB.sessionIds = config.offline.usePersistentLicense ?
  653.           sessions : [];
  655.       if (isEncrypted && config.offline.usePersistentLicense &&
  656.           !sessions.length) {
  657.         throw new shaka.util.Error(
  658.             shaka.util.Error.Severity.CRITICAL,
  659.             shaka.util.Error.Category.STORAGE,
  660.             shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE);
  661.       }
  663.       return manifestDB;
  664.     } finally {
  665.       await downloader.destroy();
  666.     }
  667.   }
  669.   /**
  670.    * Removes the given stored content.  This will also attempt to release the
  671.    * licenses, if any.
  672.    *
  673.    * @param {string} contentUri
  674.    * @return {!Promise}
  675.    * @export
  676.    */
  677.   remove(contentUri) {
  678.     return this.startOperation_(this.remove_(contentUri));
  679.   }
  681.   /**
  682.    * See |shaka.offline.Storage.remove| for details.
  683.    *
  684.    * @param {string} contentUri
  685.    * @return {!Promise}
  686.    * @private
  687.    */
  688.   async remove_(contentUri) {
  689.     this.requireSupport_();
  691.     const nullableUri = shaka.offline.OfflineUri.parse(contentUri);
  692.     if (nullableUri == null || !nullableUri.isManifest()) {
  693.       throw new shaka.util.Error(
  694.           shaka.util.Error.Severity.CRITICAL,
  695.           shaka.util.Error.Category.STORAGE,
  696.           shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  697.           contentUri);
  698.     }
  700.     /** @type {!shaka.offline.OfflineUri} */
  701.     const uri = nullableUri;
  703.     /** @type {!shaka.offline.StorageMuxer} */
  704.     const muxer = new shaka.offline.StorageMuxer();
  706.     try {
  707.       await muxer.init();
  709.       const cell = await muxer.getCell(uri.mechanism(), uri.cell());
  710.       const manifests = await cell.getManifests([uri.key()]);
  711.       const manifest = manifests[0];
  713.       await Promise.all([
  714.         this.removeFromDRM_(uri, manifest, muxer),
  715.         this.removeFromStorage_(cell, uri, manifest),
  716.       ]);
  717.     } finally {
  718.       await muxer.destroy();
  719.     }
  720.   }
  722.   /**
  723.    * @param {shaka.extern.ManifestDB} manifestDb
  724.    * @param {boolean} isVideo
  725.    * @return {!Array.<MediaKeySystemMediaCapability>}
  726.    * @private
  727.    */
  728.   static getCapabilities_(manifestDb, isVideo) {
  729.     const MimeUtils = shaka.util.MimeUtils;
  731.     const ret = [];
  732.     for (const stream of manifestDb.streams) {
  733.       if (isVideo && stream.type == 'video') {
  734.         ret.push({
  735.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  736.           robustness: manifestDb.drmInfo.videoRobustness,
  737.         });
  738.       } else if (!isVideo && stream.type == 'audio') {
  739.         ret.push({
  740.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  741.           robustness: manifestDb.drmInfo.audioRobustness,
  742.         });
  743.       }
  744.     }
  745.     return ret;
  746.   }
  748.   /**
  749.    * @param {!shaka.offline.OfflineUri} uri
  750.    * @param {shaka.extern.ManifestDB} manifestDb
  751.    * @param {!shaka.offline.StorageMuxer} muxer
  752.    * @return {!Promise}
  753.    * @private
  754.    */
  755.   async removeFromDRM_(uri, manifestDb, muxer) {
  756.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  757.     await shaka.offline.Storage.deleteLicenseFor_(
  758.         this.networkingEngine_, this.config_.drm, muxer, manifestDb);
  759.   }
  761.   /**
  762.    * @param {shaka.extern.StorageCell} storage
  763.    * @param {!shaka.offline.OfflineUri} uri
  764.    * @param {shaka.extern.ManifestDB} manifest
  765.    * @return {!Promise}
  766.    * @private
  767.    */
  768.   removeFromStorage_( storage, uri, manifest) {
  769.     /** @type {!Array.<number>} */
  770.     const segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
  772.     // Count(segments) + Count(manifests)
  773.     const toRemove = segmentIds.length + 1;
  774.     let removed = 0;
  776.     const pendingContent = shaka.offline.StoredContentUtils.fromManifestDB(
  777.         uri, manifest);
  779.     const onRemove = (key) => {
  780.       removed += 1;
  781.       this.config_.offline.progressCallback(pendingContent, removed / toRemove);
  782.     };
  784.     return Promise.all([
  785.       storage.removeSegments(segmentIds, onRemove),
  786.       storage.removeManifests([uri.key()], onRemove),
  787.     ]);
  788.   }
  790.   /**
  791.    * Removes any EME sessions that were not successfully removed before.  This
  792.    * returns whether all the sessions were successfully removed.
  793.    *
  794.    * @return {!Promise.<boolean>}
  795.    * @export
  796.    */
  797.   removeEmeSessions() {
  798.     return this.startOperation_(this.removeEmeSessions_());
  799.   }
  801.   /**
  802.    * @return {!Promise.<boolean>}
  803.    * @private
  804.    */
  805.   async removeEmeSessions_() {
  806.     this.requireSupport_();
  808.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  809.     const net = this.networkingEngine_;
  810.     const config = this.config_.drm;
  812.     /** @type {!shaka.offline.StorageMuxer} */
  813.     const muxer = new shaka.offline.StorageMuxer();
  814.     /** @type {!shaka.offline.SessionDeleter} */
  815.     const deleter = new shaka.offline.SessionDeleter();
  817.     let hasRemaining = false;
  819.     try {
  820.       await muxer.init();
  822.       /** @type {!Array.<shaka.extern.EmeSessionStorageCell>} */
  823.       const cells = [];
  824.       muxer.forEachEmeSessionCell((c) => cells.push(c));
  826.       // Run these sequentially to avoid creating too many DrmEngine instances
  827.       // and having multiple CDMs alive at once.  Some embedded platforms may
  828.       // not support that.
  829.       for (const sessionIdCell of cells) {
  830.         /* eslint-disable no-await-in-loop */
  831.         const sessions = await sessionIdCell.getAll();
  832.         const deletedSessionIds = await deleter.delete(config, net, sessions);
  833.         await sessionIdCell.remove(deletedSessionIds);
  835.         if (deletedSessionIds.length != sessions.length) {
  836.           hasRemaining = true;
  837.         }
  838.         /* eslint-enable no-await-in-loop */
  839.       }
  840.     } finally {
  841.       await muxer.destroy();
  842.     }
  844.     return !hasRemaining;
  845.   }
  847.   /**
  848.    * Lists all the stored content available.
  849.    *
  850.    * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}  A Promise to an
  851.    *   array of structures representing all stored content.  The "offlineUri"
  852.    *   member of the structure is the URI that should be given to Player.load()
  853.    *   to play this piece of content offline.  The "appMetadata" member is the
  854.    *   appMetadata argument you passed to store().
  855.    * @export
  856.    */
  857.   list() {
  858.     return this.startOperation_(this.list_());
  859.   }
  861.   /**
  862.    * See |shaka.offline.Storage.list| for details.
  863.    *
  864.    * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}
  865.    * @private
  866.    */
  867.   async list_() {
  868.     this.requireSupport_();
  870.     /** @type {!Array.<shaka.extern.StoredContent>} */
  871.     const result = [];
  873.     /** @type {!shaka.offline.StorageMuxer} */
  874.     const muxer = new shaka.offline.StorageMuxer();
  875.     try {
  876.       await muxer.init();
  878.       let p = Promise.resolve();
  879.       muxer.forEachCell((path, cell) => {
  880.         p = p.then(async () => {
  881.           const manifests = await cell.getAllManifests();
  883.           manifests.forEach((manifest, key) => {
  884.             const uri = shaka.offline.OfflineUri.manifest(
  885.                 path.mechanism,
  886.                 path.cell,
  887.                 key);
  889.             const content = shaka.offline.StoredContentUtils.fromManifestDB(
  890.                 uri,
  891.                 manifest);
  893.             result.push(content);
  894.           });
  895.         });
  896.       });
  898.       await p;
  899.     } finally {
  900.       await muxer.destroy();
  901.     }
  903.     return result;
  904.   }
  907.   /**
  908.    * This method is public so that it can be overridden in testing.
  909.    *
  910.    * @param {string} uri
  911.    * @param {shaka.extern.ManifestParser} parser
  912.    * @param {shaka.extern.PlayerConfiguration} config
  913.    * @return {!Promise.<shaka.extern.Manifest>}
  914.    */
  915.   async parseManifest(uri, parser, config) {
  916.     let error = null;
  918.     const networkingEngine = this.networkingEngine_;
  919.     goog.asserts.assert(networkingEngine, 'Should be initialized!');
  921.     /** @type {shaka.extern.ManifestParser.PlayerInterface} */
  922.     const playerInterface = {
  923.       networkingEngine: networkingEngine,
  925.       // Don't bother filtering now. We will do that later when we have all the
  926.       // information we need to filter.
  927.       filter: () => Promise.resolve(),
  929.       // The responsibility for making mock text streams for closed captions is
  930.       // handled inside shaka.offline.OfflineManifestParser, before playback.
  931.       makeTextStreamsForClosedCaptions: (manifest) => {},
  933.       onTimelineRegionAdded: () => {},
  934.       onEvent: () => {},
  936.       // Used to capture an error from the manifest parser. We will check the
  937.       // error before returning.
  938.       onError: (e) => {
  939.         error = e;
  940.       },
  941.       isLowLatencyMode: () => false,
  942.       isAutoLowLatencyMode: () => false,
  943.       enableLowLatencyMode: () => {},
  944.     };
  946.     parser.configure(config.manifest);
  948.     // We may have been destroyed while we were waiting on |getParser| to
  949.     // resolve.
  950.     this.ensureNotDestroyed_();
  952.     const manifest = await parser.start(uri, playerInterface);
  954.     // We may have been destroyed while we were waiting on |start| to
  955.     // resolve.
  956.     this.ensureNotDestroyed_();
  958.     // Get all the streams that are used in the manifest.
  959.     const streams =
  960.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  962.     // Wait for each stream to create their segment indexes.
  963.     await Promise.all(shaka.util.Iterables.map(streams, (stream) => {
  964.       return stream.createSegmentIndex();
  965.     }));
  967.     // We may have been destroyed while we were waiting on
  968.     // |createSegmentIndex| to resolve for each stream.
  969.     this.ensureNotDestroyed_();
  971.     // If we saw an error while parsing, surface the error.
  972.     if (error) {
  973.       throw error;
  974.     }
  976.     return manifest;
  977.   }
  979.   /**
  980.    * This method is public so that it can be override in testing.
  981.    *
  982.    * @param {shaka.extern.Manifest} manifest
  983.    * @param {function(shaka.util.Error)} onError
  984.    * @param {shaka.extern.PlayerConfiguration} config
  985.    * @return {!Promise.<!shaka.media.DrmEngine>}
  986.    */
  987.   async createDrmEngine(manifest, onError, config) {
  988.     goog.asserts.assert(
  989.         this.networkingEngine_,
  990.         'Cannot call |createDrmEngine| after |destroy|');
  992.     /** @type {!shaka.media.DrmEngine} */
  993.     const drmEngine = new shaka.media.DrmEngine({
  994.       netEngine: this.networkingEngine_,
  995.       onError: onError,
  996.       onKeyStatus: () => {},
  997.       onExpirationUpdated: () => {},
  998.       onEvent: () => {},
  999.     });
  1001.     drmEngine.configure(config.drm);
  1002.     await drmEngine.initForStorage(
  1003.         manifest.variants, config.offline.usePersistentLicense,
  1004.         config.useMediaCapabilities);
  1005.     await drmEngine.setServerCertificate();
  1006.     await drmEngine.createOrLoad();
  1008.     return drmEngine;
  1009.   }
  1011.   /**
  1012.    * Creates an offline 'manifest' for the real manifest.  This does not store
  1013.    * the segments yet, only adds them to the download manager through
  1014.    * createStreams_.
  1015.    *
  1016.    * @param {!shaka.offline.DownloadManager} downloader
  1017.    * @param {shaka.extern.StorageCell} storage
  1018.    * @param {!shaka.media.DrmEngine} drmEngine
  1019.    * @param {shaka.extern.Manifest} manifest
  1020.    * @param {string} originalManifestUri
  1021.    * @param {!Object} metadata
  1022.    * @param {shaka.extern.PlayerConfiguration} config
  1023.    * @return {shaka.extern.ManifestDB}
  1024.    * @private
  1025.    */
  1026.   createOfflineManifest_(
  1027.       downloader, storage, drmEngine, manifest, originalManifestUri, metadata,
  1028.       config) {
  1029.     const estimator = new shaka.offline.StreamBandwidthEstimator();
  1031.     const streams = this.createStreams_(
  1032.         downloader, storage, estimator, drmEngine, manifest, config);
  1034.     const usePersistentLicense = config.offline.usePersistentLicense;
  1035.     const drmInfo = drmEngine.getDrmInfo();
  1037.     if (drmInfo && usePersistentLicense) {
  1038.       // Don't store init data, since we have stored sessions.
  1039.       drmInfo.initData = [];
  1040.     }
  1042.     return {
  1043.       creationTime: Date.now(),
  1044.       originalManifestUri: originalManifestUri,
  1045.       duration: manifest.presentationTimeline.getDuration(),
  1046.       size: 0,
  1047.       expiration: drmEngine.getExpiration(),
  1048.       streams: streams,
  1049.       sessionIds: usePersistentLicense ? drmEngine.getSessionIds() : [],
  1050.       drmInfo: drmInfo,
  1051.       appMetadata: metadata,
  1052.     };
  1053.   }
  1055.   /**
  1056.    * Converts manifest Streams to database Streams.  This will use the current
  1057.    * configuration to get the tracks to use, then it will search each segment
  1058.    * index and add all the segments to the download manager through
  1059.    * createStream_.
  1060.    *
  1061.    * @param {!shaka.offline.DownloadManager} downloader
  1062.    * @param {shaka.extern.StorageCell} storage
  1063.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1064.    * @param {!shaka.media.DrmEngine} drmEngine
  1065.    * @param {shaka.extern.Manifest} manifest
  1066.    * @param {shaka.extern.PlayerConfiguration} config
  1067.    * @return {!Array.<shaka.extern.StreamDB>}
  1068.    * @private
  1069.    */
  1070.   createStreams_(downloader, storage, estimator, drmEngine, manifest, config) {
  1071.     // Pass all variants and text streams to the estimator so that we can
  1072.     // get the best estimate for each stream later.
  1073.     for (const variant of manifest.variants) {
  1074.       estimator.addVariant(variant);
  1075.     }
  1076.     for (const text of manifest.textStreams) {
  1077.       estimator.addText(text);
  1078.     }
  1079.     for (const image of manifest.imageStreams) {
  1080.       estimator.addImage(image);
  1081.     }
  1083.     // TODO(joeyparrish): Break out stack-based state and method params into a
  1084.     // separate class to clean up.  See:
  1085.     // https://github.com/google/shaka-player/issues/2781#issuecomment-678438039
  1087.     /**
  1088.      * A cache mapping init segment references to Promises to their DB key.
  1089.      *
  1090.      * @type {!Map.<shaka.media.InitSegmentReference, !Promise.<?number>>}
  1091.      */
  1092.     const initSegmentDbKeyCache = new Map();
  1094.     // A null init segment reference always maps to a null DB key.
  1095.     initSegmentDbKeyCache.set(
  1096.         null, /** @type {!Promise.<?number>} */(Promise.resolve(null)));
  1098.     /**
  1099.      * A cache mapping equivalent segment references to Promises to their DB
  1100.      * key.  The key in this map is a string of the form
  1101.      * "<URI>-<startByte>-<endByte>".
  1102.      *
  1103.      * @type {!Map.<string, !Promise.<number>>}
  1104.      */
  1105.     const segmentDbKeyCache = new Map();
  1107.     // Find the streams we want to download and create a stream db instance
  1108.     // for each of them.
  1109.     const streamSet =
  1110.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1111.     const streamDBs = new Map();
  1113.     for (const stream of streamSet) {
  1114.       const streamDB = this.createStream_(
  1115.           downloader, storage, estimator, manifest, stream, config,
  1116.           initSegmentDbKeyCache, segmentDbKeyCache);
  1117.       streamDBs.set(stream.id, streamDB);
  1118.     }
  1120.     // Connect streams and variants together.
  1121.     for (const variant of manifest.variants) {
  1122.       if (variant.audio) {
  1123.         streamDBs.get(variant.audio.id).variantIds.push(variant.id);
  1124.       }
  1125.       if (variant.video) {
  1126.         streamDBs.get(variant.video.id).variantIds.push(variant.id);
  1127.       }
  1128.     }
  1130.     return Array.from(streamDBs.values());
  1131.   }
  1133.   /**
  1134.    * Converts a manifest stream to a database stream.  This will search the
  1135.    * segment index and add all the segments to the download manager.
  1136.    *
  1137.    * @param {!shaka.offline.DownloadManager} downloader
  1138.    * @param {shaka.extern.StorageCell} storage
  1139.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1140.    * @param {shaka.extern.Manifest} manifest
  1141.    * @param {shaka.extern.Stream} stream
  1142.    * @param {shaka.extern.PlayerConfiguration} config
  1143.    * @param {!Map.<shaka.media.InitSegmentReference, !Promise.<?number>>}
  1144.    *   initSegmentDbKeyCache
  1145.    * @param {!Map.<string, !Promise.<number>>} segmentDbKeyCache
  1146.    * @return {shaka.extern.StreamDB}
  1147.    * @private
  1148.    */
  1149.   createStream_(downloader, storage, estimator, manifest, stream, config,
  1150.       initSegmentDbKeyCache, segmentDbKeyCache) {
  1151.     /** @type {shaka.extern.StreamDB} */
  1152.     const streamDb = {
  1153.       id: stream.id,
  1154.       originalId: stream.originalId,
  1155.       primary: stream.primary,
  1156.       type: stream.type,
  1157.       mimeType: stream.mimeType,
  1158.       codecs: stream.codecs,
  1159.       frameRate: stream.frameRate,
  1160.       pixelAspectRatio: stream.pixelAspectRatio,
  1161.       hdr: stream.hdr,
  1162.       kind: stream.kind,
  1163.       language: stream.language,
  1164.       label: stream.label,
  1165.       width: stream.width || null,
  1166.       height: stream.height || null,
  1167.       encrypted: stream.encrypted,
  1168.       keyIds: stream.keyIds,
  1169.       segments: [],
  1170.       variantIds: [],
  1171.       roles: stream.roles,
  1172.       forced: stream.forced,
  1173.       channelsCount: stream.channelsCount,
  1174.       audioSamplingRate: stream.audioSamplingRate,
  1175.       spatialAudio: stream.spatialAudio,
  1176.       closedCaptions: stream.closedCaptions,
  1177.       tilesLayout: stream.tilesLayout,
  1178.     };
  1180.     // Download each stream in parallel.
  1181.     const downloadGroup = stream.id;
  1183.     const startTime =
  1184.         manifest.presentationTimeline.getSegmentAvailabilityStart();
  1186.     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
  1187.       const initSegmentKeyPromise = this.getInitSegmentDbKey_(
  1188.           downloader, downloadGroup, stream.id, storage, estimator,
  1189.           segment.initSegmentReference, config, initSegmentDbKeyCache);
  1191.       const segmentKeyPromise = this.getSegmentDbKey_(
  1192.           downloader, downloadGroup, stream.id, storage, estimator, segment,
  1193.           config, segmentDbKeyCache);
  1195.       downloader.queueWork(downloadGroup, async () => {
  1196.         const initSegmentKey = await initSegmentKeyPromise;
  1197.         const dataKey = await segmentKeyPromise;
  1199.         streamDb.segments.push({
  1200.           initSegmentKey,
  1201.           startTime: segment.startTime,
  1202.           endTime: segment.endTime,
  1203.           appendWindowStart: segment.appendWindowStart,
  1204.           appendWindowEnd: segment.appendWindowEnd,
  1205.           timestampOffset: segment.timestampOffset,
  1206.           dataKey,
  1207.         });
  1208.       });
  1209.     });
  1211.     return streamDb;
  1212.   }
  1214.   /**
  1215.    * Get a Promise to the DB key for a given init segment reference.
  1216.    *
  1217.    * The return values will be cached so that multiple calls with the same init
  1218.    * segment reference will only trigger one request.
  1219.    *
  1220.    * @param {!shaka.offline.DownloadManager} downloader
  1221.    * @param {number} downloadGroup
  1222.    * @param {number} streamId
  1223.    * @param {shaka.extern.StorageCell} storage
  1224.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1225.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  1226.    * @param {shaka.extern.PlayerConfiguration} config
  1227.    * @param {!Map.<shaka.media.InitSegmentReference, !Promise.<?number>>}
  1228.    *   initSegmentDbKeyCache
  1229.    * @return {!Promise.<?number>}
  1230.    * @private
  1231.    */
  1232.   getInitSegmentDbKey_(
  1233.       downloader, downloadGroup, streamId, storage, estimator,
  1234.       initSegmentReference, config, initSegmentDbKeyCache) {
  1235.     if (initSegmentDbKeyCache.has(initSegmentReference)) {
  1236.       return initSegmentDbKeyCache.get(initSegmentReference);
  1237.     }
  1239.     const request = shaka.util.Networking.createSegmentRequest(
  1240.         initSegmentReference.getUris(),
  1241.         initSegmentReference.startByte,
  1242.         initSegmentReference.endByte,
  1243.         config.streaming.retryParameters);
  1245.     const promise = downloader.queue(
  1246.         downloadGroup,
  1247.         request,
  1248.         estimator.getInitSegmentEstimate(streamId),
  1249.         /* isInitSegment= */ true,
  1250.         async (data) => {
  1251.           /** @type {!Array.<number>} */
  1252.           const ids = await storage.addSegments([{data: data}]);
  1253.           this.segmentsFromStore_.push(ids[0]);
  1254.           return ids[0];
  1255.         });
  1257.     initSegmentDbKeyCache.set(initSegmentReference, promise);
  1258.     return promise;
  1259.   }
  1261.   /**
  1262.    * Get a Promise to the DB key for a given segment reference.
  1263.    *
  1264.    * The return values will be cached so that multiple calls with the same
  1265.    * segment reference will only trigger one request.
  1266.    *
  1267.    * @param {!shaka.offline.DownloadManager} downloader
  1268.    * @param {number} downloadGroup
  1269.    * @param {number} streamId
  1270.    * @param {shaka.extern.StorageCell} storage
  1271.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1272.    * @param {shaka.media.SegmentReference} segmentReference
  1273.    * @param {shaka.extern.PlayerConfiguration} config
  1274.    * @param {!Map.<string, !Promise.<number>>} segmentDbKeyCache
  1275.    * @return {!Promise.<number>}
  1276.    * @private
  1277.    */
  1278.   getSegmentDbKey_(
  1279.       downloader, downloadGroup, streamId, storage, estimator,
  1280.       segmentReference, config, segmentDbKeyCache) {
  1281.     const mapKey = [
  1282.       segmentReference.getUris()[0],
  1283.       segmentReference.startByte,
  1284.       segmentReference.endByte,
  1285.     ].join('-');
  1287.     if (segmentDbKeyCache.has(mapKey)) {
  1288.       return segmentDbKeyCache.get(mapKey);
  1289.     }
  1291.     const request = shaka.util.Networking.createSegmentRequest(
  1292.         segmentReference.getUris(),
  1293.         segmentReference.startByte,
  1294.         segmentReference.endByte,
  1295.         config.streaming.retryParameters);
  1297.     const promise = downloader.queue(
  1298.         downloadGroup,
  1299.         request,
  1300.         estimator.getSegmentEstimate(streamId, segmentReference),
  1301.         /* isInitSegment= */ false,
  1302.         async (data) => {
  1303.           /** @type {!Array.<number>} */
  1304.           const ids = await storage.addSegments([{data: data}]);
  1305.           this.segmentsFromStore_.push(ids[0]);
  1306.           return ids[0];
  1307.         });
  1309.     segmentDbKeyCache.set(mapKey, promise);
  1310.     return promise;
  1311.   }
  1313.   /**
  1314.    * @param {shaka.extern.Stream} stream
  1315.    * @param {number} startTime
  1316.    * @param {function(!shaka.media.SegmentReference)} callback
  1317.    * @private
  1318.    */
  1319.   static forEachSegment_(stream, startTime, callback) {
  1320.     /** @type {?number} */
  1321.     let i = stream.segmentIndex.find(startTime);
  1323.     if (i == null) {
  1324.       return;
  1325.     }
  1327.     /** @type {?shaka.media.SegmentReference} */
  1328.     let ref = stream.segmentIndex.get(i);
  1329.     while (ref) {
  1330.       callback(ref);
  1331.       ref = stream.segmentIndex.get(++i);
  1332.     }
  1333.   }
  1335.   /**
  1336.    * Throws an error if the object is destroyed.
  1337.    * @private
  1338.    */
  1339.   ensureNotDestroyed_() {
  1340.     if (this.destroyer_.destroyed()) {
  1341.       throw new shaka.util.Error(
  1342.           shaka.util.Error.Severity.CRITICAL,
  1343.           shaka.util.Error.Category.STORAGE,
  1344.           shaka.util.Error.Code.OPERATION_ABORTED);
  1345.     }
  1346.   }
  1348.   /**
  1349.    * Used by functions that need storage support to ensure that the current
  1350.    * platform has storage support before continuing. This should only be
  1351.    * needed to be used at the start of public methods.
  1352.    *
  1353.    * @private
  1354.    */
  1355.   requireSupport_() {
  1356.     if (!shaka.offline.Storage.support()) {
  1357.       throw new shaka.util.Error(
  1358.           shaka.util.Error.Severity.CRITICAL,
  1359.           shaka.util.Error.Category.STORAGE,
  1360.           shaka.util.Error.Code.STORAGE_NOT_SUPPORTED);
  1361.     }
  1362.   }
  1364.   /**
  1365.    * Perform an action. Track the action's progress so that when we destroy
  1366.    * we will wait until all the actions have completed before allowing destroy
  1367.    * to resolve.
  1368.    *
  1369.    * @param {!Promise<T>} action
  1370.    * @return {!Promise<T>}
  1371.    * @template T
  1372.    * @private
  1373.    */
  1374.   async startOperation_(action) {
  1375.     this.openOperations_.push(action);
  1377.     try {
  1378.       // Await |action| so we can use the finally statement to remove |action|
  1379.       // from |openOperations_| when we still have a reference to |action|.
  1380.       return await action;
  1381.     } finally {
  1382.       shaka.util.ArrayUtils.remove(this.openOperations_, action);
  1383.     }
  1384.   }
  1386.   /**
  1387.    * The equivalent of startOperation_, but for abortable operations.
  1388.    *
  1389.    * @param {!shaka.extern.IAbortableOperation<T>} action
  1390.    * @return {!shaka.extern.IAbortableOperation<T>}
  1391.    * @template T
  1392.    * @private
  1393.    */
  1394.   startAbortableOperation_(action) {
  1395.     const promise = action.promise;
  1396.     this.openOperations_.push(promise);
  1398.     // Remove the open operation once the action has completed. So that we
  1399.     // can still return the AbortableOperation, this is done using a |finally|
  1400.     // block, rather than awaiting the result.
  1401.     return action.finally(() => {
  1402.       shaka.util.ArrayUtils.remove(this.openOperations_, promise);
  1403.     });
  1404.   }
  1406.   /**
  1407.    * @param {shaka.extern.ManifestDB} manifest
  1408.    * @return {!Array.<number>}
  1409.    * @private
  1410.    */
  1411.   static getAllSegmentIds_(manifest) {
  1412.     /** @type {!Array.<number>} */
  1413.     const ids = [];
  1415.     // Get every segment for every stream in the manifest.
  1416.     for (const stream of manifest.streams) {
  1417.       for (const segment of stream.segments) {
  1418.         if (segment.initSegmentKey != null) {
  1419.           ids.push(segment.initSegmentKey);
  1420.         }
  1422.         ids.push(segment.dataKey);
  1423.       }
  1424.     }
  1426.     return ids;
  1427.   }
  1429.   /**
  1430.    * Delete the on-disk storage and all the content it contains. This should not
  1431.    * be done in normal circumstances. Only do it when storage is rendered
  1432.    * unusable, such as by a version mismatch. No business logic will be run, and
  1433.    * licenses will not be released.
  1434.    *
  1435.    * @return {!Promise}
  1436.    * @export
  1437.    */
  1438.   static async deleteAll() {
  1439.     /** @type {!shaka.offline.StorageMuxer} */
  1440.     const muxer = new shaka.offline.StorageMuxer();
  1441.     try {
  1442.       // Wipe all content from all storage mechanisms.
  1443.       await muxer.erase();
  1444.     } finally {
  1445.       // Destroy the muxer, whether or not erase() succeeded.
  1446.       await muxer.destroy();
  1447.     }
  1448.   }
  1450.   /**
  1451.    * @param {!shaka.net.NetworkingEngine} net
  1452.    * @param {!shaka.extern.DrmConfiguration} drmConfig
  1453.    * @param {!shaka.offline.StorageMuxer} muxer
  1454.    * @param {shaka.extern.ManifestDB} manifestDb
  1455.    * @return {!Promise}
  1456.    * @private
  1457.    */
  1458.   static async deleteLicenseFor_(net, drmConfig, muxer, manifestDb) {
  1459.     if (!manifestDb.drmInfo) {
  1460.       return;
  1461.     }
  1463.     const sessionIdCell = muxer.getEmeSessionCell();
  1465.     /** @type {!Array.<shaka.extern.EmeSessionDB>} */
  1466.     const sessions = manifestDb.sessionIds.map((sessionId) => {
  1467.       return {
  1468.         sessionId: sessionId,
  1469.         keySystem: manifestDb.drmInfo.keySystem,
  1470.         licenseUri: manifestDb.drmInfo.licenseServerUri,
  1471.         serverCertificate: manifestDb.drmInfo.serverCertificate,
  1472.         audioCapabilities: shaka.offline.Storage.getCapabilities_(
  1473.             manifestDb,
  1474.             /* isVideo= */ false),
  1475.         videoCapabilities: shaka.offline.Storage.getCapabilities_(
  1476.             manifestDb,
  1477.             /* isVideo= */ true),
  1478.       };
  1479.     });
  1480.     // Try to delete the sessions; any sessions that weren't deleted get stored
  1481.     // in the database so we can try to remove them again later.  This allows us
  1482.     // to still delete the stored content but not "forget" about these sessions.
  1483.     // Later, we can remove the sessions to free up space.
  1484.     const deleter = new shaka.offline.SessionDeleter();
  1485.     const deletedSessionIds = await deleter.delete(drmConfig, net, sessions);
  1486.     await sessionIdCell.remove(deletedSessionIds);
  1487.     await sessionIdCell.add(sessions.filter(
  1488.         (session) => !deletedSessionIds.includes(session.sessionId)));
  1489.   }
  1491.   /**
  1492.    * Get the set of all streams in |manifest|.
  1493.    *
  1494.    * @param {shaka.extern.Manifest} manifest
  1495.    * @return {!Set.<shaka.extern.Stream>}
  1496.    * @private
  1497.    */
  1498.   static getAllStreamsFromManifest_(manifest) {
  1499.     /** @type {!Set.<shaka.extern.Stream>} */
  1500.     const set = new Set();
  1502.     for (const text of manifest.textStreams) {
  1503.       set.add(text);
  1504.     }
  1506.     for (const image of manifest.imageStreams) {
  1507.       set.add(image);
  1508.     }
  1510.     for (const variant of manifest.variants) {
  1511.       if (variant.audio) {
  1512.         set.add(variant.audio);
  1513.       }
  1514.       if (variant.video) {
  1515.         set.add(variant.video);
  1516.       }
  1517.     }
  1519.     return set;
  1520.   }
  1522.   /**
  1523.    * Go over a manifest and issue warnings for any suspicious properties.
  1524.    *
  1525.    * @param {shaka.extern.Manifest} manifest
  1526.    * @private
  1527.    */
  1528.   static validateManifest_(manifest) {
  1529.     const videos = new Set(manifest.variants.map((v) => v.video));
  1530.     const audios = new Set(manifest.variants.map((v) => v.audio));
  1531.     const texts = manifest.textStreams;
  1533.     if (videos.size > 1) {
  1534.       shaka.log.warning('Multiple video tracks selected to be stored');
  1535.     }
  1537.     for (const audio1 of audios) {
  1538.       for (const audio2 of audios) {
  1539.         if (audio1 != audio2 && audio1.language == audio2.language) {
  1540.           shaka.log.warning(
  1541.               'Similar audio tracks were selected to be stored',
  1542.               audio1.id,
  1543.               audio2.id);
  1544.         }
  1545.       }
  1546.     }
  1548.     for (const text1 of texts) {
  1549.       for (const text2 of texts) {
  1550.         if (text1 != text2 && text1.language == text2.language) {
  1551.           shaka.log.warning(
  1552.               'Similar text tracks were selected to be stored',
  1553.               text1.id,
  1554.               text2.id);
  1555.         }
  1556.       }
  1557.     }
  1558.   }
  1559. };
  1561. shaka.offline.Storage.defaultSystemIds_ = new Map()
  1562.     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
  1563.     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')
  1564.     .set('com.microsoft.playready', '9a04f07998404286ab92e65be0885f95')
  1565.     .set('com.microsoft.playready.recommendation',
  1566.         '9a04f07998404286ab92e65be0885f95')
  1567.     .set('com.microsoft.playready.software',
  1568.         '9a04f07998404286ab92e65be0885f95')
  1569.     .set('com.microsoft.playready.hardware',
  1570.         '9a04f07998404286ab92e65be0885f95')
  1571.     .set('com.adobe.primetime', 'f239e769efa348509c16a903c6932efb');
  1573. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);