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.offline.DownloadManager');
  26. goog.require('shaka.offline.IStorageEngine');
  27. goog.require('shaka.offline.OfflineManifestParser');
  28. goog.require('shaka.offline.OfflineUtils');
  29. goog.require('shaka.util.ConfigUtils');
  30. goog.require('shaka.util.Error');
  31. goog.require('shaka.util.Functional');
  32. goog.require('shaka.util.IDestroyable');
  33. goog.require('shaka.util.LanguageUtils');
  34. goog.require('shaka.util.ManifestParserUtils');
  35. goog.require('shaka.util.StreamUtils');
  39. /**
  40.  * This manages persistent offline data including storage, listing, and deleting
  41.  * stored manifests.  Playback of offline manifests are done using Player
  42.  * using the special URI (e.g. 'offline:12').
  43.  *
  44.  * First, check support() to see if offline is supported by the platform.
  45.  * Second, configure() the storage object with callbacks to your application.
  46.  * Third, call store(), remove(), or list() as needed.
  47.  * When done, call destroy().
  48.  *
  49.  * @param {shaka.Player} player
  50.  *   The player instance to pull configuration data from.
  51.  *
  52.  * @struct
  53.  * @constructor
  54.  * @implements {shaka.util.IDestroyable}
  55.  * @export
  56.  */
  57. shaka.offline.Storage = function(player) {
  58.   // It is an easy mistake to make to pass a Player proxy from CastProxy.
  59.   // Rather than throw a vague exception later, throw an explicit and clear one
  60.   // now.
  61.   if (!player || player.constructor != shaka.Player) {
  62.     throw new shaka.util.Error(
  63.         shaka.util.Error.Severity.CRITICAL,
  64.         shaka.util.Error.Category.STORAGE,
  65.         shaka.util.Error.Code.LOCAL_PLAYER_INSTANCE_REQUIRED);
  66.   }
  68.   /** @private {shaka.offline.IStorageEngine} */
  69.   this.storageEngine_ = shaka.offline.OfflineUtils.createStorageEngine();
  71.   /** @private {shaka.Player} */
  72.   this.player_ = player;
  74.   /** @private {?shakaExtern.OfflineConfiguration} */
  75.   this.config_ = this.defaultConfig_();
  77.   /** @private {shaka.media.DrmEngine} */
  78.   this.drmEngine_ = null;
  80.   /** @private {boolean} */
  81.   this.storeInProgress_ = false;
  83.   /** @private {Array.<shakaExtern.Track>} */
  84.   this.firstPeriodTracks_ = null;
  86.   /** @private {number} */
  87.   this.manifestId_ = -1;
  89.   /** @private {number} */
  90.   this.duration_ = 0;
  92.   /** @private {?shakaExtern.Manifest} */
  93.   this.manifest_ = null;
  95.   var netEngine = player.getNetworkingEngine();
  96.   goog.asserts.assert(netEngine, 'Player must not be destroyed');
  98.   /** @private {shaka.offline.DownloadManager} */
  99.   this.downloadManager_ = new shaka.offline.DownloadManager(
  100.       this.storageEngine_, netEngine,
  101.       player.getConfiguration().streaming.retryParameters, this.config_);
  102. };
  105. /**
  106.  * Gets whether offline storage is supported.  Returns true if offline storage
  107.  * is supported for clear content.  Support for offline storage of encrypted
  108.  * content will not be determined until storage is attempted.
  109.  *
  110.  * @return {boolean}
  111.  * @export
  112.  */
  113. shaka.offline.Storage.support = function() {
  114.   return shaka.offline.OfflineUtils.isStorageEngineSupported();
  115. };
  118. /**
  119.  * @override
  120.  * @export
  121.  */
  122. shaka.offline.Storage.prototype.destroy = function() {
  123.   var storageEngine = this.storageEngine_;
  124.   // Destroy the download manager first since it needs the StorageEngine to
  125.   // clean up old segments.
  126.   var ret = !this.downloadManager_ ?
  127.       Promise.resolve() :
  128.       this.downloadManager_.destroy()
  129.           .catch(function() {})
  130.           .then(function() {
  131.             if (storageEngine) return storageEngine.destroy();
  132.           });
  134.   this.storageEngine_ = null;
  135.   this.downloadManager_ = null;
  136.   this.player_ = null;
  137.   this.config_ = null;
  138.   return ret;
  139. };
  142. /**
  143.  * Sets configuration values for Storage.  This is not associated with
  144.  * Player.configure and will not change Player.
  145.  *
  146.  * There are two important callbacks configured here: one for download progress,
  147.  * and one to decide which tracks to store.
  148.  *
  149.  * The default track selection callback will store the largest SD video track.
  150.  * Provide your own callback to choose the tracks you want to store.
  151.  *
  152.  * @param {!Object} config This should follow the form of
  153.  *   {@link shakaExtern.OfflineConfiguration}, but you may omit any field you do
  154.  *   not wish to change.
  155.  * @export
  156.  */
  157. shaka.offline.Storage.prototype.configure = function(config) {
  158.   goog.asserts.assert(this.config_, 'Storage must not be destroyed');
  159.   shaka.util.ConfigUtils.mergeConfigObjects(
  160.       this.config_, config, this.defaultConfig_(), {}, '');
  161. };
  164. /**
  165.  * Stores the given manifest.  If the content is encrypted, and encrypted
  166.  * content cannot be stored on this platform, the Promise will be rejected with
  167.  * error code 6001, REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE.
  168.  *
  169.  * @param {string} manifestUri The URI of the manifest to store.
  170.  * @param {!Object=} opt_appMetadata An arbitrary object from the application
  171.  *   that will be stored along-side the offline content.  Use this for any
  172.  *   application-specific metadata you need associated with the stored content.
  173.  *   For details on the data types that can be stored here, please refer to
  174.  *   https://goo.gl/h62coS
  175.  * @param {!shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  176.  * @return {!Promise.<shakaExtern.StoredContent>}  A Promise to a structure
  177.  *   representing what was stored.  The "offlineUri" member is the URI that
  178.  *   should be given to Player.load() to play this piece of content offline.
  179.  *   The "appMetadata" member is the appMetadata argument you passed to store().
  180.  * @export
  181.  */
  182. shaka.offline.Storage.prototype.store = function(
  183.     manifestUri, opt_appMetadata, opt_manifestParserFactory) {
  184.   if (this.storeInProgress_) {
  185.     return Promise.reject(new shaka.util.Error(
  186.         shaka.util.Error.Severity.CRITICAL,
  187.         shaka.util.Error.Category.STORAGE,
  188.         shaka.util.Error.Code.STORE_ALREADY_IN_PROGRESS));
  189.   }
  190.   this.storeInProgress_ = true;
  192.   /** @type {shakaExtern.ManifestDB} */
  193.   var manifestDb;
  195.   var error = null;
  196.   var onError = function(e) { error = e; };
  197.   return this.initIfNeeded_()
  198.       .then(function() {
  199.         this.checkDestroyed_();
  200.         return this.loadInternal(
  201.             manifestUri, onError, opt_manifestParserFactory);
  202.       }.bind(this)).then((
  203.           /**
  204.            * @param {{manifest: shakaExtern.Manifest,
  205.            *          drmEngine: !shaka.media.DrmEngine}} data
  206.            * @return {!Promise}
  207.            */
  208.           function(data) {
  209.             this.checkDestroyed_();
  210.             this.manifest_ = data.manifest;
  211.             this.drmEngine_ = data.drmEngine;
  213.             if (this.manifest_.presentationTimeline.isLive() ||
  214.                 this.manifest_.presentationTimeline.isInProgress()) {
  215.               throw new shaka.util.Error(
  216.                   shaka.util.Error.Severity.CRITICAL,
  217.                   shaka.util.Error.Category.STORAGE,
  218.                   shaka.util.Error.Code.CANNOT_STORE_LIVE_OFFLINE, manifestUri);
  219.             }
  221.             // Re-filter now that DrmEngine is initialized.
  222.             this.filterAllPeriods_(this.manifest_.periods);
  224.             this.manifestId_ = this.storageEngine_.reserveId('manifest');
  225.             this.duration_ = 0;
  226.             manifestDb =
  227.                 this.createOfflineManifest_(manifestUri, opt_appMetadata || {});
  228.             return this.downloadManager_.downloadAndStore(manifestDb);
  229.           })
  230.       .bind(this))
  231.       .then(function() {
  232.         this.checkDestroyed_();
  233.         // Throw any errors from the manifest parser or DrmEngine.
  234.         if (error)
  235.           throw error;
  237.         return this.cleanup_();
  238.       }.bind(this))
  239.       .then(function() {
  240.         return shaka.offline.OfflineUtils.getStoredContent(manifestDb);
  241.       }.bind(this))
  242.       .catch(function(err) {
  243.         var Functional = shaka.util.Functional;
  244.         return this.cleanup_().catch(Functional.noop).then(function() {
  245.           throw err;
  246.         });
  247.       }.bind(this));
  248. };
  251. /**
  252.  * Removes the given stored content.
  253.  *
  254.  * @param {shakaExtern.StoredContent} content
  255.  * @return {!Promise}
  256.  * @export
  257.  */
  258. shaka.offline.Storage.prototype.remove = function(content) {
  259.   var uri = content.offlineUri;
  260.   var parts = /^offline:([0-9]+)$/.exec(uri);
  261.   if (!parts) {
  262.     return Promise.reject(new shaka.util.Error(
  263.         shaka.util.Error.Severity.CRITICAL,
  264.         shaka.util.Error.Category.STORAGE,
  265.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI, uri));
  266.   }
  268.   var error = null;
  269.   var onError = function(e) {
  270.     // Ignore errors if the session was already removed.
  271.     if (e.code != shaka.util.Error.Code.OFFLINE_SESSION_REMOVED)
  272.       error = e;
  273.   };
  275.   /** @type {shakaExtern.ManifestDB} */
  276.   var manifestDb;
  277.   /** @type {!shaka.media.DrmEngine} */
  278.   var drmEngine;
  279.   var manifestId = Number(parts[1]);
  280.   return this.initIfNeeded_().then(function() {
  281.     this.checkDestroyed_();
  282.     return this.storageEngine_.get('manifest', manifestId);
  283.   }.bind(this)).then((
  284.       /**
  285.        * @param {?shakaExtern.ManifestDB} data
  286.        * @return {!Promise}
  287.        */
  288.       function(data) {
  289.         this.checkDestroyed_();
  290.         if (!data) {
  291.           throw new shaka.util.Error(
  292.               shaka.util.Error.Severity.CRITICAL,
  293.               shaka.util.Error.Category.STORAGE,
  294.               shaka.util.Error.Code.REQUESTED_ITEM_NOT_FOUND, uri);
  295.         }
  296.         manifestDb = data;
  297.         var manifest =
  298.             shaka.offline.OfflineManifestParser.reconstructManifest(manifestDb);
  299.         var netEngine = this.player_.getNetworkingEngine();
  300.         goog.asserts.assert(netEngine, 'Player must not be destroyed');
  301.         drmEngine = new shaka.media.DrmEngine({
  302.           netEngine: netEngine,
  303.           onError: onError,
  304.           onKeyStatus: function() {},
  305.           onExpirationUpdated: function() {},
  306.           onEvent: function() {}
  307.         });
  308.         drmEngine.configure(this.player_.getConfiguration().drm);
  309.         var isOffline = this.config_.usePersistentLicense || false;
  310.         return drmEngine.init(manifest, isOffline);
  311.       })
  312.   .bind(this)).then(function() {
  313.     return drmEngine.removeSessions(manifestDb.sessionIds);
  314.   }.bind(this)).then(function() {
  315.     return drmEngine.destroy();
  316.   }.bind(this)).then(function() {
  317.     this.checkDestroyed_();
  318.     if (error) throw error;
  319.     var Functional = shaka.util.Functional;
  320.     // Get every segment for every stream in the manifest.
  321.     /** @type {!Array.<number>} */
  322.     var segments = manifestDb.periods.map(function(period) {
  323.       return period.streams.map(function(stream) {
  324.         var segments = stream.segments.map(function(segment) {
  325.           var parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(segment.uri);
  326.           goog.asserts.assert(parts, 'Invalid offline URI');
  327.           return Number(parts[1]);
  328.         });
  329.         if (stream.initSegmentUri) {
  330.           var parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(
  331.               stream.initSegmentUri);
  332.           goog.asserts.assert(parts, 'Invalid offline URI');
  333.           segments.push(Number(parts[1]));
  334.         }
  335.         return segments;
  336.       }).reduce(Functional.collapseArrays, []);
  337.     }).reduce(Functional.collapseArrays, []);
  339.     // Delete all the segments.
  340.     var deleteCount = 0;
  341.     var segmentCount = segments.length;
  342.     var callback = this.config_.progressCallback;
  344.     return this.storageEngine_.removeKeys('segment', segments, function() {
  345.       deleteCount++;
  346.       callback(content, deleteCount / segmentCount);
  347.     });
  349.   }.bind(this)).then(function() {
  350.     this.checkDestroyed_();
  351.     this.config_.progressCallback(content, 1);
  352.     return this.storageEngine_.remove('manifest', manifestId);
  353.   }.bind(this));
  354. };
  357. /**
  358.  * Lists all the stored content available.
  359.  *
  360.  * @return {!Promise.<!Array.<shakaExtern.StoredContent>>}  A Promise to an
  361.  *   array of structures representing all stored content.  The "offlineUri"
  362.  *   member of the structure is the URI that should be given to Player.load()
  363.  *   to play this piece of content offline.  The "appMetadata" member is the
  364.  *   appMetadata argument you passed to store().
  365.  * @export
  366.  */
  367. shaka.offline.Storage.prototype.list = function() {
  368.   /** @type {!Array.<shakaExtern.StoredContent>} */
  369.   var storedContents = [];
  370.   return this.initIfNeeded_()
  371.       .then(function() {
  372.         this.checkDestroyed_();
  373.         return this.storageEngine_.forEach(
  374.             'manifest', function(/** shakaExtern.ManifestDB */ manifest) {
  375.               storedContents.push(
  376.                   shaka.offline.OfflineUtils.getStoredContent(manifest));
  377.             });
  378.       }.bind(this))
  379.       .then(function() { return storedContents; });
  380. };
  383. /**
  384.  * Loads the given manifest, parses it, and constructs the DrmEngine.  This
  385.  * stops the manifest parser.  This may be replaced by tests.
  386.  *
  387.  * @param {string} manifestUri
  388.  * @param {function(*)} onError
  389.  * @param {!shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  390.  * @return {!Promise.<{
  391.  *   manifest: shakaExtern.Manifest,
  392.  *   drmEngine: !shaka.media.DrmEngine
  393.  * }>}
  394.  */
  395. shaka.offline.Storage.prototype.loadInternal = function(
  396.     manifestUri, onError, opt_manifestParserFactory) {
  398.   var netEngine = /** @type {!shaka.net.NetworkingEngine} */ (
  399.       this.player_.getNetworkingEngine());
  400.   var config = this.player_.getConfiguration();
  402.   /** @type {shakaExtern.Manifest} */
  403.   var manifest;
  404.   /** @type {!shaka.media.DrmEngine} */
  405.   var drmEngine;
  406.   /** @type {!shakaExtern.ManifestParser} */
  407.   var manifestParser;
  409.   var onKeyStatusChange = function() {};
  410.   return shaka.media.ManifestParser
  411.       .getFactory(
  412.           manifestUri, netEngine, config.manifest.retryParameters,
  413.           opt_manifestParserFactory)
  414.       .then(function(factory) {
  415.         this.checkDestroyed_();
  416.         manifestParser = new factory();
  417.         manifestParser.configure(config.manifest);
  419.         var playerInterface = {
  420.           networkingEngine: netEngine,
  421.           filterAllPeriods: this.filterAllPeriods_.bind(this),
  422.           filterNewPeriod: this.filterPeriod_.bind(this),
  423.           onTimelineRegionAdded: function() {},
  424.           onEvent: function() {},
  425.           onError: onError
  426.         };
  427.         return manifestParser.start(manifestUri, playerInterface);
  428.       }.bind(this))
  429.       .then(function(data) {
  430.         this.checkDestroyed_();
  431.         manifest = data;
  432.         drmEngine = new shaka.media.DrmEngine({
  433.           netEngine: netEngine,
  434.           onError: onError,
  435.           onKeyStatus: onKeyStatusChange,
  436.           onExpirationUpdated: function() {},
  437.           onEvent: function() {}
  438.         });
  439.         drmEngine.configure(config.drm);
  440.         var isOffline = this.config_.usePersistentLicense || false;
  441.         return drmEngine.init(manifest, isOffline);
  442.       }.bind(this))
  443.       .then(function() {
  444.         this.checkDestroyed_();
  445.         return this.createSegmentIndex_(manifest);
  446.       }.bind(this))
  447.       .then(function() {
  448.         this.checkDestroyed_();
  449.         return drmEngine.createOrLoad();
  450.       }.bind(this))
  451.       .then(function() {
  452.         this.checkDestroyed_();
  453.         return manifestParser.stop();
  454.       }.bind(this))
  455.       .then(function() {
  456.         this.checkDestroyed_();
  457.         return {manifest: manifest, drmEngine: drmEngine};
  458.       }.bind(this))
  459.       .catch(function(error) {
  460.         if (manifestParser)
  461.           return manifestParser.stop().then(function() { throw error; });
  462.         else
  463.           throw error;
  464.       });
  465. };
  468. /**
  469.  * The default track selection function.
  470.  *
  471.  * @param {!Array.<shakaExtern.Track>} tracks
  472.  * @return {!Array.<shakaExtern.Track>}
  473.  * @private
  474.  */
  475. shaka.offline.Storage.prototype.defaultTrackSelect_ = function(tracks) {
  476.   var LanguageUtils = shaka.util.LanguageUtils;
  477.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  479.   var selectedTracks = [];
  481.   // Select variants with best language match.
  482.   var audioLangPref = LanguageUtils.normalize(
  483.       this.player_.getConfiguration().preferredAudioLanguage);
  484.   var matchTypes = [
  485.     LanguageUtils.MatchType.EXACT,
  486.     LanguageUtils.MatchType.BASE_LANGUAGE_OKAY,
  487.     LanguageUtils.MatchType.OTHER_SUB_LANGUAGE_OKAY
  488.   ];
  489.   var allVariantTracks =
  490.       tracks.filter(function(track) { return track.type == 'variant'; });
  491.   // For each match type, get the tracks that match the audio preference for
  492.   // that match type.
  493.   var tracksByMatchType = matchTypes.map(function(match) {
  494.     return allVariantTracks.filter(function(track) {
  495.       var lang = LanguageUtils.normalize(track.language);
  496.       return LanguageUtils.match(match, audioLangPref, lang);
  497.     });
  498.   });
  500.   // Find the best match type that has any matches.
  501.   var variantTracks;
  502.   for (var i = 0; i < tracksByMatchType.length; i++) {
  503.     if (tracksByMatchType[i].length) {
  504.       variantTracks = tracksByMatchType[i];
  505.       break;
  506.     }
  507.   }
  509.   // Fall back to "primary" audio tracks, if present.
  510.   if (!variantTracks) {
  511.     var primaryTracks = allVariantTracks.filter(function(track) {
  512.       return track.primary;
  513.     });
  514.     if (primaryTracks.length)
  515.       variantTracks = primaryTracks;
  516.   }
  518.   // Otherwise, there is no good way to choose the language, so we don't choose
  519.   // a language at all.
  520.   if (!variantTracks) {
  521.     variantTracks = allVariantTracks;
  522.     // Issue a warning, but only if the content has multiple languages.
  523.     // Otherwise, this warning would just be noise.
  524.     var languages = allVariantTracks
  525.         .map(function(track) { return track.language; })
  526.         .filter(shaka.util.Functional.isNotDuplicate);
  527.     if (languages.length > 1) {
  528.       shaka.log.warning('Could not choose a good audio track based on ' +
  529.                         'language preferences or primary tracks.  An ' +
  530.                         'arbitrary language will be stored!');
  531.     }
  532.   }
  534.   // From previously selected variants, choose the SD ones (height <= 480).
  535.   var tracksByHeight = variantTracks.filter(function(track) {
  536.     return track.height && track.height <= 480;
  537.   });
  539.   // If variants don't have video or no video with height <= 480 was
  540.   // found, proceed with the previously selected tracks.
  541.   if (tracksByHeight.length) {
  542.     // Sort by resolution, then select all variants which match the height
  543.     // of the highest SD res.  There may be multiple audio bitrates for the
  544.     // same video resolution.
  545.     tracksByHeight.sort(function(a, b) { return b.height - a.height; });
  546.     variantTracks = tracksByHeight.filter(function(track) {
  547.       return track.height == tracksByHeight[0].height;
  548.     });
  549.   }
  551.   // Now sort by bandwidth.
  552.   variantTracks.sort(function(a, b) { return a.bandwidth - b.bandwidth; });
  554.   // In case there are multiple matches at different audio bitrates, select the
  555.   // middle bandwidth one.
  556.   if (variantTracks.length)
  557.     selectedTracks.push(variantTracks[Math.floor(variantTracks.length / 2)]);
  559.   // Since this default callback is used primarily by our own demo app and by
  560.   // app developers who haven't thought about which tracks they want, we should
  561.   // select all text tracks, regardless of language.  This makes for a better
  562.   // demo for us, and does not rely on user preferences for the unconfigured
  563.   // app.
  564.   selectedTracks.push.apply(selectedTracks, tracks.filter(function(track) {
  565.     return track.type == ContentType.TEXT;
  566.   }));
  568.   return selectedTracks;
  569. };
  572. /**
  573.  * @return {shakaExtern.OfflineConfiguration}
  574.  * @private
  575.  */
  576. shaka.offline.Storage.prototype.defaultConfig_ = function() {
  577.   return {
  578.     trackSelectionCallback: this.defaultTrackSelect_.bind(this),
  579.     progressCallback: function(storedContent, percent) {
  580.       // Reference arguments to keep closure from removing it.
  581.       // If the argument is removed, it breaks our function length check
  582.       // in mergeConfigObjects_().
  583.       // NOTE: Chrome App Content Security Policy prohibits usage of new
  584.       // Function().
  585.       if (storedContent || percent) return null;
  586.     },
  587.     usePersistentLicense: true
  588.   };
  589. };
  592. /**
  593.  * Initializes the IStorageEngine if it is not already.
  594.  *
  595.  * @return {!Promise}
  596.  * @private
  597.  */
  598. shaka.offline.Storage.prototype.initIfNeeded_ = function() {
  599.   if (!this.storageEngine_) {
  600.     return Promise.reject(new shaka.util.Error(
  601.         shaka.util.Error.Severity.CRITICAL,
  602.         shaka.util.Error.Category.STORAGE,
  603.         shaka.util.Error.Code.STORAGE_NOT_SUPPORTED));
  604.   } else if (this.storageEngine_.initialized()) {
  605.     return Promise.resolve();
  606.   } else {
  607.     var scheme = shaka.offline.OfflineUtils.DB_SCHEME;
  608.     return this.storageEngine_.init(scheme);
  609.   }
  610. };
  613. /**
  614.  * @param {!Array.<shakaExtern.Period>} periods
  615.  * @private
  616.  */
  617. shaka.offline.Storage.prototype.filterAllPeriods_ = function(periods) {
  618.   periods.forEach(this.filterPeriod_.bind(this));
  619. };
  622. /**
  623.  * @param {shakaExtern.Period} period
  624.  * @private
  625.  */
  626. shaka.offline.Storage.prototype.filterPeriod_ = function(period) {
  627.   var StreamUtils = shaka.util.StreamUtils;
  628.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  629.   var activeStreams = {};
  630.   if (this.firstPeriodTracks_) {
  631.     var variantTracks = this.firstPeriodTracks_.filter(function(track) {
  632.       return track.type == 'variant';
  633.     });
  634.     var variant = null;
  635.     if (variantTracks.length)
  636.       variant = StreamUtils.findVariantForTrack(period, variantTracks[0]);
  638.     if (variant) {
  639.       // Use the first variant as the container of "active streams".  This
  640.       // is then used to filter out the streams that are not compatible with it.
  641.       // This ensures that in multi-Period content, all Periods have streams
  642.       // with compatible MIME types.
  643.       if (variant.video) activeStreams[ContentType.VIDEO] = variant.video;
  644.       if (variant.audio) activeStreams[ContentType.AUDIO] = variant.audio;
  645.     }
  646.   }
  647.   StreamUtils.filterNewPeriod(this.drmEngine_, activeStreams, period);
  648.   StreamUtils.applyRestrictions(
  649.       period, this.player_.getConfiguration().restrictions,
  650.       /* maxHwRes */ { width: Infinity, height: Infinity });
  651. };
  654. /**
  655.  * Cleans up the current store and destroys any objects.  This object is still
  656.  * usable after this.
  657.  *
  658.  * @return {!Promise}
  659.  * @private
  660.  */
  661. shaka.offline.Storage.prototype.cleanup_ = function() {
  662.   var ret = this.drmEngine_ ? this.drmEngine_.destroy() : Promise.resolve();
  663.   this.drmEngine_ = null;
  664.   this.manifest_ = null;
  665.   this.storeInProgress_ = false;
  666.   this.firstPeriodTracks_ = null;
  667.   this.manifestId_ = -1;
  668.   return ret;
  669. };
  672. /**
  673.  * Calls createSegmentIndex for all streams in the manifest.
  674.  *
  675.  * @param {shakaExtern.Manifest} manifest
  676.  * @return {!Promise}
  677.  * @private
  678.  */
  679. shaka.offline.Storage.prototype.createSegmentIndex_ = function(manifest) {
  680.   var Functional = shaka.util.Functional;
  681.   var streams = manifest.periods
  682.       .map(function(period) { return period.variants; })
  683.       .reduce(Functional.collapseArrays, [])
  684.       .map(function(variant) {
  685.         var variantStreams = [];
  686.         if (variant.audio) variantStreams.push(variant.audio);
  687.         if (variant.video) variantStreams.push(variant.video);
  688.         return variantStreams;
  689.       })
  690.       .reduce(Functional.collapseArrays, [])
  691.       .filter(Functional.isNotDuplicate);
  693.   var textStreams = manifest.periods
  694.       .map(function(period) { return period.textStreams; })
  695.       .reduce(Functional.collapseArrays, []);
  697.   streams.push.apply(streams, textStreams);
  698.   return Promise.all(
  699.       streams.map(function(stream) { return stream.createSegmentIndex(); }));
  700. };
  703. /**
  704.  * Creates an offline 'manifest' for the real manifest.  This does not store
  705.  * the segments yet, only adds them to the download manager through
  706.  * createPeriod_.
  707.  *
  708.  * @param {string} originalManifestUri
  709.  * @param {!Object} appMetadata
  710.  * @return {shakaExtern.ManifestDB}
  711.  * @private
  712.  */
  713. shaka.offline.Storage.prototype.createOfflineManifest_ = function(
  714.     originalManifestUri, appMetadata) {
  715.   var periods = this.manifest_.periods.map(this.createPeriod_.bind(this));
  716.   var drmInfo = this.drmEngine_.getDrmInfo();
  717.   var sessions = this.drmEngine_.getSessionIds();
  719.   if (drmInfo && this.config_.usePersistentLicense) {
  720.     if (!sessions.length) {
  721.       throw new shaka.util.Error(
  722.           shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.STORAGE,
  723.           shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE, originalManifestUri);
  724.     }
  725.     // Don't store init data since we have stored sessions.
  726.     drmInfo.initData = [];
  727.   }
  729.   return {
  730.     key: this.manifestId_,
  731.     originalManifestUri: originalManifestUri,
  732.     duration: this.duration_,
  733.     size: 0,
  734.     expiration: this.drmEngine_.getExpiration(),
  735.     periods: periods,
  736.     sessionIds: this.config_.usePersistentLicense ? sessions : [],
  737.     drmInfo: drmInfo,
  738.     appMetadata: appMetadata
  739.   };
  740. };
  743. /**
  744.  * Converts a manifest Period to a database Period.  This will use the current
  745.  * configuration to get the tracks to use, then it will search each segment
  746.  * index and add all the segments to the download manager through createStream_.
  747.  *
  748.  * @param {shakaExtern.Period} period
  749.  * @return {shakaExtern.PeriodDB}
  750.  * @private
  751.  */
  752. shaka.offline.Storage.prototype.createPeriod_ = function(period) {
  753.   var StreamUtils = shaka.util.StreamUtils;
  755.   var variantTracks = StreamUtils.getVariantTracks(period, null, null);
  756.   var textTracks = StreamUtils.getTextTracks(period, null);
  757.   var allTracks = variantTracks.concat(textTracks);
  759.   var chosenTracks = this.config_.trackSelectionCallback(allTracks);
  761.   if (this.firstPeriodTracks_ == null) {
  762.     this.firstPeriodTracks_ = chosenTracks;
  763.     // Now that the first tracks are chosen, filter again.  This ensures all
  764.     // Periods have compatible content types.
  765.     this.filterAllPeriods_(this.manifest_.periods);
  766.   }
  768.   for (var i = chosenTracks.length - 1; i > 0; --i) {
  769.     var foundSimilarTracks = false;
  770.     for (var j = i - 1; j >= 0; --j) {
  771.       if (chosenTracks[i].type == chosenTracks[j].type &&
  772.           chosenTracks[i].kind == chosenTracks[j].kind &&
  773.           chosenTracks[i].language == chosenTracks[j].language) {
  774.         shaka.log.warning(
  775.             'Multiple tracks of the same type/kind/language given.');
  776.         foundSimilarTracks = true;
  777.         break;
  778.       }
  779.     }
  780.     if (foundSimilarTracks) break;
  781.   }
  783.   var streams = [];
  785.   for (var i = 0; i < chosenTracks.length; i++) {
  786.     var variant = StreamUtils.findVariantForTrack(period, chosenTracks[i]);
  787.     if (variant) {
  788.       // Make a rough estimation of the streams' bandwidth so download manager
  789.       // can track the progress of the download.
  790.       var bandwidthEstimation;
  791.       if (variant.audio) {
  792.         // If the audio stream has already been added to the DB
  793.         // as part of another variant, add the ID to the list.
  794.         // Otherwise, add it to the DB.
  795.         var stream = streams.filter(function(s) {
  796.           return s.id == variant.audio.id;
  797.         })[0];
  798.         if (stream) {
  799.           stream.variantIds.push(variant.id);
  800.         } else {
  801.           // If variant has both audio and video, roughly estimate them
  802.           // both to be 1/2 of the variant's bandwidth.
  803.           // If variant only has one stream, it's bandwidth equals to
  804.           // the bandwidth of the variant.
  805.           bandwidthEstimation =
  806.               variant.video ? variant.bandwidth / 2 : variant.bandwidth;
  807.           streams.push(this.createStream_(period,
  808.                                           variant.audio,
  809.                                           bandwidthEstimation,
  810.                                           variant.id));
  811.         }
  812.       }
  813.       if (variant.video) {
  814.         var stream = streams.filter(function(s) {
  815.           return s.id == variant.video.id;
  816.         })[0];
  817.         if (stream) {
  818.           stream.variantIds.push(variant.id);
  819.         } else {
  820.           bandwidthEstimation =
  821.               variant.audio ? variant.bandwidth / 2 : variant.bandwidth;
  822.           streams.push(this.createStream_(period,
  823.                                           variant.video,
  824.                                           bandwidthEstimation,
  825.                                           variant.id));
  826.         }
  827.       }
  828.     } else {
  829.       var textStream =
  830.           StreamUtils.findTextStreamForTrack(period, chosenTracks[i]);
  831.       goog.asserts.assert(
  832.           textStream, 'Could not find track with id ' + chosenTracks[i].id);
  833.       streams.push(this.createStream_(
  834.           period, textStream, 0 /* estimatedStreamBandwidth */));
  835.     }
  836.   }
  838.   return {
  839.     startTime: period.startTime,
  840.     streams: streams
  841.   };
  842. };
  845. /**
  846.  * Converts a manifest stream to a database stream.  This will search the
  847.  * segment index and add all the segments to the download manager.
  848.  *
  849.  * @param {shakaExtern.Period} period
  850.  * @param {shakaExtern.Stream} stream
  851.  * @param {number} estimatedStreamBandwidth
  852.  * @param {number=} opt_variantId
  853.  * @return {shakaExtern.StreamDB}
  854.  * @private
  855.  */
  856. shaka.offline.Storage.prototype.createStream_ = function(
  857.     period, stream, estimatedStreamBandwidth, opt_variantId) {
  858.   /** @type {!Array.<shakaExtern.SegmentDB>} */
  859.   var segmentsDb = [];
  860.   var startTime =
  861.       this.manifest_.presentationTimeline.getSegmentAvailabilityStart();
  862.   var endTime = startTime;
  863.   var i = stream.findSegmentPosition(startTime);
  864.   var ref = (i != null ? stream.getSegmentReference(i) : null);
  865.   while (ref) {
  866.     var id = this.storageEngine_.reserveId('segment');
  867.     var bandwidthSize =
  868.         (ref.endTime - ref.startTime) * estimatedStreamBandwidth / 8;
  870.     /** @type {shakaExtern.SegmentDataDB} */
  871.     var segmentDataDb = {
  872.       key: id,
  873.       data: null,
  874.       manifestKey: this.manifestId_,
  875.       streamNumber: stream.id,
  876.       segmentNumber: id
  877.     };
  878.     this.downloadManager_.addSegment(
  879.         stream.type, ref, bandwidthSize, segmentDataDb);
  881.     segmentsDb.push({
  882.       startTime: ref.startTime,
  883.       endTime: ref.endTime,
  884.       uri: 'offline:' + this.manifestId_ + '/' + stream.id + '/' + id
  885.     });
  887.     endTime = ref.endTime + period.startTime;
  888.     ref = stream.getSegmentReference(++i);
  889.   }
  891.   this.duration_ = Math.max(this.duration_, (endTime - startTime));
  892.   var initUri = null;
  893.   if (stream.initSegmentReference) {
  894.     var id = this.storageEngine_.reserveId('segment');
  895.     initUri = 'offline:' + this.manifestId_ + '/' + stream.id + '/' + id;
  897.     /** @type {shakaExtern.SegmentDataDB} */
  898.     var initDataDb = {
  899.       key: id,
  900.       data: null,
  901.       manifestKey: this.manifestId_,
  902.       streamNumber: stream.id,
  903.       segmentNumber: -1
  904.     };
  906.     this.downloadManager_.addSegment(
  907.         stream.contentType, stream.initSegmentReference, 0, initDataDb);
  908.   }
  910.   var variantIds = [];
  911.   if (opt_variantId != null) variantIds.push(opt_variantId);
  913.   return {
  914.     id: stream.id,
  915.     primary: stream.primary,
  916.     presentationTimeOffset: stream.presentationTimeOffset || 0,
  917.     contentType: stream.type,
  918.     mimeType: stream.mimeType,
  919.     codecs: stream.codecs,
  920.     frameRate: stream.frameRate,
  921.     kind: stream.kind,
  922.     language: stream.language,
  923.     label: stream.label,
  924.     width: stream.width || null,
  925.     height: stream.height || null,
  926.     initSegmentUri: initUri,
  927.     encrypted: stream.encrypted,
  928.     keyId: stream.keyId,
  929.     segments: segmentsDb,
  930.     variantIds: variantIds
  931.   };
  932. };
  935. /**
  936.  * Throws an error if the object is destroyed.
  937.  * @private
  938.  */
  939. shaka.offline.Storage.prototype.checkDestroyed_ = function() {
  940.   if (!this.player_) {
  941.     throw new shaka.util.Error(
  942.         shaka.util.Error.Severity.CRITICAL,
  943.         shaka.util.Error.Category.STORAGE,
  944.         shaka.util.Error.Code.OPERATION_ABORTED);
  945.   }
  946. };
  949. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);