Source: lib/offline/storage.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.offline.Storage');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.Deprecate');
  22. goog.require('shaka.Player');
  23. goog.require('shaka.log');
  24. goog.require('shaka.media.DrmEngine');
  25. goog.require('shaka.media.ManifestParser');
  26. goog.require('shaka.net.NetworkingEngine');
  27. goog.require('shaka.offline.DownloadManager');
  28. goog.require('shaka.offline.OfflineUri');
  29. goog.require('shaka.offline.SessionDeleter');
  30. goog.require('shaka.offline.StorageMuxer');
  31. goog.require('shaka.offline.StoredContentUtils');
  32. goog.require('shaka.offline.StreamBandwidthEstimator');
  33. goog.require('shaka.util.ArrayUtils');
  34. goog.require('shaka.util.Destroyer');
  35. goog.require('shaka.util.Error');
  36. goog.require('shaka.util.IDestroyable');
  37. goog.require('shaka.util.Iterables');
  38. goog.require('shaka.util.ManifestFilter');
  39. goog.require('shaka.util.Networking');
  40. goog.require('shaka.util.Periods');
  41. goog.require('shaka.util.Platform');
  42. goog.require('shaka.util.PlayerConfiguration');
  43. goog.require('shaka.util.StreamUtils');
  46. /**
  47.  * This manages persistent offline data including storage, listing, and deleting
  48.  * stored manifests.  Playback of offline manifests are done through the Player
  49.  * using a special URI (see shaka.offline.OfflineUri).
  50.  *
  51.  * First, check support() to see if offline is supported by the platform.
  52.  * Second, configure() the storage object with callbacks to your application.
  53.  * Third, call store(), remove(), or list() as needed.
  54.  * When done, call destroy().
  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.  * @struct
  63.  * @constructor
  64.  * @implements {shaka.util.IDestroyable}
  65.  * @export
  66.  */
  67. shaka.offline.Storage = function(player) {
  68.   // It is an easy mistake to make to pass a Player proxy from CastProxy.
  69.   // Rather than throw a vague exception later, throw an explicit and clear one
  70.   // now.
  71.   //
  72.   // TODO(vaage): After we decide whether or not we want to support
  73.   //  initializing storage with a player proxy, we should either remove
  74.   //  this error or rename the error.
  75.   if (player && player.constructor != shaka.Player) {
  76.     throw new shaka.util.Error(
  77.         shaka.util.Error.Severity.CRITICAL,
  78.         shaka.util.Error.Category.STORAGE,
  79.         shaka.util.Error.Code.LOCAL_PLAYER_INSTANCE_REQUIRED);
  80.   }
  82.   /** @private {?shaka.extern.PlayerConfiguration} */
  83.   this.config_ = null;
  85.   /** @private {shaka.net.NetworkingEngine} */
  86.   this.networkingEngine_ = null;
  88.   // Initialize |config_| and |networkingEngine_| based on whether or not
  89.   // we were given a player instance.
  90.   if (player) {
  91.     this.config_ = player.getSharedConfiguration();
  92.     this.networkingEngine_ = player.getNetworkingEngine();
  94.     goog.asserts.assert(
  95.         this.networkingEngine_,
  96.         'Storage should not be initialized with a player that had |destroy| ' +
  97.             'called on it.');
  98.   } else {
  99.     this.config_ = shaka.util.PlayerConfiguration.createDefault();
  100.     this.networkingEngine_ = new shaka.net.NetworkingEngine();
  101.   }
  103.   /** @private {boolean} */
  104.   this.storeInProgress_ = false;
  106.   /**
  107.    * A list of segment ids for all the segments that were added during the
  108.    * current store. If the store fails or is aborted, these need to be
  109.    * removed from storage.
  110.    * @private {!Array.<number>}
  111.    */
  112.   this.segmentsFromStore_ = [];
  114.   /**
  115.    * A list of open operations that are being performed by this instance of
  116.    * |shaka.offline.Storage|.
  117.    *
  118.    * @private {!Array.<!Promise>}
  119.    */
  120.   this.openOperations_ = [];
  122.   /**
  123.    * Storage should only destroy the networking engine if it was initialized
  124.    * without a player instance. Store this as a flag here to avoid including
  125.    * the player object in the destoyer's closure.
  126.    *
  127.    * @type {boolean}
  128.    */
  129.   const destroyNetworkingEngine = !player;
  131.   /** @private {!shaka.util.Destroyer} */
  132.   this.destroyer_ = new shaka.util.Destroyer(async () => {
  133.     // Wait for all the open operations to end. Wrap each operations so that a
  134.     // single rejected promise won't cause |Promise.all| to return early or to
  135.     // return a rejected Promise.
  136.     const noop = () => {};
  137.     await Promise.all(this.openOperations_.map((op) => op.then(noop, noop)));
  139.     // Wait until after all the operations have finished before we destroy
  140.     // the networking engine to avoid any unexpected errors.
  141.     if (destroyNetworkingEngine) {
  142.       await this.networkingEngine_.destroy();
  143.     }
  145.     // Drop all references to internal objects to help with GC.
  146.     this.config_ = null;
  147.     this.networkingEngine_ = null;
  148.   });
  149. };
  152. /**
  153.  * Gets whether offline storage is supported.  Returns true if offline storage
  154.  * is supported for clear content.  Support for offline storage of encrypted
  155.  * content will not be determined until storage is attempted.
  156.  *
  157.  * @return {boolean}
  158.  * @export
  159.  */
  160. shaka.offline.Storage.support = function() {
  161.   // Our Storage system is useless without MediaSource.  MediaSource allows us
  162.   // to pull data from anywhere (including our Storage system) and feed it to
  163.   // the video element.
  164.   if (!shaka.util.Platform.supportsMediaSource()) return false;
  166.   return shaka.offline.StorageMuxer.support();
  167. };
  170. /**
  171.  * @override
  172.  * @export
  173.  */
  174. shaka.offline.Storage.prototype.destroy = function() {
  175.   return this.destroyer_.destroy();
  176. };
  179. /**
  180.  * Sets configuration values for Storage.  This is associated with
  181.  * Player.configure and will change the player instance given at
  182.  * initialization.
  183.  *
  184.  * @param {string|!Object} config This should either be a field name or an
  185.  *   object following the form of {@link shaka.extern.PlayerConfiguration},
  186.  *   where you may omit any field you do not wish to change.
  187.  * @param {*=} value This should be provided if the previous parameter
  188.  *   was a string field name.
  189.  * @return {boolean}
  190.  * @export
  191.  */
  192. shaka.offline.Storage.prototype.configure = function(config, value) {
  193.   goog.asserts.assert(typeof(config) == 'object' || arguments.length == 2,
  194.                       'String configs should have values!');
  196.   // ('fieldName', value) format
  197.   if (arguments.length == 2 && typeof(config) == 'string') {
  198.     config = shaka.util.ConfigUtils.convertToConfigObject(config, value);
  199.   }
  201.   goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
  203.   shaka.offline.Storage.verifyConfig_(config);
  205.   goog.asserts.assert(
  206.       this.config_, 'Cannot reconfigure stroage after calling destroy.');
  207.   return shaka.util.PlayerConfiguration.mergeConfigObjects(
  208.       this.config_ /* destination */, config /* updates */);
  209. };
  212. /**
  213.  * Return a copy of the current configuration.  Modifications of the returned
  214.  * value will not affect the Storage instance's active configuration.  You must
  215.  * call storage.configure() to make changes.
  216.  *
  217.  * @return {shaka.extern.PlayerConfiguration}
  218.  * @export
  219.  */
  220. shaka.offline.Storage.prototype.getConfiguration = function() {
  221.   goog.asserts.assert(this.config_, 'Config must not be null!');
  223.   let ret = shaka.util.PlayerConfiguration.createDefault();
  224.   shaka.util.PlayerConfiguration.mergeConfigObjects(
  225.       ret, this.config_, shaka.util.PlayerConfiguration.createDefault());
  226.   return ret;
  227. };
  230. /**
  231.  * Return the networking engine that storage is using. If storage was
  232.  * initialized with a player instance, then the networking engine returned
  233.  * will be the same as |player.getNetworkingEngine()|.
  234.  *
  235.  * The returned value will only be null if |destroy| was called before
  236.  * |getNetworkingEngine|.
  237.  *
  238.  * @return {shaka.net.NetworkingEngine}
  239.  * @export
  240.  */
  241. shaka.offline.Storage.prototype.getNetworkingEngine = function() {
  242.   return this.networkingEngine_;
  243. };
  246. /**
  247.  * Stores the given manifest.  If the content is encrypted, and encrypted
  248.  * content cannot be stored on this platform, the Promise will be rejected with
  249.  * error code 6001, REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE.
  250.  *
  251.  * @param {string} uri The URI of the manifest to store.
  252.  * @param {!Object=} appMetadata An arbitrary object from the application
  253.  *   that will be stored along-side the offline content.  Use this for any
  254.  *   application-specific metadata you need associated with the stored content.
  255.  *   For details on the data types that can be stored here, please refer to
  256.  *   {@link https://bit.ly/StructClone}
  257.  * @param {string|shaka.extern.ManifestParser.Factory=} mimeType
  258.  *   The mime type for the content |manifestUri| points to or a manifest parser
  259.  *   factory to override auto-detection or use an unregistered parser. Passing
  260.  *   a manifest parser factory is deprecated and will be removed.
  261.  * @return {!Promise.<shaka.extern.StoredContent>}  A Promise to a structure
  262.  *   representing what was stored.  The "offlineUri" member is the URI that
  263.  *   should be given to Player.load() to play this piece of content offline.
  264.  *   The "appMetadata" member is the appMetadata argument you passed to store().
  265.  * @export
  266.  */
  267. shaka.offline.Storage.prototype.store = function(uri, appMetadata, mimeType) {
  268.   const getParser = async () => {
  269.     if (mimeType && typeof mimeType != 'string') {
  270.         shaka.Deprecate.deprecateFeature(
  271.             2, 6,
  272.             'Storing with a manifest parser factory',
  273.             'Please register a manifest parser and for the mime-type.');
  275.       const Factory =
  276.           /** @type {shaka.extern.ManifestParser.Factory} */(mimeType);
  277.       return new Factory();
  278.     }
  280.     goog.asserts.assert(
  281.         this.networkingEngine_, 'Should not call |store| after |destroy|');
  283.     const parser = await shaka.media.ManifestParser.create(
  284.         uri,
  285.         this.networkingEngine_,
  286.         this.config_.manifest.retryParameters,
  287.         /** @type {?string} */ (mimeType));
  289.     return parser;
  290.   };
  292.   return this.startOperation_(this.store_(uri, appMetadata || {}, getParser));
  293. };
  296. /**
  297.  * Returns true if an asset is currently downloading.
  298.  *
  299.  * @return {boolean}
  300.  * @export
  301.  */
  302. shaka.offline.Storage.prototype.getStoreInProgress = function() {
  303.   return this.storeInProgress_;
  304. };
  307. /**
  308.  * See |shaka.offline.Storage.store| for details.
  309.  *
  310.  * @param {string} uri
  311.  * @param {!Object} appMetadata
  312.  * @param {function():!Promise.<shaka.extern.ManifestParser>} getParser
  313.  * @return {!Promise.<shaka.extern.StoredContent>}
  314.  * @private
  315.  */
  316. shaka.offline.Storage.prototype.store_ = async function(
  317.     uri, appMetadata, getParser) {
  318.   // TODO: Create a way for a download to be canceled while being downloaded.
  319.   this.requireSupport_();
  321.   if (this.storeInProgress_) {
  322.     return Promise.reject(new shaka.util.Error(
  323.         shaka.util.Error.Severity.CRITICAL,
  324.         shaka.util.Error.Category.STORAGE,
  325.         shaka.util.Error.Code.STORE_ALREADY_IN_PROGRESS));
  326.   }
  327.   this.storeInProgress_ = true;
  329.   const manifest = await this.parseManifest(uri, getParser);
  331.   // Check if we were asked to destroy ourselves while we were "away"
  332.   // downloading the manifest.
  333.   this.checkDestroyed_();
  335.   // Check if we can even download this type of manifest before trying to
  336.   // create the drm engine.
  337.   const canDownload = !manifest.presentationTimeline.isLive() &&
  338.                       !manifest.presentationTimeline.isInProgress();
  339.   if (!canDownload) {
  340.     throw new shaka.util.Error(
  341.         shaka.util.Error.Severity.CRITICAL,
  342.         shaka.util.Error.Category.STORAGE,
  343.         shaka.util.Error.Code.CANNOT_STORE_LIVE_OFFLINE,
  344.         uri);
  345.   }
  347.   // Since we will need to use |drmEngine|, |activeHandle|, and |muxer| in the
  348.   // catch/finally blocks, we need to define them out here. Since they may not
  349.   // get initialized when we enter the catch/finally block, we need to assume
  350.   // that they may be null/undefined when we get there.
  351.   /** @type {?shaka.media.DrmEngine} */
  352.   let drmEngine = null;
  353.   /** @type {shaka.offline.StorageMuxer} */
  354.   let muxer = new shaka.offline.StorageMuxer();
  355.   /** @type {?shaka.offline.StorageCellHandle} */
  356.   let activeHandle = null;
  358.   // This will be used to store any errors from drm engine. Whenever drm engine
  359.   // is passed to another function to do work, we should check if this was
  360.   // set.
  361.   let drmError = null;
  363.   try {
  364.     drmEngine = await this.createDrmEngine(
  365.         manifest,
  366.         (e) => { drmError = drmError || e; });
  368.     // We could have been asked to destroy ourselves while we were "away"
  369.     // creating the drm engine.
  370.     this.checkDestroyed_();
  371.     if (drmError) { throw drmError; }
  373.     await this.filterManifest_(manifest, drmEngine);
  375.     await muxer.init();
  376.     this.checkDestroyed_();
  378.     // Get the cell that we are saving the manifest to. Once we get a cell
  379.     // we will only reference the cell and not the muxer so that the manifest
  380.     // and segments will all be saved to the same cell.
  381.     activeHandle = await muxer.getActive();
  382.     this.checkDestroyed_();
  384.     goog.asserts.assert(drmEngine, 'drmEngine should be non-null here.');
  386.     const manifestDB = await this.downloadManifest_(
  387.         activeHandle.cell, drmEngine, manifest, uri, appMetadata);
  388.     this.checkDestroyed_();
  389.     if (drmError) { throw drmError; }
  391.     const ids = await activeHandle.cell.addManifests([manifestDB]);
  392.     this.checkDestroyed_();
  394.     const offlineUri = shaka.offline.OfflineUri.manifest(
  395.         activeHandle.path.mechanism, activeHandle.path.cell, ids[0]);
  397.     return shaka.offline.StoredContentUtils.fromManifestDB(
  398.         offlineUri, manifestDB);
  399.   } catch (e) {
  400.     // If we did start saving some data, we need to remove it all to avoid
  401.     // wasting storage. However if the muxer did not manage to initialize, then
  402.     // we won't have an active cell to remove the segments from.
  403.     if (activeHandle) {
  404.       await activeHandle.cell.removeSegments(this.segmentsFromStore_, () => {});
  405.     }
  407.     // If we already had an error, ignore this error to avoid hiding
  408.     // the original error.
  409.     throw drmError || e;
  410.   } finally {
  411.     this.storeInProgress_ = false;
  412.     this.segmentsFromStore_ = [];
  414.     await muxer.destroy();
  415.     if (drmEngine) {
  416.       await drmEngine.destroy();
  417.     }
  418.   }
  419. };
  422. /**
  423.  * Filter |manifest| such that it will only contain the variants and text
  424.  * streams that we want to store and can actually play.
  425.  *
  426.  * @param {shaka.extern.Manifest} manifest
  427.  * @param {!shaka.media.DrmEngine} drmEngine
  428.  * @return {!Promise}
  429.  * @private
  430.  */
  431. shaka.offline.Storage.prototype.filterManifest_ = async function(
  432.     manifest, drmEngine) {
  433.   // Filter the manifest based on the restrictions given in the player
  434.   // configuration.
  435.   const maxHwRes = {width: Infinity, height: Infinity};
  436.   shaka.util.ManifestFilter.filterByRestrictions(
  437.       manifest, this.config_.restrictions, maxHwRes);
  439.   // Filter the manifest based on what we know media source will be able to
  440.   // play later (no point storing something we can't play).
  441.   shaka.util.ManifestFilter.filterByMediaSourceSupport(manifest);
  443.   // Filter the manifest based on what we know our drm system will support
  444.   // playing later.
  445.   shaka.util.ManifestFilter.filterByDrmSupport(manifest, drmEngine);
  447.   // Filter the manifest so that it will only use codecs that are available in
  448.   // all periods.
  449.   shaka.util.ManifestFilter.filterByCommonCodecs(manifest);
  451.   // Choose the codec that has the lowest average bandwidth.
  452.   const preferredAudioChannelCount = this.config_.preferredAudioChannelCount;
  453.   shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  454.       manifest, preferredAudioChannelCount);
  456.   // Filter each variant based on what the app says they want to store. The app
  457.   // will only be given variants that are compatible with all previous
  458.   // post-filtered periods.
  459.   await shaka.util.ManifestFilter.rollingFilter(manifest, async (period) => {
  460.     const StreamUtils = shaka.util.StreamUtils;
  461.     const allTracks = [];
  463.     for (const variant of period.variants) {
  464.       goog.asserts.assert(
  465.           StreamUtils.isPlayable(variant),
  466.           'We should have already filtered by "is playable"');
  468.       allTracks.push(StreamUtils.variantToTrack(variant));
  469.     }
  471.     for (const text of period.textStreams) {
  472.       allTracks.push(StreamUtils.textStreamToTrack(text));
  473.     }
  475.     const chosenTracks =
  476.         await this.config_.offline.trackSelectionCallback(allTracks);
  478.     /** @type {!Set.<number>} */
  479.     const variantIds = new Set();
  480.     /** @type {!Set.<number>} */
  481.     const textIds = new Set();
  483.     for (const track of chosenTracks) {
  484.       if (track.type == 'variant') { variantIds.add(track.id); }
  485.       if (track.type == 'text') { textIds.add(track.id); }
  486.     }
  488.     period.variants =
  489.         period.variants.filter((variant) => variantIds.has(variant.id));
  490.     period.textStreams =
  491.         period.textStreams.filter((stream) => textIds.has(stream.id));
  492.   });
  494.   // Check the post-filtered manifest for characteristics that may indicate
  495.   // issues with how the app selected tracks.
  496.   shaka.offline.Storage.validateManifest_(manifest);
  497. };
  500. /**
  501.  * Create a download manager and download the manifest.
  502.  *
  503.  * @param {shaka.extern.StorageCell} storage
  504.  * @param {!shaka.media.DrmEngine} drmEngine
  505.  * @param {shaka.extern.Manifest} manifest
  506.  * @param {string} uri
  507.  * @param {!Object} metadata
  508.  * @return {!Promise.<shaka.extern.ManifestDB>}
  509.  * @private
  510.  */
  511. shaka.offline.Storage.prototype.downloadManifest_ = async function(
  512.     storage, drmEngine, manifest, uri, metadata) {
  513.   goog.asserts.assert(
  514.       this.networkingEngine_,
  515.       'Cannot call |downloadManifest_| after calling |destroy|.');
  517.   const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
  518.       uri, manifest, /* size */ 0, metadata);
  520.   const isEncrypted = manifest.periods.some((period) => {
  521.     return period.variants.some((variant) => {
  522.       return variant.drmInfos && variant.drmInfos.length;
  523.     });
  524.   });
  525.   const includesInitData = manifest.periods.some((period) => {
  526.     return period.variants.some((variant) => {
  527.       return variant.drmInfos.some((drmInfos) => {
  528.         return drmInfos.initData && drmInfos.initData.length;
  529.       });
  530.     });
  531.   });
  532.   const needsInitData = isEncrypted && !includesInitData;
  534.   let currentSystemId = null;
  535.   if (needsInitData) {
  536.     const drmInfo = drmEngine.getDrmInfo();
  537.     currentSystemId =
  538.         shaka.offline.Storage.defaultSystemIds_.get(drmInfo.keySystem);
  539.   }
  541.   /** @type {!shaka.offline.DownloadManager} */
  542.   const downloader = new shaka.offline.DownloadManager(
  543.       this.networkingEngine_,
  544.       (progress, size) => {
  545.         // Update the size of the stored content before issuing a progress
  546.         // update.
  547.         pendingContent.size = size;
  548.         this.config_.offline.progressCallback(pendingContent, progress);
  549.       },
  550.       (initData, systemId) => {
  551.         if (needsInitData && this.config_.offline.usePersistentLicense &&
  552.             currentSystemId == systemId) {
  553.           drmEngine.newInitData('cenc', initData);
  554.         }
  555.       });
  557.   try {
  558.     const manifestDB = this.createOfflineManifest_(
  559.         downloader, storage, drmEngine, manifest, uri, metadata);
  561.     manifestDB.size = await downloader.waitToFinish();
  562.       manifestDB.expiration = drmEngine.getExpiration();
  563.       const sessions = drmEngine.getSessionIds();
  564.       manifestDB.sessionIds = this.config_.offline.usePersistentLicense ?
  565.           sessions : [];
  567.       if (isEncrypted && this.config_.offline.usePersistentLicense &&
  568.           !sessions.length) {
  569.         throw new shaka.util.Error(
  570.             shaka.util.Error.Severity.CRITICAL,
  571.             shaka.util.Error.Category.STORAGE,
  572.             shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE);
  573.       }
  575.     return manifestDB;
  576.   } finally {
  577.     await downloader.destroy();
  578.   }
  579. };
  582. /**
  583.  * Removes the given stored content.  This will also attempt to release the
  584.  * licenses, if any.
  585.  *
  586.  * @param {string} contentUri
  587.  * @return {!Promise}
  588.  * @export
  589.  */
  590. shaka.offline.Storage.prototype.remove = function(contentUri) {
  591.   return this.startOperation_(this.remove_(contentUri));
  592. };
  595. /**
  596.  * See |shaka.offline.Storage.remove| for details.
  597.  *
  598.  * @param {string} contentUri
  599.  * @return {!Promise}
  600.  * @private
  601.  */
  602. shaka.offline.Storage.prototype.remove_ = async function(contentUri) {
  603.   this.requireSupport_();
  605.   const nullableUri = shaka.offline.OfflineUri.parse(contentUri);
  606.   if (nullableUri == null || !nullableUri.isManifest()) {
  607.     return Promise.reject(new shaka.util.Error(
  608.         shaka.util.Error.Severity.CRITICAL,
  609.         shaka.util.Error.Category.STORAGE,
  610.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  611.         contentUri));
  612.   }
  614.   /** @type {!shaka.offline.OfflineUri} */
  615.   const uri = nullableUri;
  617.   /** @type {!shaka.offline.StorageMuxer} */
  618.   const muxer = new shaka.offline.StorageMuxer();
  620.   try {
  621.     await muxer.init();
  623.     const cell = await muxer.getCell(uri.mechanism(), uri.cell());
  624.     const manifests = await cell.getManifests([uri.key()]);
  625.     const manifest = manifests[0];
  627.     await Promise.all([
  628.       this.removeFromDRM_(uri, manifest, muxer),
  629.       this.removeFromStorage_(cell, uri, manifest),
  630.     ]);
  631.   } finally {
  632.     await muxer.destroy();
  633.   }
  634. };
  637. /**
  638.  * @param {shaka.extern.ManifestDB} manifestDb
  639.  * @param {boolean} isVideo
  640.  * @return {!Array.<MediaKeySystemMediaCapability>}
  641.  * @private
  642.  */
  643. shaka.offline.Storage.getCapabilities_ = function(manifestDb, isVideo) {
  644.   const MimeUtils = shaka.util.MimeUtils;
  646.   const ret = [];
  647.   for (const period of manifestDb.periods) {
  648.     for (const stream of period.streams) {
  649.       if (isVideo && stream.contentType == 'video') {
  650.         ret.push({
  651.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  652.           robustness: manifestDb.drmInfo.videoRobustness,
  653.         });
  654.       } else if (!isVideo && stream.contentType == 'audio') {
  655.         ret.push({
  656.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  657.           robustness: manifestDb.drmInfo.audioRobustness,
  658.         });
  659.       }
  660.     }
  661.   }
  662.   return ret;
  663. };
  666. /**
  667.  * @param {!shaka.offline.OfflineUri} uri
  668.  * @param {shaka.extern.ManifestDB} manifestDb
  669.  * @param {!shaka.offline.StorageMuxer} muxer
  670.  * @return {!Promise}
  671.  * @private
  672.  */
  673. shaka.offline.Storage.prototype.removeFromDRM_ = async function(
  674.     uri, manifestDb, muxer) {
  675.   goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  676.   await shaka.offline.Storage.deleteLicenseFor_(
  677.       this.networkingEngine_, this.config_.drm, muxer, manifestDb);
  678. };
  681. /**
  682.  * @param {shaka.extern.StorageCell} storage
  683.  * @param {!shaka.offline.OfflineUri} uri
  684.  * @param {shaka.extern.ManifestDB} manifest
  685.  * @return {!Promise}
  686.  * @private
  687.  */
  688. shaka.offline.Storage.prototype.removeFromStorage_ = function(
  689.     storage, uri, manifest) {
  690.   /** @type {!Array.<number>} */
  691.   let segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
  693.   // Count(segments) + Count(manifests)
  694.   let toRemove = segmentIds.length + 1;
  695.   let removed = 0;
  697.   let pendingContent = shaka.offline.StoredContentUtils.fromManifestDB(
  698.       uri, manifest);
  700.   let onRemove = (key) => {
  701.     removed += 1;
  702.     this.config_.offline.progressCallback(pendingContent, removed / toRemove);
  703.   };
  705.   return Promise.all([
  706.     storage.removeSegments(segmentIds, onRemove),
  707.     storage.removeManifests([uri.key()], onRemove),
  708.   ]);
  709. };
  712. /**
  713.  * Removes any EME sessions that were not successfully removed before.  This
  714.  * returns whether all the sessions were successfully removed.
  715.  *
  716.  * @return {!Promise.<boolean>}
  717.  * @export
  718.  */
  719. shaka.offline.Storage.prototype.removeEmeSessions = function() {
  720.   return this.startOperation_(this.removeEmeSessions_());
  721. };
  723. /**
  724.  * @return {!Promise.<boolean>}
  725.  * @private
  726.  */
  727. shaka.offline.Storage.prototype.removeEmeSessions_ = async function() {
  728.   this.requireSupport_();
  730.   goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  731.   const net = this.networkingEngine_;
  732.   const config = this.config_.drm;
  734.   /** @type {!shaka.offline.StorageMuxer} */
  735.   const muxer = new shaka.offline.StorageMuxer();
  736.   /** @type {!shaka.offline.SessionDeleter} */
  737.   const deleter = new shaka.offline.SessionDeleter();
  739.   let hasRemaining = false;
  741.   try {
  742.     await muxer.init();
  744.     /** @type {!Array.<shaka.extern.EmeSessionStorageCell>} */
  745.     const cells = [];
  746.     muxer.forEachEmeSessionCell((c) => cells.push(c));
  748.     // Run these sequentially to avoid creating too many DrmEngine instances
  749.     // and having multiple CDMs alive at once.  Some embedded platforms may
  750.     // not support that.
  751.     let p = Promise.resolve();
  753.     for (const sessionIdCell of cells) {
  754.       p = p.then(async () => {
  755.         const sessions = await sessionIdCell.getAll();
  756.         const deletedSessionIds = await deleter.delete(config, net, sessions);
  757.         await sessionIdCell.remove(deletedSessionIds);
  759.         if (deletedSessionIds.length != sessions.length) {
  760.           hasRemaining = true;
  761.         }
  762.       });
  763.     }
  765.     await p;
  766.   } finally {
  767.     await muxer.destroy();
  768.   }
  770.   return !hasRemaining;
  771. };
  774. /**
  775.  * Lists all the stored content available.
  776.  *
  777.  * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}  A Promise to an
  778.  *   array of structures representing all stored content.  The "offlineUri"
  779.  *   member of the structure is the URI that should be given to Player.load()
  780.  *   to play this piece of content offline.  The "appMetadata" member is the
  781.  *   appMetadata argument you passed to store().
  782.  * @export
  783.  */
  784. shaka.offline.Storage.prototype.list = function() {
  785.   return this.startOperation_(this.list_());
  786. };
  789. /**
  790.  * See |shaka.offline.Storage.list| for details.
  791.  *
  792.  * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}
  793.  * @private
  794.  */
  795. shaka.offline.Storage.prototype.list_ = async function() {
  796.   this.requireSupport_();
  798.   /** @type {!Array.<shaka.extern.StoredContent>} */
  799.   const result = [];
  801.   /** @type {!shaka.offline.StorageMuxer} */
  802.   const muxer = new shaka.offline.StorageMuxer();
  803.   try {
  804.     await muxer.init();
  806.     let p = Promise.resolve();
  807.     muxer.forEachCell((path, cell) => {
  808.       p = p.then(async () => {
  809.         const manifests = await cell.getAllManifests();
  811.         manifests.forEach((manifest, key) => {
  812.           const uri = shaka.offline.OfflineUri.manifest(
  813.               path.mechanism,
  814.               path.cell,
  815.               key);
  817.           const content = shaka.offline.StoredContentUtils.fromManifestDB(
  818.               uri,
  819.               manifest);
  821.           result.push(content);
  822.         });
  823.       });
  824.     });
  826.     await p;
  827.   } finally {
  828.     await muxer.destroy();
  829.   }
  831.   return result;
  832. };
  835. /**
  836.  * This method is public so that it can be overridden in testing.
  837.  *
  838.  * @param {string} uri
  839.  * @param {function():!Promise.<shaka.extern.ManifestParser>} getParser
  840.  * @return {!Promise.<shaka.extern.Manifest>}
  841.  */
  842. shaka.offline.Storage.prototype.parseManifest = async function(
  843.     uri, getParser) {
  844.   let error = null;
  846.   const networkingEngine = this.networkingEngine_;
  847.   goog.asserts.assert(networkingEngine, 'Should be initialized!');
  849.   /** @type {shaka.extern.ManifestParser.PlayerInterface} */
  850.   const playerInterface = {
  851.     networkingEngine: networkingEngine,
  853.     // Don't bother filtering now. We will do that later when we have all the
  854.     // information we need to filter.
  855.     filterAllPeriods: () => {},
  856.     filterNewPeriod: () => {},
  858.     onTimelineRegionAdded: () => {},
  859.     onEvent: () => {},
  861.     // Used to capture an error from the manifest parser. We will check the
  862.     // error before returning.
  863.     onError: (e) => {
  864.       error = e;
  865.     },
  866.   };
  868.   const parser = await getParser();
  869.   parser.configure(this.config_.manifest);
  871.   // We may have been destroyed while we were waiting on |getParser| to
  872.   // resolve.
  873.   this.checkDestroyed_();
  875.   try {
  876.     const manifest = await parser.start(uri, playerInterface);
  878.     // We may have been destroyed while we were waiting on |start| to
  879.     // resolve.
  880.     this.checkDestroyed_();
  882.     // Get all the streams that are used in the manifest.
  883.     const streams = shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  885.     // Wait for each stream to create their segment indexes.
  886.     await Promise.all(shaka.util.Iterables.map(streams, (stream) => {
  887.       return stream.createSegmentIndex();
  888.     }));
  890.     // We may have been destroyed while we were waiting on |createSegmentIndex|
  891.     // to resolve for each stream.
  892.     this.checkDestroyed_();
  894.     // If we saw an error while parsing, surface the error.
  895.     if (error) {
  896.       throw error;
  897.     }
  899.     return manifest;
  900.   } finally {
  901.     await parser.stop();
  902.   }
  903. };
  906. /**
  907.  * This method is public so that it can be override in testing.
  908.  *
  909.  * @param {shaka.extern.Manifest} manifest
  910.  * @param {function(shaka.util.Error)} onError
  911.  * @return {!Promise.<!shaka.media.DrmEngine>}
  912.  */
  913. shaka.offline.Storage.prototype.createDrmEngine = async function(
  914.     manifest, onError) {
  915.   goog.asserts.assert(
  916.       this.networkingEngine_, 'Cannot call |createDrmEngine| after |destroy|');
  918.   /** @type {!shaka.media.DrmEngine} */
  919.   const drmEngine = new shaka.media.DrmEngine({
  920.     netEngine: this.networkingEngine_,
  921.     onError: onError,
  922.     onKeyStatus: () => {},
  923.     onExpirationUpdated: () => {},
  924.     onEvent: () => {},
  925.   });
  927.   const variants = shaka.util.Periods.getAllVariantsFrom(manifest.periods);
  929.   const config = this.config_;
  930.   drmEngine.configure(config.drm);
  931.   await drmEngine.initForStorage(variants, config.offline.usePersistentLicense);
  932.   await drmEngine.setServerCertificate();
  933.   await drmEngine.createOrLoad();
  935.   return drmEngine;
  936. };
  939. /**
  940.  * Creates an offline 'manifest' for the real manifest.  This does not store the
  941.  * segments yet, only adds them to the download manager through createPeriod_.
  942.  *
  943.  * @param {!shaka.offline.DownloadManager} downloader
  944.  * @param {shaka.extern.StorageCell} storage
  945.  * @param {!shaka.media.DrmEngine} drmEngine
  946.  * @param {shaka.extern.Manifest} manifest
  947.  * @param {string} originalManifestUri
  948.  * @param {!Object} metadata
  949.  * @return {shaka.extern.ManifestDB}
  950.  * @private
  951.  */
  952. shaka.offline.Storage.prototype.createOfflineManifest_ = function(
  953.     downloader, storage, drmEngine, manifest, originalManifestUri, metadata) {
  954.   let estimator = new shaka.offline.StreamBandwidthEstimator();
  956.   let periods = manifest.periods.map((period) => {
  957.     return this.createPeriod_(
  958.         downloader, storage, estimator, drmEngine, manifest, period);
  959.   });
  961.   let drmInfo = drmEngine.getDrmInfo();
  962.   let usePersistentLicense = this.config_.offline.usePersistentLicense;
  964.   if (drmInfo && usePersistentLicense) {
  965.     // Don't store init data, since we have stored sessions.
  966.     drmInfo.initData = [];
  967.   }
  969.   return {
  970.     originalManifestUri: originalManifestUri,
  971.     duration: manifest.presentationTimeline.getDuration(),
  972.     size: 0,
  973.     expiration: drmEngine.getExpiration(),
  974.     periods: periods,
  975.       sessionIds: usePersistentLicense ? drmEngine.getSessionIds() : [],
  976.     drmInfo: drmInfo,
  977.     appMetadata: metadata,
  978.   };
  979. };
  982. /**
  983.  * Converts a manifest Period to a database Period.  This will use the current
  984.  * configuration to get the tracks to use, then it will search each segment
  985.  * index and add all the segments to the download manager through createStream_.
  986.  *
  987.  * @param {!shaka.offline.DownloadManager} downloader
  988.  * @param {shaka.extern.StorageCell} storage
  989.  * @param {shaka.offline.StreamBandwidthEstimator} estimator
  990.  * @param {!shaka.media.DrmEngine} drmEngine
  991.  * @param {shaka.extern.Manifest} manifest
  992.  * @param {shaka.extern.Period} period
  993.  * @return {shaka.extern.PeriodDB}
  994.  * @private
  995.  */
  996. shaka.offline.Storage.prototype.createPeriod_ = function(
  997.     downloader, storage, estimator, drmEngine, manifest, period) {
  998.   // Pass all variants and text streams to the estimator so that we can
  999.   // get the best estimate for each stream later.
  1000.   for (const variant of period.variants) {
  1001.     estimator.addVariant(variant);
  1002.   }
  1003.   for (const text of period.textStreams) {
  1004.     estimator.addText(text);
  1005.   }
  1007.   // Find the streams we want to download and create a stream db instance
  1008.   // for each of them.
  1009.   const streamSet = shaka.offline.Storage.getAllStreamsFromPeriod_(period);
  1010.   const streamDBs = new Map();
  1012.   for (const stream of streamSet) {
  1013.     const streamDB = this.createStream_(
  1014.         downloader, storage, estimator, manifest, period, stream);
  1015.     streamDBs.set(stream.id, streamDB);
  1016.   }
  1018.   // Connect streams and variants together.
  1019.   period.variants.forEach((variant) => {
  1020.     if (variant.audio) {
  1021.       streamDBs.get(variant.audio.id).variantIds.push(variant.id);
  1022.     }
  1023.     if (variant.video) {
  1024.       streamDBs.get(variant.video.id).variantIds.push(variant.id);
  1025.     }
  1026.   });
  1028.   return {
  1029.     startTime: period.startTime,
  1030.     streams: Array.from(streamDBs.values()),
  1031.   };
  1032. };
  1035. /**
  1036.  * Converts a manifest stream to a database stream.  This will search the
  1037.  * segment index and add all the segments to the download manager.
  1038.  *
  1039.  * @param {!shaka.offline.DownloadManager} downloader
  1040.  * @param {shaka.extern.StorageCell} storage
  1041.  * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1042.  * @param {shaka.extern.Manifest} manifest
  1043.  * @param {shaka.extern.Period} period
  1044.  * @param {shaka.extern.Stream} stream
  1045.  * @return {shaka.extern.StreamDB}
  1046.  * @private
  1047.  */
  1048. shaka.offline.Storage.prototype.createStream_ = function(
  1049.     downloader, storage, estimator, manifest, period, stream) {
  1050.   /** @type {shaka.extern.StreamDB} */
  1051.   let streamDb = {
  1052.     id: stream.id,
  1053.     originalId: stream.originalId,
  1054.     primary: stream.primary,
  1055.     presentationTimeOffset: stream.presentationTimeOffset || 0,
  1056.     contentType: stream.type,
  1057.     mimeType: stream.mimeType,
  1058.     codecs: stream.codecs,
  1059.     frameRate: stream.frameRate,
  1060.     pixelAspectRatio: stream.pixelAspectRatio,
  1061.     kind: stream.kind,
  1062.     language: stream.language,
  1063.     label: stream.label,
  1064.     width: stream.width || null,
  1065.     height: stream.height || null,
  1066.     initSegmentKey: null,
  1067.     encrypted: stream.encrypted,
  1068.     keyId: stream.keyId,
  1069.     segments: [],
  1070.     variantIds: [],
  1071.   };
  1073.   /** @type {number} */
  1074.   let startTime =
  1075.       manifest.presentationTimeline.getSegmentAvailabilityStart();
  1077.   // Download each stream in parallel.
  1078.   let downloadGroup = stream.id;
  1080.   let initSegment = stream.initSegmentReference;
  1081.   if (initSegment) {
  1082.     const request = shaka.util.Networking.createSegmentRequest(
  1083.         initSegment.getUris(),
  1084.         initSegment.startByte,
  1085.         initSegment.endByte,
  1086.         this.config_.streaming.retryParameters);
  1088.     downloader.queue(
  1089.         downloadGroup,
  1090.         request,
  1091.         estimator.getInitSegmentEstimate(stream.id),
  1092.         /* isInitSegment */ true,
  1093.         async (data) => {
  1094.           const ids = await storage.addSegments([{data: data}]);
  1095.           this.segmentsFromStore_.push(ids[0]);
  1096.           streamDb.initSegmentKey = ids[0];
  1097.         });
  1098.   }
  1100.     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
  1101.       const request = shaka.util.Networking.createSegmentRequest(
  1102.           segment.getUris(),
  1103.           segment.startByte,
  1104.           segment.endByte,
  1105.           this.config_.streaming.retryParameters);
  1107.       downloader.queue(
  1108.           downloadGroup,
  1109.           request,
  1110.           estimator.getSegmentEstimate(stream.id, segment),
  1111.           /* isInitSegment */ false,
  1112.           async (data) => {
  1113.             const ids = await storage.addSegments([{data: data}]);
  1114.             this.segmentsFromStore_.push(ids[0]);
  1116.             streamDb.segments.push({
  1117.               startTime: segment.startTime,
  1118.               endTime: segment.endTime,
  1119.               dataKey: ids[0],
  1120.             });
  1121.           });
  1122.     });
  1124.   return streamDb;
  1125. };
  1128. /**
  1129.  * @param {shaka.extern.Stream} stream
  1130.  * @param {number} startTime
  1131.  * @param {function(!shaka.media.SegmentReference)} callback
  1132.  * @private
  1133.  */
  1134. shaka.offline.Storage.forEachSegment_ = function(stream, startTime, callback) {
  1135.   /** @type {?number} */
  1136.   let i = stream.findSegmentPosition(startTime);
  1137.   /** @type {?shaka.media.SegmentReference} */
  1138.   let ref = i == null ? null : stream.getSegmentReference(i);
  1140.   while (ref) {
  1141.     callback(ref);
  1142.     ref = stream.getSegmentReference(++i);
  1143.   }
  1144. };
  1147. /**
  1148.  * Throws an error if the object is destroyed.
  1149.  * @private
  1150.  */
  1151. shaka.offline.Storage.prototype.checkDestroyed_ = function() {
  1152.   if (this.destroyer_.destroyed()) {
  1153.     throw new shaka.util.Error(
  1154.         shaka.util.Error.Severity.CRITICAL,
  1155.         shaka.util.Error.Category.STORAGE,
  1156.         shaka.util.Error.Code.OPERATION_ABORTED);
  1157.   }
  1158. };
  1161. /**
  1162.  * Used by functions that need storage support to ensure that the current
  1163.  * platform has storage support before continuing. This should only be
  1164.  * needed to be used at the start of public methods.
  1165.  *
  1166.  * @private
  1167.  */
  1168. shaka.offline.Storage.prototype.requireSupport_ = function() {
  1169.   if (!shaka.offline.Storage.support()) {
  1170.     throw new shaka.util.Error(
  1171.         shaka.util.Error.Severity.CRITICAL,
  1172.         shaka.util.Error.Category.STORAGE,
  1173.         shaka.util.Error.Code.STORAGE_NOT_SUPPORTED);
  1174.   }
  1175. };
  1178. /**
  1179.  * Perform an action. Track the action's progress so that when we destroy
  1180.  * we will wait until all the actions have completed before allowing destroy
  1181.  * to resolve.
  1182.  *
  1183.  * @param {!Promise<T>} action
  1184.  * @return {!Promise<T>}
  1185.  * @template T
  1186.  * @private
  1187.  */
  1188. shaka.offline.Storage.prototype.startOperation_ = async function(action) {
  1189.   this.openOperations_.push(action);
  1191.   try {
  1192.     // Await |action| so we can use the finally statement to remove |action|
  1193.     // from |openOperations_| when we still have a reference to |action|.
  1194.     return await action;
  1195.   } finally {
  1196.     shaka.util.ArrayUtils.remove(this.openOperations_, action);
  1197.   }
  1198. };
  1201. /**
  1202.  * @param {shaka.extern.ManifestDB} manifest
  1203.  * @return {!Array.<number>}
  1204.  * @private
  1205.  */
  1206. shaka.offline.Storage.getAllSegmentIds_ = function(manifest) {
  1207.   /** @type {!Array.<number>} */
  1208.   let ids = [];
  1210.   // Get every segment for every stream in the manifest.
  1211.   manifest.periods.forEach(function(period) {
  1212.     period.streams.forEach(function(stream) {
  1213.       if (stream.initSegmentKey != null) {
  1214.         ids.push(stream.initSegmentKey);
  1215.       }
  1217.       stream.segments.forEach(function(segment) {
  1218.         ids.push(segment.dataKey);
  1219.       });
  1220.     });
  1221.   });
  1223.   return ids;
  1224. };
  1227. /**
  1228.  * Delete the on-disk storage and all the content it contains. This should not
  1229.  * be done in normal circumstances. Only do it when storage is rendered
  1230.  * unusable, such as by a version mismatch. No business logic will be run, and
  1231.  * licenses will not be released.
  1232.  *
  1233.  * @return {!Promise}
  1234.  * @export
  1235.  */
  1236. shaka.offline.Storage.deleteAll = async function() {
  1237.   /** @type {!shaka.offline.StorageMuxer} */
  1238.   const muxer = new shaka.offline.StorageMuxer();
  1239.   try {
  1240.     // Wipe all content from all storage mechanisms.
  1241.     await muxer.erase();
  1242.   } finally {
  1243.     // Destroy the muxer, whether or not erase() succeeded.
  1244.     await muxer.destroy();
  1245.   }
  1246. };
  1249. /**
  1250.  * @param {!shaka.net.NetworkingEngine} net
  1251.  * @param {!shaka.extern.DrmConfiguration} drmConfig
  1252.  * @param {!shaka.offline.StorageMuxer} muxer
  1253.  * @param {shaka.extern.ManifestDB} manifestDb
  1254.  * @return {!Promise}
  1255.  * @private
  1256.  */
  1257. shaka.offline.Storage.deleteLicenseFor_ = async function(
  1258.     net, drmConfig, muxer, manifestDb) {
  1259.   if (!manifestDb.drmInfo) {
  1260.     return;
  1261.   }
  1263.   const sessionIdCell = muxer.getEmeSessionCell();
  1265.   /** @type {!Array.<shaka.extern.EmeSessionDB>} */
  1266.   const sessions = manifestDb.sessionIds.map((sessionId) => {
  1267.     return {
  1268.       sessionId: sessionId,
  1269.       keySystem: manifestDb.drmInfo.keySystem,
  1270.       licenseUri: manifestDb.drmInfo.licenseServerUri,
  1271.       serverCertificate: manifestDb.drmInfo.serverCertificate,
  1272.       audioCapabilities: shaka.offline.Storage.getCapabilities_(
  1273.           manifestDb,
  1274.           /* isVideo */ false),
  1275.       videoCapabilities: shaka.offline.Storage.getCapabilities_(
  1276.           manifestDb,
  1277.           /* isVideo */ true),
  1278.     };
  1279.   });
  1280.   // Try to delete the sessions; any sessions that weren't deleted get stored
  1281.   // in the database so we can try to remove them again later.  This allows us
  1282.   // to still delete the stored content but not "forget" about these sessions.
  1283.   // Later, we can remove the sessions to free up space.
  1284.   const deleter = new shaka.offline.SessionDeleter();
  1285.   const deletedSessionIds = await deleter.delete(drmConfig, net, sessions);
  1286.   await sessionIdCell.remove(deletedSessionIds);
  1287.   await sessionIdCell.add(sessions.filter(
  1288.       (session) => deletedSessionIds.indexOf(session.sessionId) == -1));
  1289. };
  1292. /**
  1293.  * Get the set of all streams in |manifest|.
  1294.  *
  1295.  * @param {shaka.extern.Manifest} manifest
  1296.  * @return {!Set.<shaka.extern.Stream>}
  1297.  * @private
  1298.  */
  1299. shaka.offline.Storage.getAllStreamsFromManifest_ = function(manifest) {
  1300.   /** @type {!Set.<shaka.extern.Stream>} */
  1301.   const set = new Set();
  1303.   for (const period of manifest.periods) {
  1304.     for (const text of period.textStreams) {
  1305.       set.add(text);
  1306.     }
  1308.     for (const variant of period.variants) {
  1309.       if (variant.audio) { set.add(variant.audio); }
  1310.       if (variant.video) { set.add(variant.video); }
  1311.     }
  1312.   }
  1314.   return set;
  1315. };
  1318. /**
  1319.  * Get the set of all streams in |period|.
  1320.  *
  1321.  * @param {shaka.extern.Period} period
  1322.  * @return {!Set.<shaka.extern.Stream>}
  1323.  * @private
  1324.  */
  1325. shaka.offline.Storage.getAllStreamsFromPeriod_ = function(period) {
  1326.   /** @type {!Set.<shaka.extern.Stream>} */
  1327.   const set = new Set();
  1329.   for (const text of period.textStreams) {
  1330.     set.add(text);
  1331.   }
  1333.   for (const variant of period.variants) {
  1334.     if (variant.audio) {
  1335.       set.add(variant.audio);
  1336.     }
  1337.     if (variant.video) {
  1338.       set.add(variant.video);
  1339.     }
  1340.   }
  1342.   return set;
  1343. };
  1346. /**
  1347.  * Make sure that the given configuration object follows the correct structure
  1348.  * expected by |configure|. This function should be removed in v3.0 when
  1349.  * backward-compatibility is no longer needed.
  1350.  *
  1351.  * @param {!Object} config
  1352.  *    The config fields that the app wants to update. This object will be
  1353.  *    change by this function.
  1354.  * @private
  1355.  */
  1356. shaka.offline.Storage.verifyConfig_ = function(config) {
  1357.   // To avoid printing a deprecated warning multiple times, track all
  1358.   // infractions and then print it once at the end.
  1359.   let usedLegacyConfig = false;
  1361.   // For each field in the legacy config structure
  1362.   // (shaka.extern.OfflineConfiguration), move any occurances to the correct
  1363.   // location in the player configuration.
  1364.   if (config.trackSelectionCallback != null) {
  1365.     usedLegacyConfig = true;
  1366.     config.offline = config.offline || {};
  1367.     config.offline.trackSelectionCallback = config.trackSelectionCallback;
  1368.     delete config.trackSelectionCallback;
  1369.   }
  1371.   if (config.progressCallback != null) {
  1372.     usedLegacyConfig = true;
  1373.     config.offline = config.offline || {};
  1374.     config.offline.progressCallback = config.progressCallback;
  1375.     delete config.progressCallback;
  1376.   }
  1378.   if (config.usePersistentLicense != null) {
  1379.     usedLegacyConfig = true;
  1380.     config.offline = config.offline || {};
  1381.     config.offline.usePersistentLicense = config.usePersistentLicense;
  1382.     delete config.usePersistentLicense;
  1383.   }
  1385.   if (usedLegacyConfig) {
  1386.     shaka.Deprecate.deprecateFeature(
  1387.         2, 6,
  1388.         'Storage.configure with OfflineConfig',
  1389.         'Please configure storage with a player configuration.');
  1390.   }
  1391. };
  1394. /**
  1395.  * Go over a manifest and issue warnings for any suspicious properties.
  1396.  *
  1397.  * @param {shaka.extern.Manifest} manifest
  1398.  * @private
  1399.  */
  1400. shaka.offline.Storage.validateManifest_ = function(manifest) {
  1401.   // Make sure that the period has not been reduced to nothing.
  1402.   if (manifest.periods.length == 0) {
  1403.     throw new shaka.util.Error(
  1404.         shaka.util.Error.Severity.CRITICAL,
  1405.         shaka.util.Error.Category.MANIFEST,
  1406.         shaka.util.Error.Code.NO_PERIODS);
  1407.   }
  1409.   for (const period of manifest.periods) {
  1410.     shaka.offline.Storage.validatePeriod_(period);
  1411.   }
  1412. };
  1415. /**
  1416.  * Go over a period and issue warnings for any suspicious properties.
  1417.  *
  1418.  * @param {shaka.extern.Period} period
  1419.  * @private
  1420.  */
  1421. shaka.offline.Storage.validatePeriod_ = function(period) {
  1422.   const videos = new Set(period.variants.map((v) => v.video));
  1423.   const audios = new Set(period.variants.map((v) => v.audio));
  1424.   const texts = period.textStreams;
  1426.   if (videos.size > 1) {
  1427.     shaka.log.warning('Multiple video tracks selected to be stored');
  1428.   }
  1430.   for (const audio1 of audios) {
  1431.     for (const audio2 of audios) {
  1432.       if (audio1 != audio2 && audio1.language == audio2.language) {
  1433.         shaka.log.warning(
  1434.             'Similar audio tracks were selected to be stored',
  1435.             audio1.id,
  1436.             audio2.id);
  1437.       }
  1438.     }
  1439.   }
  1441.   for (const text1 of texts) {
  1442.     for (const text2 of texts) {
  1443.       if (text1 != text2 && text1.language == text2.language) {
  1444.         shaka.log.warning(
  1445.             'Similar text tracks were selected to be stored',
  1446.             text1.id,
  1447.             text2.id);
  1448.       }
  1449.     }
  1450.   }
  1451. };
  1453. shaka.offline.Storage.defaultSystemIds_ = new Map()
  1454.     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
  1455.     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')
  1456.     .set('com.microsoft.playready', '9a04f07998404286ab92e65be0885f95')
  1457.     .set('com.adobe.primetime', 'f239e769efa348509c16a903c6932efb');
  1459. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);