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.Player');
  22. goog.require('shaka.log');
  23. goog.require('shaka.media.DrmEngine');
  24. goog.require('shaka.media.ManifestParser');
  25. goog.require('shaka.net.NetworkingEngine');
  26. goog.require('shaka.offline.DownloadManager');
  27. goog.require('shaka.offline.ManifestConverter');
  28. goog.require('shaka.offline.OfflineUri');
  29. goog.require('shaka.offline.StorageCellPath');
  30. goog.require('shaka.offline.StorageMuxer');
  31. goog.require('shaka.offline.StoredContentUtils');
  32. goog.require('shaka.offline.StreamBandwidthEstimator');
  33. goog.require('shaka.util.ConfigUtils');
  34. goog.require('shaka.util.Error');
  35. goog.require('shaka.util.Functional');
  36. goog.require('shaka.util.IDestroyable');
  37. goog.require('shaka.util.LanguageUtils');
  38. goog.require('shaka.util.ManifestParserUtils');
  39. goog.require('shaka.util.MapUtils');
  40. goog.require('shaka.util.StreamUtils');
  44. /**
  45.  * This manages persistent offline data including storage, listing, and deleting
  46.  * stored manifests.  Playback of offline manifests are done through the Player
  47.  * using a special URI (see shaka.offline.OfflineUri).
  48.  *
  49.  * First, check support() to see if offline is supported by the platform.
  50.  * Second, configure() the storage object with callbacks to your application.
  51.  * Third, call store(), remove(), or list() as needed.
  52.  * When done, call destroy().
  53.  *
  54.  * @param {shaka.Player} player
  55.  *   The player instance to pull configuration data from.
  56.  *
  57.  * @struct
  58.  * @constructor
  59.  * @implements {shaka.util.IDestroyable}
  60.  * @export
  61.  */
  62. shaka.offline.Storage = function(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 one
  65.   // now.
  66.   if (!player || player.constructor != shaka.Player) {
  67.     throw new shaka.util.Error(
  68.         shaka.util.Error.Severity.CRITICAL,
  69.         shaka.util.Error.Category.STORAGE,
  70.         shaka.util.Error.Code.LOCAL_PLAYER_INSTANCE_REQUIRED);
  71.   }
  73.   /** @private {shaka.Player} */
  74.   this.player_ = player;
  76.   /** @private {?shakaExtern.OfflineConfiguration} */
  77.   this.config_ = this.defaultConfig_();
  79.   /** @private {boolean} */
  80.   this.storeInProgress_ = false;
  82.   /** @private {Array.<shakaExtern.Track>} */
  83.   this.firstPeriodTracks_ = null;
  85.   /**
  86.    * A list of segment ids for all the segments that were added during the
  87.    * current store. If the store fails or is aborted, these need to be
  88.    * removed from storage.
  89.    * @private {!Array.<number>}
  90.    */
  91.   this.segmentsFromStore_ = [];
  92. };
  95. /**
  96.  * Gets whether offline storage is supported.  Returns true if offline storage
  97.  * is supported for clear content.  Support for offline storage of encrypted
  98.  * content will not be determined until storage is attempted.
  99.  *
  100.  * @return {boolean}
  101.  * @export
  102.  */
  103. shaka.offline.Storage.support = function() {
  104.   return shaka.offline.StorageMuxer.support();
  105. };
  108. /**
  109.  * @override
  110.  * @export
  111.  */
  112. shaka.offline.Storage.prototype.destroy = function() {
  113.   this.config_ = null;
  114.   this.player_ = null;
  116.   // TODO: Need to wait for whatever current store, remove, or list async
  117.   //       operations that may be in progress to stop/fail before we
  118.   //       resolve this promise.
  119.   return Promise.resolve();
  120. };
  123. /**
  124.  * Sets configuration values for Storage.  This is not associated with
  125.  * Player.configure and will not change Player.
  126.  *
  127.  * There are two important callbacks configured here: one for download progress,
  128.  * and one to decide which tracks to store.
  129.  *
  130.  * The default track selection callback will store the largest SD video track.
  131.  * Provide your own callback to choose the tracks you want to store.
  132.  *
  133.  * @param {!Object} config This should follow the form of
  134.  *   {@link shakaExtern.OfflineConfiguration}, but you may omit any field you do
  135.  *   not wish to change.
  136.  * @export
  137.  */
  138. shaka.offline.Storage.prototype.configure = function(config) {
  139.   goog.asserts.assert(this.config_, 'Storage must not be destroyed');
  140.   shaka.util.ConfigUtils.mergeConfigObjects(
  141.       this.config_, config, this.defaultConfig_(), {}, '');
  142. };
  145. /**
  146.  * Stores the given manifest.  If the content is encrypted, and encrypted
  147.  * content cannot be stored on this platform, the Promise will be rejected with
  148.  * error code 6001, REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE.
  149.  *
  150.  * @param {string} uri The URI of the manifest to store.
  151.  * @param {!Object=} opt_appMetadata An arbitrary object from the application
  152.  *   that will be stored along-side the offline content.  Use this for any
  153.  *   application-specific metadata you need associated with the stored content.
  154.  *   For details on the data types that can be stored here, please refer to
  155.  *   {@link https://goo.gl/h62coS}
  156.  * @param {!shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  157.  * @return {!Promise.<shakaExtern.StoredContent>}  A Promise to a structure
  158.  *   representing what was stored.  The "offlineUri" member is the URI that
  159.  *   should be given to Player.load() to play this piece of content offline.
  160.  *   The "appMetadata" member is the appMetadata argument you passed to store().
  161.  * @export
  162.  */
  163. shaka.offline.Storage.prototype.store = async function(
  164.     uri, opt_appMetadata, opt_manifestParserFactory) {
  165.   // TODO: Create a way for a download to be canceled while being downloaded.
  166.   this.requireSupport_();
  168.   if (this.storeInProgress_) {
  169.     return Promise.reject(new shaka.util.Error(
  170.         shaka.util.Error.Severity.CRITICAL,
  171.         shaka.util.Error.Category.STORAGE,
  172.         shaka.util.Error.Code.STORE_ALREADY_IN_PROGRESS));
  173.   }
  174.   this.storeInProgress_ = true;
  176.   /** @type {!Object} */
  177.   let appMetadata = opt_appMetadata || {};
  179.   let error = null;
  180.   let onError = (e) => {
  181.     // To avoid hiding a previously thrown error, throw the older error.
  182.     error = error || e;
  183.   };
  185.   let data = await this.loadInternal(
  186.       uri, onError, opt_manifestParserFactory);
  188.   let canDownload = !data.manifest.presentationTimeline.isLive() &&
  189.                     !data.manifest.presentationTimeline.isInProgress();
  191.   if (!canDownload) {
  192.     throw new shaka.util.Error(
  193.         shaka.util.Error.Severity.CRITICAL,
  194.         shaka.util.Error.Category.STORAGE,
  195.         shaka.util.Error.Code.CANNOT_STORE_LIVE_OFFLINE,
  196.         uri);
  197.   }
  199.   this.checkDestroyed_();
  200.   if (error) { throw error; }
  202.   /** @type {!shaka.offline.StorageMuxer} */
  203.   const muxer = new shaka.offline.StorageMuxer();
  204.   return shaka.util.IDestroyable.with([muxer, data.drmEngine], async () => {
  205.     try {
  206.       await muxer.init();
  207.       this.checkDestroyed_();
  209.       // Re-filter now that DrmEngine is initialized.
  210.       this.filterAllPeriods_(data.drmEngine, data.manifest.periods);
  212.       // Get the cell that we are saving the manifest to. Once we get a cell
  213.       // we will only reference the cell and not the muxer so that the manifest
  214.       // and segments will all be saved to the same cell.
  215.       let active = await muxer.getActive();
  216.       this.checkDestroyed_();
  218.       try {
  219.         let manifestDB = await this.downloadManifest_(
  220.             active.cell,
  221.             data.drmEngine,
  222.             data.manifest,
  223.             uri,
  224.             appMetadata || {});
  225.         this.checkDestroyed_();
  227.         let ids = await active.cell.addManifests([manifestDB]);
  228.         this.checkDestroyed_();
  230.         let offlineUri = shaka.offline.OfflineUri.manifest(
  231.             active.path.mechanism, active.path.cell, ids[0]);
  232.         return shaka.offline.StoredContentUtils.fromManifestDB(
  233.             offlineUri, manifestDB);
  234.       } catch (e) {
  235.         // We need to remove all the segments that did get into storage as
  236.         // the manifest won't be playable.
  237.         let segmentsToRemove = this.segmentsFromStore_;
  238.         let noop = () => {};
  239.         await active.cell.removeSegments(segmentsToRemove, noop);
  241.         // If we already had an error, ignore this error to avoid hiding
  242.         // the original error.
  243.         throw error || e;
  244.       }
  245.     } finally {
  246.       this.storeInProgress_ = false;
  247.       this.firstPeriodTracks_ = null;
  248.       this.segmentsFromStore_ = [];
  249.     }
  250.   });
  251. };
  254. /**
  255.  * Create a download manager and download the manifest.
  256.  *
  257.  * @param {shakaExtern.StorageCell} storage
  258.  * @param {!shaka.media.DrmEngine} drm
  259.  * @param {shakaExtern.Manifest} manifest
  260.  * @param {string} uri
  261.  * @param {!Object} metadata
  262.  * @return {!Promise.<shakaExtern.ManifestDB>}
  263.  * @private
  264.  */
  265. shaka.offline.Storage.prototype.downloadManifest_ = function(
  266.     storage, drm, manifest, uri, metadata) {
  267.   const noSize = 0;
  268.   let pendingContent = shaka.offline.StoredContentUtils.fromManifest(
  269.       uri, manifest, noSize, metadata);
  271.   /** @type {!shaka.offline.DownloadManager} */
  272.   let downloader = new shaka.offline.DownloadManager((progress, size) => {
  273.     // Update the size of the stored content before issuing a progress update.
  274.     pendingContent.size = size;
  275.     this.config_.progressCallback(pendingContent, progress);
  276.   });
  278.   /** @type {shakaExtern.ManifestDB} */
  279.   let manifestDB;
  280.   return shaka.util.IDestroyable.with([downloader], () => {
  281.     manifestDB = this.createOfflineManifest_(
  282.         downloader, storage, drm, manifest, uri, metadata);
  283.     return downloader.download(this.getNetEngine_());
  284.   }).then(() => {
  285.     // Update the size before saving it.
  286.     manifestDB.size = pendingContent.size;
  287.     return manifestDB;
  288.   });
  289. };
  292. /**
  293.  * Removes the given stored content.  This will also attempt to release the
  294.  * licenses, if any.
  295.  *
  296.  * @param {string} contentUri
  297.  * @return {!Promise}
  298.  * @export
  299.  */
  300. shaka.offline.Storage.prototype.remove = function(contentUri) {
  301.   this.requireSupport_();
  303.   let nullableUri = shaka.offline.OfflineUri.parse(contentUri);
  304.   if (nullableUri == null || !nullableUri.isManifest()) {
  305.     return Promise.reject(new shaka.util.Error(
  306.         shaka.util.Error.Severity.CRITICAL,
  307.         shaka.util.Error.Category.STORAGE,
  308.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  309.         contentUri));
  310.   }
  312.   let uri = /** @type {!shaka.offline.OfflineUri} */ (nullableUri);
  314.   let muxer = new shaka.offline.StorageMuxer();
  315.   return shaka.util.IDestroyable.with([muxer], async () => {
  316.     await muxer.init();
  318.     let cell = await muxer.getCell(uri.mechanism(), uri.cell());
  319.     let manifests = await cell.getManifests([uri.key()]);
  320.     let manifest = manifests[0];
  322.     await Promise.all([
  323.       this.removeFromDRM_(uri, manifest),
  324.       this.removeFromStorage_(cell, uri, manifest)
  325.     ]);
  326.   });
  327. };
  330. /**
  331.  * @param {!shaka.offline.OfflineUri} uri
  332.  * @param {shakaExtern.ManifestDB} manifestDB
  333.  * @return {!Promise}
  334.  * @private
  335.  */
  336. shaka.offline.Storage.prototype.removeFromDRM_ = function(uri, manifestDB) {
  337.   let netEngine = this.getNetEngine_();
  339.   let error;
  340.   let onError = (e) => {
  341.     // Ignore errors if the session was already removed.
  342.     if (e.code != shaka.util.Error.Code.OFFLINE_SESSION_REMOVED) {
  343.       error = e;
  344.     }
  345.   };
  347.   let drmEngine = new shaka.media.DrmEngine({
  348.     netEngine: netEngine,
  349.     onError: onError,
  350.     onKeyStatus: () => {},
  351.     onExpirationUpdated: () => {},
  352.     onEvent: () => {}
  353.   });
  355.   drmEngine.configure(this.player_.getConfiguration().drm);
  357.   let converter = new shaka.offline.ManifestConverter(
  358.       uri.mechanism(), uri.cell());
  359.   let manifest = converter.fromManifestDB(manifestDB);
  361.   return shaka.util.IDestroyable.with([drmEngine], async () => {
  362.     await drmEngine.init(manifest, this.config_.usePersistentLicense);
  363.     await drmEngine.removeSessions(manifestDB.sessionIds);
  364.   }).then(() => { if (error) { throw error; } });
  365. };
  368. /**
  369.  * @param {shakaExtern.StorageCell} storage
  370.  * @param {!shaka.offline.OfflineUri} uri
  371.  * @param {shakaExtern.ManifestDB} manifest
  372.  * @return {!Promise}
  373.  * @private
  374.  */
  375. shaka.offline.Storage.prototype.removeFromStorage_ = function(
  376.     storage, uri, manifest) {
  377.   /** @type {!Array.<number>} */
  378.   let segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
  380.   // Count(segments) + Count(manifests)
  381.   let toRemove = segmentIds.length + 1;
  382.   let removed = 0;
  384.   let pendingContent = shaka.offline.StoredContentUtils.fromManifestDB(
  385.       uri, manifest);
  387.   let onRemove = (key) => {
  388.     removed += 1;
  389.     this.config_.progressCallback(pendingContent, removed / toRemove);
  390.   };
  392.   return Promise.all([
  393.     storage.removeSegments(segmentIds, onRemove),
  394.     storage.removeManifests([uri.key()], onRemove)
  395.   ]);
  396. };
  399. /**
  400.  * Lists all the stored content available.
  401.  *
  402.  * @return {!Promise.<!Array.<shakaExtern.StoredContent>>}  A Promise to an
  403.  *   array of structures representing all stored content.  The "offlineUri"
  404.  *   member of the structure is the URI that should be given to Player.load()
  405.  *   to play this piece of content offline.  The "appMetadata" member is the
  406.  *   appMetadata argument you passed to store().
  407.  * @export
  408.  */
  409. shaka.offline.Storage.prototype.list = function() {
  410.   this.requireSupport_();
  412.   /** @type {!Array.<shakaExtern.StoredContent>} */
  413.   let result = [];
  415.   /**
  416.    * @param {!shaka.offline.StorageCellPath} path
  417.    * @param {shakaExtern.StorageCell} cell
  418.    */
  419.   async function onCell(path, cell) {
  420.     let manifests = await cell.getAllManifests();
  422.     shaka.util.MapUtils.forEach(manifests, (key, manifest) => {
  423.       let uri = shaka.offline.OfflineUri.manifest(
  424.           path.mechanism, path.cell, key);
  425.       let content = shaka.offline.StoredContentUtils.fromManifestDB(
  426.           uri, manifest);
  428.       result.push(content);
  429.     });
  430.   }
  432.   // Go over each storage cell and call |onCell| to create our list of
  433.   // stored content.
  434.   let muxer = new shaka.offline.StorageMuxer();
  435.   return shaka.util.IDestroyable.with([muxer], async () => {
  436.     await muxer.init();
  438.     let p = Promise.resolve();
  439.     muxer.forEachCell((path, cell) => {
  440.       p = p.then(() => onCell(path, cell));
  441.     });
  443.     await p;
  444.   }).then(() => result);
  445. };
  448. /**
  449.  * Loads the given manifest, parses it, and constructs the DrmEngine.  This
  450.  * stops the manifest parser.  This may be replaced by tests.
  451.  *
  452.  * @param {string} manifestUri
  453.  * @param {function(*)} onError
  454.  * @param {!shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  455.  * @return {!Promise.<{
  456.  *   manifest: shakaExtern.Manifest,
  457.  *   drmEngine: !shaka.media.DrmEngine
  458.  * }>}
  459.  */
  460. shaka.offline.Storage.prototype.loadInternal = function(
  461.     manifestUri, onError, opt_manifestParserFactory) {
  463.   let netEngine = this.getNetEngine_();
  464.   let config = this.player_.getConfiguration();
  466.   /** @type {shakaExtern.Manifest} */
  467.   let manifest;
  468.   /** @type {!shaka.media.DrmEngine} */
  469.   let drmEngine;
  470.   /** @type {shakaExtern.ManifestParser} */
  471.   let manifestParser;
  473.   let onKeyStatusChange = function() {};
  474.   return shaka.media.ManifestParser
  475.       .getFactory(
  476.           manifestUri, netEngine, config.manifest.retryParameters,
  477.           opt_manifestParserFactory)
  478.       .then(function(factory) {
  479.         this.checkDestroyed_();
  481.         drmEngine = new shaka.media.DrmEngine({
  482.           netEngine: netEngine,
  483.           onError: onError,
  484.           onKeyStatus: onKeyStatusChange,
  485.           onExpirationUpdated: () => {},
  486.           onEvent: () => {}
  487.         });
  489.         drmEngine.configure(config.drm);
  491.         let playerInterface = {
  492.           networkingEngine: netEngine,
  493.           filterAllPeriods: (periods) => {
  494.             this.filterAllPeriods_(drmEngine, periods);
  495.           },
  496.           filterNewPeriod: (period) => {
  497.             this.filterPeriod_(drmEngine, period);
  498.           },
  499.           onTimelineRegionAdded: function() {},
  500.           onEvent: function() {},
  501.           onError: onError
  502.         };
  504.         manifestParser = new factory();
  505.         manifestParser.configure(config.manifest);
  506.         return manifestParser.start(manifestUri, playerInterface);
  507.       }.bind(this))
  508.       .then(function(data) {
  509.         this.checkDestroyed_();
  510.         manifest = data;
  511.         return drmEngine.init(manifest, this.config_.usePersistentLicense);
  512.       }.bind(this))
  513.       .then(function() {
  514.         this.checkDestroyed_();
  515.         return this.createSegmentIndex_(manifest);
  516.       }.bind(this))
  517.       .then(function() {
  518.         this.checkDestroyed_();
  519.         return drmEngine.createOrLoad();
  520.       }.bind(this))
  521.       .then(function() {
  522.         this.checkDestroyed_();
  523.         return manifestParser.stop();
  524.       }.bind(this))
  525.       .then(function() {
  526.         this.checkDestroyed_();
  527.         return {manifest: manifest, drmEngine: drmEngine};
  528.       }.bind(this))
  529.       .catch(function(error) {
  530.         if (manifestParser) {
  531.           return manifestParser.stop().then(function() { throw error; });
  532.         } else {
  533.           throw error;
  534.         }
  535.       });
  536. };
  539. /**
  540.  * The default track selection function.
  541.  *
  542.  * @param {string} preferredAudioLanguage
  543.  * @param {!Array.<shakaExtern.Track>} tracks
  544.  * @return {!Array.<shakaExtern.Track>}
  545.  */
  546. shaka.offline.Storage.defaultTrackSelect =
  547.     function(preferredAudioLanguage, tracks) {
  548.   const LanguageUtils = shaka.util.LanguageUtils;
  549.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  551.   let selectedTracks = [];
  553.   // Select variants with best language match.
  554.   let audioLangPref = LanguageUtils.normalize(preferredAudioLanguage);
  555.   let matchTypes = [
  556.     LanguageUtils.MatchType.EXACT,
  557.     LanguageUtils.MatchType.BASE_LANGUAGE_OKAY,
  558.     LanguageUtils.MatchType.OTHER_SUB_LANGUAGE_OKAY
  559.   ];
  560.   let allVariantTracks =
  561.       tracks.filter(function(track) { return track.type == 'variant'; });
  562.   // For each match type, get the tracks that match the audio preference for
  563.   // that match type.
  564.   let tracksByMatchType = matchTypes.map(function(match) {
  565.     return allVariantTracks.filter(function(track) {
  566.       let lang = LanguageUtils.normalize(track.language);
  567.       return LanguageUtils.match(match, audioLangPref, lang);
  568.     });
  569.   });
  571.   // Find the best match type that has any matches.
  572.   let variantTracks;
  573.   for (let i = 0; i < tracksByMatchType.length; i++) {
  574.     if (tracksByMatchType[i].length) {
  575.       variantTracks = tracksByMatchType[i];
  576.       break;
  577.     }
  578.   }
  580.   // Fall back to "primary" audio tracks, if present.
  581.   if (!variantTracks) {
  582.     let primaryTracks = allVariantTracks.filter(function(track) {
  583.       return track.primary;
  584.     });
  585.     if (primaryTracks.length) {
  586.       variantTracks = primaryTracks;
  587.     }
  588.   }
  590.   // Otherwise, there is no good way to choose the language, so we don't choose
  591.   // a language at all.
  592.   if (!variantTracks) {
  593.     variantTracks = allVariantTracks;
  594.     // Issue a warning, but only if the content has multiple languages.
  595.     // Otherwise, this warning would just be noise.
  596.     let languages = allVariantTracks
  597.         .map(function(track) { return track.language; })
  598.         .filter(shaka.util.Functional.isNotDuplicate);
  599.     if (languages.length > 1) {
  600.       shaka.log.warning('Could not choose a good audio track based on ' +
  601.                         'language preferences or primary tracks.  An ' +
  602.                         'arbitrary language will be stored!');
  603.     }
  604.   }
  606.   // From previously selected variants, choose the SD ones (height <= 480).
  607.   let tracksByHeight = variantTracks.filter(function(track) {
  608.     return track.height && track.height <= 480;
  609.   });
  611.   // If variants don't have video or no video with height <= 480 was
  612.   // found, proceed with the previously selected tracks.
  613.   if (tracksByHeight.length) {
  614.     // Sort by resolution, then select all variants which match the height
  615.     // of the highest SD res.  There may be multiple audio bitrates for the
  616.     // same video resolution.
  617.     tracksByHeight.sort(function(a, b) { return b.height - a.height; });
  618.     variantTracks = tracksByHeight.filter(function(track) {
  619.       return track.height == tracksByHeight[0].height;
  620.     });
  621.   }
  623.   // Now sort by bandwidth.
  624.   variantTracks.sort(function(a, b) { return a.bandwidth - b.bandwidth; });
  626.   // If there are multiple matches at different audio bitrates, select the
  627.   // middle bandwidth one.
  628.   if (variantTracks.length) {
  629.     selectedTracks.push(variantTracks[Math.floor(variantTracks.length / 2)]);
  630.   }
  632.   // Since this default callback is used primarily by our own demo app and by
  633.   // app developers who haven't thought about which tracks they want, we should
  634.   // select all text tracks, regardless of language.  This makes for a better
  635.   // demo for us, and does not rely on user preferences for the unconfigured
  636.   // app.
  637.   selectedTracks.push.apply(selectedTracks, tracks.filter(function(track) {
  638.     return track.type == ContentType.TEXT;
  639.   }));
  641.   return selectedTracks;
  642. };
  645. /**
  646.  * @return {shakaExtern.OfflineConfiguration}
  647.  * @private
  648.  */
  649. shaka.offline.Storage.prototype.defaultConfig_ = function() {
  650.   let selectionCallback = (tracks) => {
  651.     goog.asserts.assert(
  652.         this.player_,
  653.         'The player should be non-null when selecting tracks');
  654.     let config = this.player_.getConfiguration();
  655.     return shaka.offline.Storage.defaultTrackSelect(
  656.         config.preferredAudioLanguage, tracks);
  657.   };
  659.   let progressCallback = (content, percent) => {
  660.     // Reference arguments to keep closure from removing them.
  661.     // If the arguments are removed, it breaks our function length check
  662.     // in mergeConfigObjects_().
  663.     // NOTE: Chrome App Content Security Policy prohibits usage of new
  664.     // Function().
  665.     if (content || percent) return null;
  666.   };
  668.   return {
  669.     trackSelectionCallback: selectionCallback,
  670.     progressCallback: progressCallback,
  671.     usePersistentLicense: true
  672.   };
  673. };
  676. /**
  677.  * @param {!shaka.media.DrmEngine} drmEngine
  678.  * @param {!Array.<shakaExtern.Period>} periods
  679.  * @private
  680.  */
  681. shaka.offline.Storage.prototype.filterAllPeriods_ = function(
  682.     drmEngine, periods) {
  683.   periods.forEach((period) => this.filterPeriod_(drmEngine, period));
  684. };
  687. /**
  688.  * @param {!shaka.media.DrmEngine} drmEngine
  689.  * @param {shakaExtern.Period} period
  690.  * @private
  691.  */
  692. shaka.offline.Storage.prototype.filterPeriod_ = function(drmEngine, period) {
  693.   const StreamUtils = shaka.util.StreamUtils;
  695.   const maxHwRes = {width: Infinity, height: Infinity};
  697.   /** @type {?shakaExtern.Variant} */
  698.   let variant = null;
  700.   if (this.firstPeriodTracks_) {
  701.     let variantTrack = this.firstPeriodTracks_.filter(function(track) {
  702.       return track.type == 'variant';
  703.     })[0];
  705.     if (variantTrack) {
  706.       variant = StreamUtils.findVariantForTrack(period, variantTrack);
  707.     }
  708.   }
  710.   /** @type {?shakaExtern.Stream} */
  711.   let activeAudio = null;
  712.   /** @type {?shakaExtern.Stream} */
  713.   let activeVideo = null;
  715.   if (variant) {
  716.     // Use the first variant as the container of "active streams".  This
  717.     // is then used to filter out the streams that are not compatible with it.
  718.     // This ensures that in multi-Period content, all Periods have streams
  719.     // with compatible MIME types.
  720.     if (variant.audio) activeAudio = variant.audio;
  721.     if (variant.video) activeVideo = variant.video;
  722.   }
  724.   StreamUtils.filterNewPeriod(
  725.       drmEngine, activeAudio, activeVideo, period);
  726.   StreamUtils.applyRestrictions(
  727.       period, this.player_.getConfiguration().restrictions, maxHwRes);
  728. };
  732. /**
  733.  * Calls createSegmentIndex for all streams in the manifest.
  734.  *
  735.  * @param {shakaExtern.Manifest} manifest
  736.  * @return {!Promise}
  737.  * @private
  738.  */
  739. shaka.offline.Storage.prototype.createSegmentIndex_ = function(manifest) {
  740.   const Functional = shaka.util.Functional;
  741.   let streams = manifest.periods
  742.       .map(function(period) { return period.variants; })
  743.       .reduce(Functional.collapseArrays, [])
  744.       .map(function(variant) {
  745.         let variantStreams = [];
  746.         if (variant.audio) variantStreams.push(variant.audio);
  747.         if (variant.video) variantStreams.push(variant.video);
  748.         return variantStreams;
  749.       })
  750.       .reduce(Functional.collapseArrays, [])
  751.       .filter(Functional.isNotDuplicate);
  753.   let textStreams = manifest.periods
  754.       .map(function(period) { return period.textStreams; })
  755.       .reduce(Functional.collapseArrays, []);
  757.   streams.push.apply(streams, textStreams);
  758.   return Promise.all(
  759.       streams.map(function(stream) { return stream.createSegmentIndex(); }));
  760. };
  763. /**
  764.  * Creates an offline 'manifest' for the real manifest.  This does not store the
  765.  * segments yet, only adds them to the download manager through createPeriod_.
  766.  *
  767.  * @param {!shaka.offline.DownloadManager} downloader
  768.  * @param {shakaExtern.StorageCell} storage
  769.  * @param {!shaka.media.DrmEngine} drmEngine
  770.  * @param {shakaExtern.Manifest} manifest
  771.  * @param {string} originalManifestUri
  772.  * @param {!Object} metadata
  773.  * @return {shakaExtern.ManifestDB}
  774.  * @private
  775.  */
  776. shaka.offline.Storage.prototype.createOfflineManifest_ = function(
  777.     downloader, storage, drmEngine, manifest, originalManifestUri, metadata) {
  778.   let estimator = new shaka.offline.StreamBandwidthEstimator();
  780.   let periods = manifest.periods.map((period) => {
  781.     return this.createPeriod_(
  782.         downloader, storage, estimator, drmEngine, manifest, period);
  783.   });
  785.   let drmInfo = drmEngine.getDrmInfo();
  786.   let sessions = drmEngine.getSessionIds();
  788.   if (drmInfo && this.config_.usePersistentLicense) {
  789.     if (!sessions.length) {
  790.       throw new shaka.util.Error(
  791.           shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.STORAGE,
  792.           shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE, originalManifestUri);
  793.     }
  794.     // Don't store init data, since we have stored sessions.
  795.     drmInfo.initData = [];
  796.   }
  798.   return {
  799.     originalManifestUri: originalManifestUri,
  800.     duration: manifest.presentationTimeline.getDuration(),
  801.     size: 0,
  802.     expiration: drmEngine.getExpiration(),
  803.     periods: periods,
  804.     sessionIds: this.config_.usePersistentLicense ? sessions : [],
  805.     drmInfo: drmInfo,
  806.     appMetadata: metadata
  807.   };
  808. };
  811. /**
  812.  * Converts a manifest Period to a database Period.  This will use the current
  813.  * configuration to get the tracks to use, then it will search each segment
  814.  * index and add all the segments to the download manager through createStream_.
  815.  *
  816.  * @param {!shaka.offline.DownloadManager} downloader
  817.  * @param {shakaExtern.StorageCell} storage
  818.  * @param {shaka.offline.StreamBandwidthEstimator} estimator
  819.  * @param {!shaka.media.DrmEngine} drmEngine
  820.  * @param {shakaExtern.Manifest} manifest
  821.  * @param {shakaExtern.Period} period
  822.  * @return {shakaExtern.PeriodDB}
  823.  * @private
  824.  */
  825. shaka.offline.Storage.prototype.createPeriod_ = function(
  826.     downloader, storage, estimator, drmEngine, manifest, period) {
  827.   const StreamUtils = shaka.util.StreamUtils;
  829.   let variantTracks = StreamUtils.getVariantTracks(period, null, null);
  830.   let textTracks = StreamUtils.getTextTracks(period, null);
  831.   let allTracks = variantTracks.concat(textTracks);
  833.   let chosenTracks = this.config_.trackSelectionCallback(allTracks);
  835.   if (this.firstPeriodTracks_ == null) {
  836.     this.firstPeriodTracks_ = chosenTracks;
  837.     // Now that the first tracks are chosen, filter again.  This ensures all
  838.     // Periods have compatible content types.
  839.     this.filterAllPeriods_(drmEngine, manifest.periods);
  840.   }
  842.   // Check for any similar tracks.
  843.   if (shaka.offline.Storage.lookForSimilarTracks_(chosenTracks)) {
  844.     shaka.log.warning(
  845.         'Multiple tracks of the same type/kind/language given.');
  846.   }
  848.   // Pass all variants and text streams to the estimator so that we can
  849.   // get the best estimate for each stream later.
  850.   manifest.periods.forEach((period) => {
  851.     period.variants.forEach((variant) => { estimator.addVariant(variant); });
  852.     period.textStreams.forEach((text) => { estimator.addText(text); });
  853.   });
  855.   // Need a way to look up which streams should be downloaded. Use a map so
  856.   // that we can easily lookup if a stream should be downloaded just by
  857.   // checking if its id is in the map.
  858.   let idMap = {};
  859.   chosenTracks.forEach((track) => {
  860.     if (track.type == 'variant' && track.audioId != null) {
  861.       idMap[track.audioId] = true;
  862.     }
  863.     if (track.type == 'variant' && track.videoId != null) {
  864.       idMap[track.videoId] = true;
  865.     }
  866.     if (track.type == 'text') {
  867.       idMap[track.id] = true;
  868.     }
  869.   });
  871.   // Find the streams we want to download and create a stream db instance
  872.   // for each of them.
  873.   let streamDBs = {};
  874.   shaka.offline.Storage.getStreamSet_(manifest)
  875.       .filter((stream) => !!idMap[stream.id])
  876.       .forEach((stream) => {
  877.         streamDBs[stream.id] = this.createStream_(
  878.             downloader, storage, estimator, manifest, period, stream);
  879.       });
  881.   // Connect streams and variants together.
  882.   chosenTracks.forEach((track) => {
  883.     if (track.type == 'variant' && track.audioId != null) {
  884.       streamDBs[track.audioId].variantIds.push(track.id);
  885.     }
  886.     if (track.type == 'variant' && track.videoId != null) {
  887.       streamDBs[track.videoId].variantIds.push(track.id);
  888.     }
  889.   });
  891.   return {
  892.     startTime: period.startTime,
  893.     streams: shaka.util.MapUtils.values(streamDBs)
  894.   };
  895. };
  898. /**
  899.  * Converts a manifest stream to a database stream.  This will search the
  900.  * segment index and add all the segments to the download manager.
  901.  *
  902.  * @param {!shaka.offline.DownloadManager} downloader
  903.  * @param {shakaExtern.StorageCell} storage
  904.  * @param {shaka.offline.StreamBandwidthEstimator} estimator
  905.  * @param {shakaExtern.Manifest} manifest
  906.  * @param {shakaExtern.Period} period
  907.  * @param {shakaExtern.Stream} stream
  908.  * @return {shakaExtern.StreamDB}
  909.  * @private
  910.  */
  911. shaka.offline.Storage.prototype.createStream_ = function(
  912.     downloader, storage, estimator, manifest, period, stream) {
  913.   /** @type {shakaExtern.StreamDB} */
  914.   let streamDb = {
  915.     id: stream.id,
  916.     primary: stream.primary,
  917.     presentationTimeOffset: stream.presentationTimeOffset || 0,
  918.     contentType: stream.type,
  919.     mimeType: stream.mimeType,
  920.     codecs: stream.codecs,
  921.     frameRate: stream.frameRate,
  922.     kind: stream.kind,
  923.     language: stream.language,
  924.     label: stream.label,
  925.     width: stream.width || null,
  926.     height: stream.height || null,
  927.     initSegmentKey: null,
  928.     encrypted: stream.encrypted,
  929.     keyId: stream.keyId,
  930.     segments: [],
  931.     variantIds: []
  932.   };
  934.   /** @type {number} */
  935.   let startTime =
  936.       manifest.presentationTimeline.getSegmentAvailabilityStart();
  938.   // Download each stream in parallel.
  939.   let downloadGroup = stream.id;
  941.   shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
  942.     downloader.queue(
  943.         downloadGroup,
  944.         this.createRequest_(segment),
  945.         estimator.getSegmentEstimate(stream.id, segment),
  946.         (data) => {
  947.           return storage.addSegments([{data: data}]).then((ids) => {
  948.             this.segmentsFromStore_.push(ids[0]);
  950.             streamDb.segments.push({
  951.               startTime: segment.startTime,
  952.               endTime: segment.endTime,
  953.               dataKey: ids[0]
  954.             });
  955.           });
  956.         });
  957.   });
  959.   let initSegment = stream.initSegmentReference;
  960.   if (initSegment) {
  961.     downloader.queue(
  962.         downloadGroup,
  963.         this.createRequest_(initSegment),
  964.         estimator.getInitSegmentEstimate(stream.id),
  965.         (data) => {
  966.           return storage.addSegments([{data: data}]).then((ids) => {
  967.             this.segmentsFromStore_.push(ids[0]);
  968.             streamDb.initSegmentKey = ids[0];
  969.           });
  970.         });
  971.   }
  973.   return streamDb;
  974. };
  977. /**
  978.  * @param {shakaExtern.Stream} stream
  979.  * @param {number} startTime
  980.  * @param {function(!shaka.media.SegmentReference)} callback
  981.  * @private
  982.  */
  983. shaka.offline.Storage.forEachSegment_ = function(stream, startTime, callback) {
  984.   /** @type {?number} */
  985.   let i = stream.findSegmentPosition(startTime);
  986.   /** @type {?shaka.media.SegmentReference} */
  987.   let ref = i == null ? null : stream.getSegmentReference(i);
  989.   while (ref) {
  990.     callback(ref);
  991.     ref = stream.getSegmentReference(++i);
  992.   }
  993. };
  996. /**
  997.  * Throws an error if the object is destroyed.
  998.  * @private
  999.  */
  1000. shaka.offline.Storage.prototype.checkDestroyed_ = function() {
  1001.   if (!this.player_) {
  1002.     throw new shaka.util.Error(
  1003.         shaka.util.Error.Severity.CRITICAL,
  1004.         shaka.util.Error.Category.STORAGE,
  1005.         shaka.util.Error.Code.OPERATION_ABORTED);
  1006.   }
  1007. };
  1010. /**
  1011.  * Used by functions that need storage support to ensure that the current
  1012.  * platform has storage support before continuing. This should only be
  1013.  * needed to be used at the start of public methods.
  1014.  *
  1015.  * @private
  1016.  */
  1017. shaka.offline.Storage.prototype.requireSupport_ = function() {
  1018.   if (!shaka.offline.Storage.support()) {
  1019.     throw new shaka.util.Error(
  1020.         shaka.util.Error.Severity.CRITICAL,
  1021.         shaka.util.Error.Category.STORAGE,
  1022.         shaka.util.Error.Code.STORAGE_NOT_SUPPORTED);
  1023.   }
  1024. };
  1027. /**
  1028.  * @return {!shaka.net.NetworkingEngine}
  1029.  * @private
  1030.  */
  1031. shaka.offline.Storage.prototype.getNetEngine_ = function() {
  1032.   let net = this.player_.getNetworkingEngine();
  1033.   goog.asserts.assert(net, 'Player must not be destroyed');
  1034.   return net;
  1035. };
  1038. /**
  1039.  * @param {!shaka.media.SegmentReference|
  1040.  *         !shaka.media.InitSegmentReference} segment
  1041.  * @return {shakaExtern.Request}
  1042.  * @private
  1043.  */
  1044. shaka.offline.Storage.prototype.createRequest_ = function(segment) {
  1045.   let retryParams = this.player_.getConfiguration().streaming.retryParameters;
  1046.   let request = shaka.net.NetworkingEngine.makeRequest(
  1047.       segment.getUris(), retryParams);
  1049.   if (segment.startByte != 0 || segment.endByte != null) {
  1050.     let end = segment.endByte == null ? '' : segment.endByte;
  1051.     request.headers['Range'] = 'bytes=' + segment.startByte + '-' + end;
  1052.   }
  1054.   return request;
  1055. };
  1058. /**
  1059.  * @param {shakaExtern.ManifestDB} manifest
  1060.  * @return {!Array.<number>}
  1061.  * @private
  1062.  */
  1063. shaka.offline.Storage.getAllSegmentIds_ = function(manifest) {
  1064.   /** @type {!Array.<number>} */
  1065.   let ids = [];
  1067.   // Get every segment for every stream in the manifest.
  1068.   manifest.periods.forEach(function(period) {
  1069.     period.streams.forEach(function(stream) {
  1070.       if (stream.initSegmentKey != null) {
  1071.         ids.push(stream.initSegmentKey);
  1072.       }
  1074.       stream.segments.forEach(function(segment) {
  1075.         ids.push(segment.dataKey);
  1076.       });
  1077.     });
  1078.   });
  1080.   return ids;
  1081. };
  1084. /**
  1085.  * Delete the on-disk storage and all the content it contains. This should not
  1086.  * be done in normal circumstances. Only do it when storage is rendered
  1087.  * unusable, such as by a version mismatch. No business logic will be run, and
  1088.  * licenses will not be released.
  1089.  *
  1090.  * @return {!Promise}
  1091.  * @export
  1092.  */
  1093. shaka.offline.Storage.deleteAll = async function() {
  1094.   /** @type {!shaka.offline.StorageMuxer} */
  1095.   const muxer = new shaka.offline.StorageMuxer();
  1096.   try {
  1097.     // Wipe all content from all storage mechanisms.
  1098.     await muxer.erase();
  1099.   } finally {
  1100.     // Destroy the muxer, whether or not erase() succeeded.
  1101.     await muxer.destroy();
  1102.   }
  1103. };
  1106. /**
  1107.  * Look to see if there are any tracks that are "too" similar to each other.
  1108.  *
  1109.  * @param {!Array.<shakaExtern.Track>} tracks
  1110.  * @return {boolean}
  1111.  * @private
  1112.  */
  1113. shaka.offline.Storage.lookForSimilarTracks_ = function(tracks) {
  1114.   return tracks.some((t0) => {
  1115.     return tracks.some((t1) => {
  1116.       return t0 != t1 &&
  1117.              t0.type == t1.type &&
  1118.              t0.kind == t1.kind &&
  1119.              t0.language == t1.language;
  1120.     });
  1121.   });
  1122. };
  1125. /**
  1126.  * Get a collection of streams that are in the manifest. This collection will
  1127.  * only have one instance of each stream (similar to a set).
  1128.  *
  1129.  * @param {shakaExtern.Manifest} manifest
  1130.  * @return {!Array.<shakaExtern.Stream>}
  1131.  * @private
  1132.  */
  1133. shaka.offline.Storage.getStreamSet_ = function(manifest) {
  1134.   // Use a map so that we don't store duplicates. Since a stream's id should
  1135.   // be unique within the manifest, we can use that as the key.
  1136.   let map = {};
  1138.   manifest.periods.forEach((period) => {
  1139.     period.textStreams.forEach((text) => { map[text.id] = text; });
  1140.     period.variants.forEach((variant) => {
  1141.       if (variant.audio) { map[variant.audio.id] = variant.audio; }
  1142.       if (variant.video) { map[variant.video.id] = variant.video; }
  1143.     });
  1144.   });
  1146.   return shaka.util.MapUtils.values(map);
  1147. };
  1150. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);