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 MediaCapabilities will be able
  487.     // to play later (no point storing something we can't play).
  488.     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
  489.         manifest, config.offline.usePersistentLicense);
  491.     // Gather all tracks.
  492.     const allTracks = [];
  494.     // Choose the codec that has the lowest average bandwidth.
  495.     const preferredAudioChannelCount = config.preferredAudioChannelCount;
  496.     const preferredDecodingAttributes = config.preferredDecodingAttributes;
  497.     const preferredVideoCodecs = config.preferredVideoCodecs;
  498.     const preferredAudioCodecs = config.preferredAudioCodecs;
  500.     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  501.         manifest, preferredVideoCodecs, preferredAudioCodecs,
  502.         preferredAudioChannelCount, preferredDecodingAttributes);
  504.     for (const variant of manifest.variants) {
  505.       goog.asserts.assert(
  506.           shaka.util.StreamUtils.isPlayable(variant),
  507.           'We should have already filtered by "is playable"');
  509.       allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
  510.     }
  512.     for (const text of manifest.textStreams) {
  513.       allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
  514.     }
  516.     for (const image of manifest.imageStreams) {
  517.       allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
  518.     }
  520.     // Let the application choose which tracks to store.
  521.     const chosenTracks =
  522.         await config.offline.trackSelectionCallback(allTracks);
  523.     const duration = manifest.presentationTimeline.getDuration();
  524.     let sizeEstimate = 0;
  525.     for (const track of chosenTracks) {
  526.       const trackSize = track.bandwidth * duration / 8;
  527.       sizeEstimate += trackSize;
  528.     }
  529.     try {
  530.       const allowedDownload =
  531.           await config.offline.downloadSizeCallback(sizeEstimate);
  532.       if (!allowedDownload) {
  533.         throw new shaka.util.Error(
  534.             shaka.util.Error.Severity.CRITICAL,
  535.             shaka.util.Error.Category.STORAGE,
  536.             shaka.util.Error.Code.STORAGE_LIMIT_REACHED);
  537.       }
  538.     } catch (e) {
  539.       // It is necessary to be able to catch the STORAGE_LIMIT_REACHED error
  540.       if (e instanceof shaka.util.Error) {
  541.         throw e;
  542.       }
  543.       shaka.log.warning(
  544.           'downloadSizeCallback has produced an unexpected error', e);
  545.       throw new shaka.util.Error(
  546.           shaka.util.Error.Severity.CRITICAL,
  547.           shaka.util.Error.Category.STORAGE,
  548.           shaka.util.Error.Code.DOWNLOAD_SIZE_CALLBACK_ERROR);
  549.     }
  551.     /** @type {!Set.<number>} */
  552.     const variantIds = new Set();
  553.     /** @type {!Set.<number>} */
  554.     const textIds = new Set();
  555.     /** @type {!Set.<number>} */
  556.     const imageIds = new Set();
  558.     // Collect the IDs of the chosen tracks.
  559.     for (const track of chosenTracks) {
  560.       if (track.type == 'variant') {
  561.         variantIds.add(track.id);
  562.       }
  563.       if (track.type == 'text') {
  564.         textIds.add(track.id);
  565.       }
  566.       if (track.type == 'image') {
  567.         imageIds.add(track.id);
  568.       }
  569.     }
  571.     // Filter the manifest to keep only what the app chose.
  572.     manifest.variants =
  573.         manifest.variants.filter((variant) => variantIds.has(variant.id));
  574.     manifest.textStreams =
  575.         manifest.textStreams.filter((stream) => textIds.has(stream.id));
  576.     manifest.imageStreams =
  577.         manifest.imageStreams.filter((stream) => imageIds.has(stream.id));
  579.     // Check the post-filtered manifest for characteristics that may indicate
  580.     // issues with how the app selected tracks.
  581.     shaka.offline.Storage.validateManifest_(manifest);
  582.   }
  584.   /**
  585.    * Create a download manager and download the manifest.
  586.    *
  587.    * @param {shaka.extern.StorageCell} storage
  588.    * @param {!shaka.media.DrmEngine} drmEngine
  589.    * @param {shaka.extern.Manifest} manifest
  590.    * @param {string} uri
  591.    * @param {!Object} metadata
  592.    * @param {shaka.extern.PlayerConfiguration} config
  593.    * @param {!shaka.offline.DownloadManager} downloader
  594.    * @return {!Promise.<shaka.extern.ManifestDB>}
  595.    * @private
  596.    */
  597.   async downloadManifest_(
  598.       storage, drmEngine, manifest, uri, metadata, config, downloader) {
  599.     const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
  600.         uri, manifest, /* size= */ 0, metadata);
  601.     // In https://github.com/shaka-project/shaka-player/issues/2652, we found
  602.     // that this callback would be removed by the compiler if we reference the
  603.     // config in the onProgress closure below.  Reading it into a local
  604.     // variable first seems to work around this apparent compiler bug.
  605.     const progressCallback = config.offline.progressCallback;
  607.     const onProgress = (progress, size) => {
  608.       // Update the size of the stored content before issuing a progress
  609.       // update.
  610.       pendingContent.size = size;
  611.       progressCallback(pendingContent, progress);
  612.     };
  613.     const onInitData = (initData, systemId) => {
  614.       if (needsInitData && config.offline.usePersistentLicense &&
  615.           currentSystemId == systemId) {
  616.         drmEngine.newInitData('cenc', initData);
  617.       }
  618.     };
  619.     downloader.setCallbacks(onProgress, onInitData);
  621.     const isEncrypted = manifest.variants.some((variant) => {
  622.       const videoEncrypted = variant.video && variant.video.encrypted;
  623.       const audioEncrypted = variant.audio && variant.audio.encrypted;
  624.       return videoEncrypted || audioEncrypted;
  625.     });
  626.     const includesInitData = manifest.variants.some((variant) => {
  627.       const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  628.       const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  629.       const drmInfos = videoDrmInfos.concat(audioDrmInfos);
  630.       return drmInfos.some((drmInfos) => {
  631.         return drmInfos.initData && drmInfos.initData.length;
  632.       });
  633.     });
  634.     const needsInitData = isEncrypted && !includesInitData;
  636.     let currentSystemId = null;
  637.     if (needsInitData) {
  638.       const drmInfo = drmEngine.getDrmInfo();
  639.       currentSystemId =
  640.           shaka.offline.Storage.defaultSystemIds_.get(drmInfo.keySystem);
  641.     }
  643.     try {
  644.       const manifestDB = this.createOfflineManifest_(
  645.           downloader, storage, drmEngine, manifest, uri, metadata, config);
  647.       manifestDB.size = await downloader.waitToFinish();
  648.       manifestDB.expiration = drmEngine.getExpiration();
  649.       const sessions = drmEngine.getSessionIds();
  650.       manifestDB.sessionIds = config.offline.usePersistentLicense ?
  651.           sessions : [];
  653.       if (isEncrypted && config.offline.usePersistentLicense &&
  654.           !sessions.length) {
  655.         throw new shaka.util.Error(
  656.             shaka.util.Error.Severity.CRITICAL,
  657.             shaka.util.Error.Category.STORAGE,
  658.             shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE);
  659.       }
  661.       return manifestDB;
  662.     } finally {
  663.       await downloader.destroy();
  664.     }
  665.   }
  667.   /**
  668.    * Removes the given stored content.  This will also attempt to release the
  669.    * licenses, if any.
  670.    *
  671.    * @param {string} contentUri
  672.    * @return {!Promise}
  673.    * @export
  674.    */
  675.   remove(contentUri) {
  676.     return this.startOperation_(this.remove_(contentUri));
  677.   }
  679.   /**
  680.    * See |shaka.offline.Storage.remove| for details.
  681.    *
  682.    * @param {string} contentUri
  683.    * @return {!Promise}
  684.    * @private
  685.    */
  686.   async remove_(contentUri) {
  687.     this.requireSupport_();
  689.     const nullableUri = shaka.offline.OfflineUri.parse(contentUri);
  690.     if (nullableUri == null || !nullableUri.isManifest()) {
  691.       throw new shaka.util.Error(
  692.           shaka.util.Error.Severity.CRITICAL,
  693.           shaka.util.Error.Category.STORAGE,
  694.           shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  695.           contentUri);
  696.     }
  698.     /** @type {!shaka.offline.OfflineUri} */
  699.     const uri = nullableUri;
  701.     /** @type {!shaka.offline.StorageMuxer} */
  702.     const muxer = new shaka.offline.StorageMuxer();
  704.     try {
  705.       await muxer.init();
  707.       const cell = await muxer.getCell(uri.mechanism(), uri.cell());
  708.       const manifests = await cell.getManifests([uri.key()]);
  709.       const manifest = manifests[0];
  711.       await Promise.all([
  712.         this.removeFromDRM_(uri, manifest, muxer),
  713.         this.removeFromStorage_(cell, uri, manifest),
  714.       ]);
  715.     } finally {
  716.       await muxer.destroy();
  717.     }
  718.   }
  720.   /**
  721.    * @param {shaka.extern.ManifestDB} manifestDb
  722.    * @param {boolean} isVideo
  723.    * @return {!Array.<MediaKeySystemMediaCapability>}
  724.    * @private
  725.    */
  726.   static getCapabilities_(manifestDb, isVideo) {
  727.     const MimeUtils = shaka.util.MimeUtils;
  729.     const ret = [];
  730.     for (const stream of manifestDb.streams) {
  731.       if (isVideo && stream.type == 'video') {
  732.         ret.push({
  733.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  734.           robustness: manifestDb.drmInfo.videoRobustness,
  735.         });
  736.       } else if (!isVideo && stream.type == 'audio') {
  737.         ret.push({
  738.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  739.           robustness: manifestDb.drmInfo.audioRobustness,
  740.         });
  741.       }
  742.     }
  743.     return ret;
  744.   }
  746.   /**
  747.    * @param {!shaka.offline.OfflineUri} uri
  748.    * @param {shaka.extern.ManifestDB} manifestDb
  749.    * @param {!shaka.offline.StorageMuxer} muxer
  750.    * @return {!Promise}
  751.    * @private
  752.    */
  753.   async removeFromDRM_(uri, manifestDb, muxer) {
  754.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  755.     await shaka.offline.Storage.deleteLicenseFor_(
  756.         this.networkingEngine_, this.config_.drm, muxer, manifestDb);
  757.   }
  759.   /**
  760.    * @param {shaka.extern.StorageCell} storage
  761.    * @param {!shaka.offline.OfflineUri} uri
  762.    * @param {shaka.extern.ManifestDB} manifest
  763.    * @return {!Promise}
  764.    * @private
  765.    */
  766.   removeFromStorage_( storage, uri, manifest) {
  767.     /** @type {!Array.<number>} */
  768.     const segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
  770.     // Count(segments) + Count(manifests)
  771.     const toRemove = segmentIds.length + 1;
  772.     let removed = 0;
  774.     const pendingContent = shaka.offline.StoredContentUtils.fromManifestDB(
  775.         uri, manifest);
  777.     const onRemove = (key) => {
  778.       removed += 1;
  779.       this.config_.offline.progressCallback(pendingContent, removed / toRemove);
  780.     };
  782.     return Promise.all([
  783.       storage.removeSegments(segmentIds, onRemove),
  784.       storage.removeManifests([uri.key()], onRemove),
  785.     ]);
  786.   }
  788.   /**
  789.    * Removes any EME sessions that were not successfully removed before.  This
  790.    * returns whether all the sessions were successfully removed.
  791.    *
  792.    * @return {!Promise.<boolean>}
  793.    * @export
  794.    */
  795.   removeEmeSessions() {
  796.     return this.startOperation_(this.removeEmeSessions_());
  797.   }
  799.   /**
  800.    * @return {!Promise.<boolean>}
  801.    * @private
  802.    */
  803.   async removeEmeSessions_() {
  804.     this.requireSupport_();
  806.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  807.     const net = this.networkingEngine_;
  808.     const config = this.config_.drm;
  810.     /** @type {!shaka.offline.StorageMuxer} */
  811.     const muxer = new shaka.offline.StorageMuxer();
  812.     /** @type {!shaka.offline.SessionDeleter} */
  813.     const deleter = new shaka.offline.SessionDeleter();
  815.     let hasRemaining = false;
  817.     try {
  818.       await muxer.init();
  820.       /** @type {!Array.<shaka.extern.EmeSessionStorageCell>} */
  821.       const cells = [];
  822.       muxer.forEachEmeSessionCell((c) => cells.push(c));
  824.       // Run these sequentially to avoid creating too many DrmEngine instances
  825.       // and having multiple CDMs alive at once.  Some embedded platforms may
  826.       // not support that.
  827.       for (const sessionIdCell of cells) {
  828.         /* eslint-disable no-await-in-loop */
  829.         const sessions = await sessionIdCell.getAll();
  830.         const deletedSessionIds = await deleter.delete(config, net, sessions);
  831.         await sessionIdCell.remove(deletedSessionIds);
  833.         if (deletedSessionIds.length != sessions.length) {
  834.           hasRemaining = true;
  835.         }
  836.         /* eslint-enable no-await-in-loop */
  837.       }
  838.     } finally {
  839.       await muxer.destroy();
  840.     }
  842.     return !hasRemaining;
  843.   }
  845.   /**
  846.    * Lists all the stored content available.
  847.    *
  848.    * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}  A Promise to an
  849.    *   array of structures representing all stored content.  The "offlineUri"
  850.    *   member of the structure is the URI that should be given to Player.load()
  851.    *   to play this piece of content offline.  The "appMetadata" member is the
  852.    *   appMetadata argument you passed to store().
  853.    * @export
  854.    */
  855.   list() {
  856.     return this.startOperation_(this.list_());
  857.   }
  859.   /**
  860.    * See |shaka.offline.Storage.list| for details.
  861.    *
  862.    * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}
  863.    * @private
  864.    */
  865.   async list_() {
  866.     this.requireSupport_();
  868.     /** @type {!Array.<shaka.extern.StoredContent>} */
  869.     const result = [];
  871.     /** @type {!shaka.offline.StorageMuxer} */
  872.     const muxer = new shaka.offline.StorageMuxer();
  873.     try {
  874.       await muxer.init();
  876.       let p = Promise.resolve();
  877.       muxer.forEachCell((path, cell) => {
  878.         p = p.then(async () => {
  879.           const manifests = await cell.getAllManifests();
  881.           manifests.forEach((manifest, key) => {
  882.             const uri = shaka.offline.OfflineUri.manifest(
  883.                 path.mechanism,
  884.                 path.cell,
  885.                 key);
  887.             const content = shaka.offline.StoredContentUtils.fromManifestDB(
  888.                 uri,
  889.                 manifest);
  891.             result.push(content);
  892.           });
  893.         });
  894.       });
  896.       await p;
  897.     } finally {
  898.       await muxer.destroy();
  899.     }
  901.     return result;
  902.   }
  905.   /**
  906.    * This method is public so that it can be overridden in testing.
  907.    *
  908.    * @param {string} uri
  909.    * @param {shaka.extern.ManifestParser} parser
  910.    * @param {shaka.extern.PlayerConfiguration} config
  911.    * @return {!Promise.<shaka.extern.Manifest>}
  912.    */
  913.   async parseManifest(uri, parser, config) {
  914.     let error = null;
  916.     const networkingEngine = this.networkingEngine_;
  917.     goog.asserts.assert(networkingEngine, 'Should be initialized!');
  919.     /** @type {shaka.extern.ManifestParser.PlayerInterface} */
  920.     const playerInterface = {
  921.       networkingEngine: networkingEngine,
  923.       // Don't bother filtering now. We will do that later when we have all the
  924.       // information we need to filter.
  925.       filter: () => Promise.resolve(),
  927.       // The responsibility for making mock text streams for closed captions is
  928.       // handled inside shaka.offline.OfflineManifestParser, before playback.
  929.       makeTextStreamsForClosedCaptions: (manifest) => {},
  931.       onTimelineRegionAdded: () => {},
  932.       onEvent: () => {},
  934.       // Used to capture an error from the manifest parser. We will check the
  935.       // error before returning.
  936.       onError: (e) => {
  937.         error = e;
  938.       },
  939.       isLowLatencyMode: () => false,
  940.       isAutoLowLatencyMode: () => false,
  941.       enableLowLatencyMode: () => {},
  942.     };
  944.     parser.configure(config.manifest);
  946.     // We may have been destroyed while we were waiting on |getParser| to
  947.     // resolve.
  948.     this.ensureNotDestroyed_();
  950.     const manifest = await parser.start(uri, playerInterface);
  952.     // We may have been destroyed while we were waiting on |start| to
  953.     // resolve.
  954.     this.ensureNotDestroyed_();
  956.     // Get all the streams that are used in the manifest.
  957.     const streams =
  958.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  960.     // Wait for each stream to create their segment indexes.
  961.     await Promise.all(shaka.util.Iterables.map(streams, (stream) => {
  962.       return stream.createSegmentIndex();
  963.     }));
  965.     // We may have been destroyed while we were waiting on
  966.     // |createSegmentIndex| to resolve for each stream.
  967.     this.ensureNotDestroyed_();
  969.     // If we saw an error while parsing, surface the error.
  970.     if (error) {
  971.       throw error;
  972.     }
  974.     return manifest;
  975.   }
  977.   /**
  978.    * This method is public so that it can be override in testing.
  979.    *
  980.    * @param {shaka.extern.Manifest} manifest
  981.    * @param {function(shaka.util.Error)} onError
  982.    * @param {shaka.extern.PlayerConfiguration} config
  983.    * @return {!Promise.<!shaka.media.DrmEngine>}
  984.    */
  985.   async createDrmEngine(manifest, onError, config) {
  986.     goog.asserts.assert(
  987.         this.networkingEngine_,
  988.         'Cannot call |createDrmEngine| after |destroy|');
  990.     /** @type {!shaka.media.DrmEngine} */
  991.     const drmEngine = new shaka.media.DrmEngine({
  992.       netEngine: this.networkingEngine_,
  993.       onError: onError,
  994.       onKeyStatus: () => {},
  995.       onExpirationUpdated: () => {},
  996.       onEvent: () => {},
  997.     });
  999.     drmEngine.configure(config.drm);
  1000.     await drmEngine.initForStorage(
  1001.         manifest.variants, config.offline.usePersistentLicense);
  1002.     await drmEngine.setServerCertificate();
  1003.     await drmEngine.createOrLoad();
  1005.     return drmEngine;
  1006.   }
  1008.   /**
  1009.    * Creates an offline 'manifest' for the real manifest.  This does not store
  1010.    * the segments yet, only adds them to the download manager through
  1011.    * createStreams_.
  1012.    *
  1013.    * @param {!shaka.offline.DownloadManager} downloader
  1014.    * @param {shaka.extern.StorageCell} storage
  1015.    * @param {!shaka.media.DrmEngine} drmEngine
  1016.    * @param {shaka.extern.Manifest} manifest
  1017.    * @param {string} originalManifestUri
  1018.    * @param {!Object} metadata
  1019.    * @param {shaka.extern.PlayerConfiguration} config
  1020.    * @return {shaka.extern.ManifestDB}
  1021.    * @private
  1022.    */
  1023.   createOfflineManifest_(
  1024.       downloader, storage, drmEngine, manifest, originalManifestUri, metadata,
  1025.       config) {
  1026.     const estimator = new shaka.offline.StreamBandwidthEstimator();
  1028.     const streams = this.createStreams_(
  1029.         downloader, storage, estimator, drmEngine, manifest, config);
  1031.     const usePersistentLicense = config.offline.usePersistentLicense;
  1032.     const drmInfo = drmEngine.getDrmInfo();
  1034.     if (drmInfo && usePersistentLicense) {
  1035.       // Don't store init data, since we have stored sessions.
  1036.       drmInfo.initData = [];
  1037.     }
  1039.     return {
  1040.       creationTime: Date.now(),
  1041.       originalManifestUri: originalManifestUri,
  1042.       duration: manifest.presentationTimeline.getDuration(),
  1043.       size: 0,
  1044.       expiration: drmEngine.getExpiration(),
  1045.       streams: streams,
  1046.       sessionIds: usePersistentLicense ? drmEngine.getSessionIds() : [],
  1047.       drmInfo: drmInfo,
  1048.       appMetadata: metadata,
  1049.     };
  1050.   }
  1052.   /**
  1053.    * Converts manifest Streams to database Streams.  This will use the current
  1054.    * configuration to get the tracks to use, then it will search each segment
  1055.    * index and add all the segments to the download manager through
  1056.    * createStream_.
  1057.    *
  1058.    * @param {!shaka.offline.DownloadManager} downloader
  1059.    * @param {shaka.extern.StorageCell} storage
  1060.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1061.    * @param {!shaka.media.DrmEngine} drmEngine
  1062.    * @param {shaka.extern.Manifest} manifest
  1063.    * @param {shaka.extern.PlayerConfiguration} config
  1064.    * @return {!Array.<shaka.extern.StreamDB>}
  1065.    * @private
  1066.    */
  1067.   createStreams_(downloader, storage, estimator, drmEngine, manifest, config) {
  1068.     // Pass all variants and text streams to the estimator so that we can
  1069.     // get the best estimate for each stream later.
  1070.     for (const variant of manifest.variants) {
  1071.       estimator.addVariant(variant);
  1072.     }
  1073.     for (const text of manifest.textStreams) {
  1074.       estimator.addText(text);
  1075.     }
  1076.     for (const image of manifest.imageStreams) {
  1077.       estimator.addImage(image);
  1078.     }
  1080.     // TODO(joeyparrish): Break out stack-based state and method params into a
  1081.     // separate class to clean up.  See:
  1082.     // https://github.com/google/shaka-player/issues/2781#issuecomment-678438039
  1084.     /**
  1085.      * A cache mapping init segment references to Promises to their DB key.
  1086.      *
  1087.      * @type {!Map.<shaka.media.InitSegmentReference, !Promise.<?number>>}
  1088.      */
  1089.     const initSegmentDbKeyCache = new Map();
  1091.     // A null init segment reference always maps to a null DB key.
  1092.     initSegmentDbKeyCache.set(
  1093.         null, /** @type {!Promise.<?number>} */(Promise.resolve(null)));
  1095.     /**
  1096.      * A cache mapping equivalent segment references to Promises to their DB
  1097.      * key.  The key in this map is a string of the form
  1098.      * "<URI>-<startByte>-<endByte>".
  1099.      *
  1100.      * @type {!Map.<string, !Promise.<number>>}
  1101.      */
  1102.     const segmentDbKeyCache = new Map();
  1104.     // Find the streams we want to download and create a stream db instance
  1105.     // for each of them.
  1106.     const streamSet =
  1107.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1108.     const streamDBs = new Map();
  1110.     for (const stream of streamSet) {
  1111.       const streamDB = this.createStream_(
  1112.           downloader, storage, estimator, manifest, stream, config,
  1113.           initSegmentDbKeyCache, segmentDbKeyCache);
  1114.       streamDBs.set(stream.id, streamDB);
  1115.     }
  1117.     // Connect streams and variants together.
  1118.     for (const variant of manifest.variants) {
  1119.       if (variant.audio) {
  1120.         streamDBs.get(variant.audio.id).variantIds.push(variant.id);
  1121.       }
  1122.       if (variant.video) {
  1123.         streamDBs.get(variant.video.id).variantIds.push(variant.id);
  1124.       }
  1125.     }
  1127.     return Array.from(streamDBs.values());
  1128.   }
  1130.   /**
  1131.    * Converts a manifest stream to a database stream.  This will search the
  1132.    * segment index and add all the segments to the download manager.
  1133.    *
  1134.    * @param {!shaka.offline.DownloadManager} downloader
  1135.    * @param {shaka.extern.StorageCell} storage
  1136.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1137.    * @param {shaka.extern.Manifest} manifest
  1138.    * @param {shaka.extern.Stream} stream
  1139.    * @param {shaka.extern.PlayerConfiguration} config
  1140.    * @param {!Map.<shaka.media.InitSegmentReference, !Promise.<?number>>}
  1141.    *   initSegmentDbKeyCache
  1142.    * @param {!Map.<string, !Promise.<number>>} segmentDbKeyCache
  1143.    * @return {shaka.extern.StreamDB}
  1144.    * @private
  1145.    */
  1146.   createStream_(downloader, storage, estimator, manifest, stream, config,
  1147.       initSegmentDbKeyCache, segmentDbKeyCache) {
  1148.     /** @type {shaka.extern.StreamDB} */
  1149.     const streamDb = {
  1150.       id: stream.id,
  1151.       originalId: stream.originalId,
  1152.       primary: stream.primary,
  1153.       type: stream.type,
  1154.       mimeType: stream.mimeType,
  1155.       codecs: stream.codecs,
  1156.       frameRate: stream.frameRate,
  1157.       pixelAspectRatio: stream.pixelAspectRatio,
  1158.       hdr: stream.hdr,
  1159.       kind: stream.kind,
  1160.       language: stream.language,
  1161.       label: stream.label,
  1162.       width: stream.width || null,
  1163.       height: stream.height || null,
  1164.       encrypted: stream.encrypted,
  1165.       keyIds: stream.keyIds,
  1166.       segments: [],
  1167.       variantIds: [],
  1168.       roles: stream.roles,
  1169.       forced: stream.forced,
  1170.       channelsCount: stream.channelsCount,
  1171.       audioSamplingRate: stream.audioSamplingRate,
  1172.       spatialAudio: stream.spatialAudio,
  1173.       closedCaptions: stream.closedCaptions,
  1174.       tilesLayout: stream.tilesLayout,
  1175.     };
  1177.     // Download each stream in parallel.
  1178.     const downloadGroup = stream.id;
  1180.     const startTime =
  1181.         manifest.presentationTimeline.getSegmentAvailabilityStart();
  1183.     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
  1184.       const initSegmentKeyPromise = this.getInitSegmentDbKey_(
  1185.           downloader, downloadGroup, stream.id, storage, estimator,
  1186.           segment.initSegmentReference, config, initSegmentDbKeyCache);
  1188.       const segmentKeyPromise = this.getSegmentDbKey_(
  1189.           downloader, downloadGroup, stream.id, storage, estimator, segment,
  1190.           config, segmentDbKeyCache);
  1192.       downloader.queueWork(downloadGroup, async () => {
  1193.         const initSegmentKey = await initSegmentKeyPromise;
  1194.         const dataKey = await segmentKeyPromise;
  1196.         streamDb.segments.push({
  1197.           initSegmentKey,
  1198.           startTime: segment.startTime,
  1199.           endTime: segment.endTime,
  1200.           appendWindowStart: segment.appendWindowStart,
  1201.           appendWindowEnd: segment.appendWindowEnd,
  1202.           timestampOffset: segment.timestampOffset,
  1203.           tilesLayout: segment.tilesLayout,
  1204.           dataKey,
  1205.         });
  1206.       });
  1207.     });
  1209.     return streamDb;
  1210.   }
  1212.   /**
  1213.    * Get a Promise to the DB key for a given init segment reference.
  1214.    *
  1215.    * The return values will be cached so that multiple calls with the same init
  1216.    * segment reference will only trigger one request.
  1217.    *
  1218.    * @param {!shaka.offline.DownloadManager} downloader
  1219.    * @param {number} downloadGroup
  1220.    * @param {number} streamId
  1221.    * @param {shaka.extern.StorageCell} storage
  1222.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1223.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  1224.    * @param {shaka.extern.PlayerConfiguration} config
  1225.    * @param {!Map.<shaka.media.InitSegmentReference, !Promise.<?number>>}
  1226.    *   initSegmentDbKeyCache
  1227.    * @return {!Promise.<?number>}
  1228.    * @private
  1229.    */
  1230.   getInitSegmentDbKey_(
  1231.       downloader, downloadGroup, streamId, storage, estimator,
  1232.       initSegmentReference, config, initSegmentDbKeyCache) {
  1233.     if (initSegmentDbKeyCache.has(initSegmentReference)) {
  1234.       return initSegmentDbKeyCache.get(initSegmentReference);
  1235.     }
  1237.     const request = shaka.util.Networking.createSegmentRequest(
  1238.         initSegmentReference.getUris(),
  1239.         initSegmentReference.startByte,
  1240.         initSegmentReference.endByte,
  1241.         config.streaming.retryParameters);
  1243.     const promise = downloader.queue(
  1244.         downloadGroup,
  1245.         request,
  1246.         estimator.getInitSegmentEstimate(streamId),
  1247.         /* isInitSegment= */ true,
  1248.         async (data) => {
  1249.           /** @type {!Array.<number>} */
  1250.           const ids = await storage.addSegments([{data: data}]);
  1251.           this.segmentsFromStore_.push(ids[0]);
  1252.           return ids[0];
  1253.         });
  1255.     initSegmentDbKeyCache.set(initSegmentReference, promise);
  1256.     return promise;
  1257.   }
  1259.   /**
  1260.    * Get a Promise to the DB key for a given segment reference.
  1261.    *
  1262.    * The return values will be cached so that multiple calls with the same
  1263.    * segment reference will only trigger one request.
  1264.    *
  1265.    * @param {!shaka.offline.DownloadManager} downloader
  1266.    * @param {number} downloadGroup
  1267.    * @param {number} streamId
  1268.    * @param {shaka.extern.StorageCell} storage
  1269.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1270.    * @param {shaka.media.SegmentReference} segmentReference
  1271.    * @param {shaka.extern.PlayerConfiguration} config
  1272.    * @param {!Map.<string, !Promise.<number>>} segmentDbKeyCache
  1273.    * @return {!Promise.<number>}
  1274.    * @private
  1275.    */
  1276.   getSegmentDbKey_(
  1277.       downloader, downloadGroup, streamId, storage, estimator,
  1278.       segmentReference, config, segmentDbKeyCache) {
  1279.     const mapKey = [
  1280.       segmentReference.getUris()[0],
  1281.       segmentReference.startByte,
  1282.       segmentReference.endByte,
  1283.     ].join('-');
  1285.     if (segmentDbKeyCache.has(mapKey)) {
  1286.       return segmentDbKeyCache.get(mapKey);
  1287.     }
  1289.     const request = shaka.util.Networking.createSegmentRequest(
  1290.         segmentReference.getUris(),
  1291.         segmentReference.startByte,
  1292.         segmentReference.endByte,
  1293.         config.streaming.retryParameters);
  1295.     const promise = downloader.queue(
  1296.         downloadGroup,
  1297.         request,
  1298.         estimator.getSegmentEstimate(streamId, segmentReference),
  1299.         /* isInitSegment= */ false,
  1300.         async (data) => {
  1301.           /** @type {!Array.<number>} */
  1302.           const ids = await storage.addSegments([{data: data}]);
  1303.           this.segmentsFromStore_.push(ids[0]);
  1304.           return ids[0];
  1305.         });
  1307.     segmentDbKeyCache.set(mapKey, promise);
  1308.     return promise;
  1309.   }
  1311.   /**
  1312.    * @param {shaka.extern.Stream} stream
  1313.    * @param {number} startTime
  1314.    * @param {function(!shaka.media.SegmentReference)} callback
  1315.    * @private
  1316.    */
  1317.   static forEachSegment_(stream, startTime, callback) {
  1318.     /** @type {?number} */
  1319.     let i = stream.segmentIndex.find(startTime);
  1321.     if (i == null) {
  1322.       return;
  1323.     }
  1325.     /** @type {?shaka.media.SegmentReference} */
  1326.     let ref = stream.segmentIndex.get(i);
  1327.     while (ref) {
  1328.       callback(ref);
  1329.       ref = stream.segmentIndex.get(++i);
  1330.     }
  1331.   }
  1333.   /**
  1334.    * Throws an error if the object is destroyed.
  1335.    * @private
  1336.    */
  1337.   ensureNotDestroyed_() {
  1338.     if (this.destroyer_.destroyed()) {
  1339.       throw new shaka.util.Error(
  1340.           shaka.util.Error.Severity.CRITICAL,
  1341.           shaka.util.Error.Category.STORAGE,
  1342.           shaka.util.Error.Code.OPERATION_ABORTED);
  1343.     }
  1344.   }
  1346.   /**
  1347.    * Used by functions that need storage support to ensure that the current
  1348.    * platform has storage support before continuing. This should only be
  1349.    * needed to be used at the start of public methods.
  1350.    *
  1351.    * @private
  1352.    */
  1353.   requireSupport_() {
  1354.     if (!shaka.offline.Storage.support()) {
  1355.       throw new shaka.util.Error(
  1356.           shaka.util.Error.Severity.CRITICAL,
  1357.           shaka.util.Error.Category.STORAGE,
  1358.           shaka.util.Error.Code.STORAGE_NOT_SUPPORTED);
  1359.     }
  1360.   }
  1362.   /**
  1363.    * Perform an action. Track the action's progress so that when we destroy
  1364.    * we will wait until all the actions have completed before allowing destroy
  1365.    * to resolve.
  1366.    *
  1367.    * @param {!Promise<T>} action
  1368.    * @return {!Promise<T>}
  1369.    * @template T
  1370.    * @private
  1371.    */
  1372.   async startOperation_(action) {
  1373.     this.openOperations_.push(action);
  1375.     try {
  1376.       // Await |action| so we can use the finally statement to remove |action|
  1377.       // from |openOperations_| when we still have a reference to |action|.
  1378.       return await action;
  1379.     } finally {
  1380.       shaka.util.ArrayUtils.remove(this.openOperations_, action);
  1381.     }
  1382.   }
  1384.   /**
  1385.    * The equivalent of startOperation_, but for abortable operations.
  1386.    *
  1387.    * @param {!shaka.extern.IAbortableOperation<T>} action
  1388.    * @return {!shaka.extern.IAbortableOperation<T>}
  1389.    * @template T
  1390.    * @private
  1391.    */
  1392.   startAbortableOperation_(action) {
  1393.     const promise = action.promise;
  1394.     this.openOperations_.push(promise);
  1396.     // Remove the open operation once the action has completed. So that we
  1397.     // can still return the AbortableOperation, this is done using a |finally|
  1398.     // block, rather than awaiting the result.
  1399.     return action.finally(() => {
  1400.       shaka.util.ArrayUtils.remove(this.openOperations_, promise);
  1401.     });
  1402.   }
  1404.   /**
  1405.    * @param {shaka.extern.ManifestDB} manifest
  1406.    * @return {!Array.<number>}
  1407.    * @private
  1408.    */
  1409.   static getAllSegmentIds_(manifest) {
  1410.     /** @type {!Array.<number>} */
  1411.     const ids = [];
  1413.     // Get every segment for every stream in the manifest.
  1414.     for (const stream of manifest.streams) {
  1415.       for (const segment of stream.segments) {
  1416.         if (segment.initSegmentKey != null) {
  1417.           ids.push(segment.initSegmentKey);
  1418.         }
  1420.         ids.push(segment.dataKey);
  1421.       }
  1422.     }
  1424.     return ids;
  1425.   }
  1427.   /**
  1428.    * Delete the on-disk storage and all the content it contains. This should not
  1429.    * be done in normal circumstances. Only do it when storage is rendered
  1430.    * unusable, such as by a version mismatch. No business logic will be run, and
  1431.    * licenses will not be released.
  1432.    *
  1433.    * @return {!Promise}
  1434.    * @export
  1435.    */
  1436.   static async deleteAll() {
  1437.     /** @type {!shaka.offline.StorageMuxer} */
  1438.     const muxer = new shaka.offline.StorageMuxer();
  1439.     try {
  1440.       // Wipe all content from all storage mechanisms.
  1441.       await muxer.erase();
  1442.     } finally {
  1443.       // Destroy the muxer, whether or not erase() succeeded.
  1444.       await muxer.destroy();
  1445.     }
  1446.   }
  1448.   /**
  1449.    * @param {!shaka.net.NetworkingEngine} net
  1450.    * @param {!shaka.extern.DrmConfiguration} drmConfig
  1451.    * @param {!shaka.offline.StorageMuxer} muxer
  1452.    * @param {shaka.extern.ManifestDB} manifestDb
  1453.    * @return {!Promise}
  1454.    * @private
  1455.    */
  1456.   static async deleteLicenseFor_(net, drmConfig, muxer, manifestDb) {
  1457.     if (!manifestDb.drmInfo) {
  1458.       return;
  1459.     }
  1461.     const sessionIdCell = muxer.getEmeSessionCell();
  1463.     /** @type {!Array.<shaka.extern.EmeSessionDB>} */
  1464.     const sessions = manifestDb.sessionIds.map((sessionId) => {
  1465.       return {
  1466.         sessionId: sessionId,
  1467.         keySystem: manifestDb.drmInfo.keySystem,
  1468.         licenseUri: manifestDb.drmInfo.licenseServerUri,
  1469.         serverCertificate: manifestDb.drmInfo.serverCertificate,
  1470.         audioCapabilities: shaka.offline.Storage.getCapabilities_(
  1471.             manifestDb,
  1472.             /* isVideo= */ false),
  1473.         videoCapabilities: shaka.offline.Storage.getCapabilities_(
  1474.             manifestDb,
  1475.             /* isVideo= */ true),
  1476.       };
  1477.     });
  1478.     // Try to delete the sessions; any sessions that weren't deleted get stored
  1479.     // in the database so we can try to remove them again later.  This allows us
  1480.     // to still delete the stored content but not "forget" about these sessions.
  1481.     // Later, we can remove the sessions to free up space.
  1482.     const deleter = new shaka.offline.SessionDeleter();
  1483.     const deletedSessionIds = await deleter.delete(drmConfig, net, sessions);
  1484.     await sessionIdCell.remove(deletedSessionIds);
  1485.     await sessionIdCell.add(sessions.filter(
  1486.         (session) => !deletedSessionIds.includes(session.sessionId)));
  1487.   }
  1489.   /**
  1490.    * Get the set of all streams in |manifest|.
  1491.    *
  1492.    * @param {shaka.extern.Manifest} manifest
  1493.    * @return {!Set.<shaka.extern.Stream>}
  1494.    * @private
  1495.    */
  1496.   static getAllStreamsFromManifest_(manifest) {
  1497.     /** @type {!Set.<shaka.extern.Stream>} */
  1498.     const set = new Set();
  1500.     for (const text of manifest.textStreams) {
  1501.       set.add(text);
  1502.     }
  1504.     for (const image of manifest.imageStreams) {
  1505.       set.add(image);
  1506.     }
  1508.     for (const variant of manifest.variants) {
  1509.       if (variant.audio) {
  1510.         set.add(variant.audio);
  1511.       }
  1512.       if (variant.video) {
  1513.         set.add(variant.video);
  1514.       }
  1515.     }
  1517.     return set;
  1518.   }
  1520.   /**
  1521.    * Go over a manifest and issue warnings for any suspicious properties.
  1522.    *
  1523.    * @param {shaka.extern.Manifest} manifest
  1524.    * @private
  1525.    */
  1526.   static validateManifest_(manifest) {
  1527.     const videos = new Set(manifest.variants.map((v) => v.video));
  1528.     const audios = new Set(manifest.variants.map((v) => v.audio));
  1529.     const texts = manifest.textStreams;
  1531.     if (videos.size > 1) {
  1532.       shaka.log.warning('Multiple video tracks selected to be stored');
  1533.     }
  1535.     for (const audio1 of audios) {
  1536.       for (const audio2 of audios) {
  1537.         if (audio1 != audio2 && audio1.language == audio2.language) {
  1538.           shaka.log.warning(
  1539.               'Similar audio tracks were selected to be stored',
  1540.               audio1.id,
  1541.               audio2.id);
  1542.         }
  1543.       }
  1544.     }
  1546.     for (const text1 of texts) {
  1547.       for (const text2 of texts) {
  1548.         if (text1 != text2 && text1.language == text2.language) {
  1549.           shaka.log.warning(
  1550.               'Similar text tracks were selected to be stored',
  1551.               text1.id,
  1552.               text2.id);
  1553.         }
  1554.       }
  1555.     }
  1556.   }
  1557. };
  1559. shaka.offline.Storage.defaultSystemIds_ = new Map()
  1560.     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
  1561.     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')
  1562.     .set('com.microsoft.playready', '9a04f07998404286ab92e65be0885f95')
  1563.     .set('com.microsoft.playready.recommendation',
  1564.         '9a04f07998404286ab92e65be0885f95')
  1565.     .set('com.microsoft.playready.software',
  1566.         '9a04f07998404286ab92e65be0885f95')
  1567.     .set('com.microsoft.playready.hardware',
  1568.         '9a04f07998404286ab92e65be0885f95')
  1569.     .set('com.adobe.primetime', 'f239e769efa348509c16a903c6932efb');
  1571. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);