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.manifest_.periods.forEach(this.filterPeriod_.bind(this));
  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, onError, function() {}, function() {});
  303.         drmEngine.configure(this.player_.getConfiguration().drm);
  304.         var isOffline = this.config_.usePersistentLicense || false;
  305.         return drmEngine.init(manifest, isOffline);
  306.       })
  307.   .bind(this)).then(function() {
  308.     return drmEngine.removeSessions(manifestDb.sessionIds);
  309.   }.bind(this)).then(function() {
  310.     return drmEngine.destroy();
  311.   }.bind(this)).then(function() {
  312.     this.checkDestroyed_();
  313.     if (error) throw error;
  314.     var Functional = shaka.util.Functional;
  315.     // Get every segment for every stream in the manifest.
  316.     /** @type {!Array.<number>} */
  317.     var segments = manifestDb.periods.map(function(period) {
  318.       return period.streams.map(function(stream) {
  319.         var segments = stream.segments.map(function(segment) {
  320.           var parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(segment.uri);
  321.           goog.asserts.assert(parts, 'Invalid offline URI');
  322.           return Number(parts[1]);
  323.         });
  324.         if (stream.initSegmentUri) {
  325.           var parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(
  326.               stream.initSegmentUri);
  327.           goog.asserts.assert(parts, 'Invalid offline URI');
  328.           segments.push(Number(parts[1]));
  329.         }
  330.         return segments;
  331.       }).reduce(Functional.collapseArrays, []);
  332.     }).reduce(Functional.collapseArrays, []);
  334.     // Delete all the segments.
  335.     var deleteCount = 0;
  336.     var segmentCount = segments.length;
  337.     var callback = this.config_.progressCallback;
  339.     return this.storageEngine_.removeKeys('segment', segments, function() {
  340.       deleteCount++;
  341.       callback(content, deleteCount / segmentCount);
  342.     });
  344.   }.bind(this)).then(function() {
  345.     this.checkDestroyed_();
  346.     this.config_.progressCallback(content, 1);
  347.     return this.storageEngine_.remove('manifest', manifestId);
  348.   }.bind(this));
  349. };
  352. /**
  353.  * Lists all the stored content available.
  354.  *
  355.  * @return {!Promise.<!Array.<shakaExtern.StoredContent>>}  A Promise to an
  356.  *   array of structures representing all stored content.  The "offlineUri"
  357.  *   member of the structure is the URI that should be given to Player.load()
  358.  *   to play this piece of content offline.  The "appMetadata" member is the
  359.  *   appMetadata argument you passed to store().
  360.  * @export
  361.  */
  362. shaka.offline.Storage.prototype.list = function() {
  363.   /** @type {!Array.<shakaExtern.StoredContent>} */
  364.   var storedContents = [];
  365.   return this.initIfNeeded_()
  366.       .then(function() {
  367.         this.checkDestroyed_();
  368.         return this.storageEngine_.forEach(
  369.             'manifest', function(/** shakaExtern.ManifestDB */ manifest) {
  370.               storedContents.push(
  371.                   shaka.offline.OfflineUtils.getStoredContent(manifest));
  372.             });
  373.       }.bind(this))
  374.       .then(function() { return storedContents; });
  375. };
  378. /**
  379.  * Loads the given manifest, parses it, and constructs the DrmEngine.  This
  380.  * stops the manifest parser.  This may be replaced by tests.
  381.  *
  382.  * @param {string} manifestUri
  383.  * @param {function(*)} onError
  384.  * @param {!shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  385.  * @return {!Promise.<{
  386.  *   manifest: shakaExtern.Manifest,
  387.  *   drmEngine: !shaka.media.DrmEngine
  388.  * }>}
  389.  */
  390. shaka.offline.Storage.prototype.loadInternal = function(
  391.     manifestUri, onError, opt_manifestParserFactory) {
  393.   var netEngine = /** @type {!shaka.net.NetworkingEngine} */ (
  394.       this.player_.getNetworkingEngine());
  395.   var config = this.player_.getConfiguration();
  397.   /** @type {shakaExtern.Manifest} */
  398.   var manifest;
  399.   /** @type {!shaka.media.DrmEngine} */
  400.   var drmEngine;
  401.   /** @type {!shakaExtern.ManifestParser} */
  402.   var manifestParser;
  404.   var onKeyStatusChange = function() {};
  405.   return shaka.media.ManifestParser
  406.       .getFactory(
  407.           manifestUri, netEngine, config.manifest.retryParameters,
  408.           opt_manifestParserFactory)
  409.       .then(function(factory) {
  410.         this.checkDestroyed_();
  411.         manifestParser = new factory();
  412.         manifestParser.configure(config.manifest);
  414.         var playerInterface = {
  415.           networkingEngine: netEngine,
  416.           filterNewPeriod: this.filterPeriod_.bind(this),
  417.           onTimelineRegionAdded: function() {},
  418.           onEvent: function() {},
  419.           onError: onError
  420.         };
  421.         return manifestParser.start(manifestUri, playerInterface);
  422.       }.bind(this))
  423.       .then(function(data) {
  424.         this.checkDestroyed_();
  425.         manifest = data;
  426.         drmEngine = new shaka.media.DrmEngine(
  427.             netEngine, onError, onKeyStatusChange, function() {});
  428.         drmEngine.configure(config.drm);
  429.         var isOffline = this.config_.usePersistentLicense || false;
  430.         return drmEngine.init(manifest, isOffline);
  431.       }.bind(this))
  432.       .then(function() {
  433.         this.checkDestroyed_();
  434.         return this.createSegmentIndex_(manifest);
  435.       }.bind(this))
  436.       .then(function() {
  437.         this.checkDestroyed_();
  438.         return drmEngine.createOrLoad();
  439.       }.bind(this))
  440.       .then(function() {
  441.         this.checkDestroyed_();
  442.         return manifestParser.stop();
  443.       }.bind(this))
  444.       .then(function() {
  445.         this.checkDestroyed_();
  446.         return {manifest: manifest, drmEngine: drmEngine};
  447.       }.bind(this))
  448.       .catch(function(error) {
  449.         if (manifestParser)
  450.           return manifestParser.stop().then(function() { throw error; });
  451.         else
  452.           throw error;
  453.       });
  454. };
  457. /**
  458.  * The default track selection function.
  459.  *
  460.  * @param {!Array.<shakaExtern.Track>} tracks
  461.  * @return {!Array.<shakaExtern.Track>}
  462.  * @private
  463.  */
  464. shaka.offline.Storage.prototype.defaultTrackSelect_ = function(tracks) {
  465.   var LanguageUtils = shaka.util.LanguageUtils;
  466.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  468.   var selectedTracks = [];
  470.   // Select variants with best language match.
  471.   var audioLangPref = LanguageUtils.normalize(
  472.       this.player_.getConfiguration().preferredAudioLanguage);
  473.   var matchTypes = [
  474.     LanguageUtils.MatchType.EXACT,
  475.     LanguageUtils.MatchType.BASE_LANGUAGE_OKAY,
  476.     LanguageUtils.MatchType.OTHER_SUB_LANGUAGE_OKAY
  477.   ];
  478.   var allVariantTracks =
  479.       tracks.filter(function(track) { return track.type == 'variant'; });
  480.   // For each match type, get the tracks that match the audio preference for
  481.   // that match type.
  482.   var tracksByMatchType = matchTypes.map(function(match) {
  483.     return allVariantTracks.filter(function(track) {
  484.       var lang = LanguageUtils.normalize(track.language);
  485.       return LanguageUtils.match(match, audioLangPref, lang);
  486.     });
  487.   });
  489.   // Find the best match type that has any matches.
  490.   var variantTracks;
  491.   for (var i = 0; i < tracksByMatchType.length; i++) {
  492.     if (tracksByMatchType[i].length) {
  493.       variantTracks = tracksByMatchType[i];
  494.       break;
  495.     }
  496.   }
  498.   // Fall back to "primary" audio tracks, if present.
  499.   if (!variantTracks) {
  500.     var primaryTracks = allVariantTracks.filter(function(track) {
  501.       return track.primary;
  502.     });
  503.     if (primaryTracks.length)
  504.       variantTracks = primaryTracks;
  505.   }
  507.   // Otherwise, there is no good way to choose the language, so we don't choose
  508.   // a language at all.
  509.   if (!variantTracks) {
  510.     variantTracks = allVariantTracks;
  511.     // Issue a warning, but only if the content has multiple languages.
  512.     // Otherwise, this warning would just be noise.
  513.     var languages = allVariantTracks
  514.         .map(function(track) { return track.language; })
  515.         .filter(shaka.util.Functional.isNotDuplicate);
  516.     if (languages.length > 1) {
  517.       shaka.log.warning('Could not choose a good audio track based on ' +
  518.                         'language preferences or primary tracks.  An ' +
  519.                         'arbitrary language will be stored!');
  520.     }
  521.   }
  523.   // From previously selected variants, choose the SD ones (height <= 480).
  524.   var tracksByHeight = variantTracks.filter(function(track) {
  525.     return track.height && track.height <= 480;
  526.   });
  528.   // If variants don't have video or no video with height <= 480 was
  529.   // found, proceed with the previously selected tracks.
  530.   if (tracksByHeight.length) {
  531.     // Sort by resolution, then select all variants which match the height
  532.     // of the highest SD res.  There may be multiple audio bitrates for the
  533.     // same video resolution.
  534.     tracksByHeight.sort(function(a, b) { return b.height - a.height; });
  535.     variantTracks = tracksByHeight.filter(function(track) {
  536.       return track.height == tracksByHeight[0].height;
  537.     });
  538.   }
  540.   // Now sort by bandwidth.
  541.   variantTracks.sort(function(a, b) { return a.bandwidth - b.bandwidth; });
  543.   // In case there are multiple matches at different audio bitrates, select the
  544.   // middle bandwidth one.
  545.   if (variantTracks.length)
  546.     selectedTracks.push(variantTracks[Math.floor(variantTracks.length / 2)]);
  548.   // Since this default callback is used primarily by our own demo app and by
  549.   // app developers who haven't thought about which tracks they want, we should
  550.   // select all text tracks, regardless of language.  This makes for a better
  551.   // demo for us, and does not rely on user preferences for the unconfigured
  552.   // app.
  553.   selectedTracks.push.apply(selectedTracks, tracks.filter(function(track) {
  554.     return track.type == ContentType.TEXT;
  555.   }));
  557.   return selectedTracks;
  558. };
  561. /**
  562.  * @return {shakaExtern.OfflineConfiguration}
  563.  * @private
  564.  */
  565. shaka.offline.Storage.prototype.defaultConfig_ = function() {
  566.   return {
  567.     trackSelectionCallback: this.defaultTrackSelect_.bind(this),
  568.     progressCallback: function(storedContent, percent) {
  569.       // Reference arguments to keep closure from removing it.
  570.       // If the argument is removed, it breaks our function length check
  571.       // in mergeConfigObjects_().
  572.       // NOTE: Chrome App Content Security Policy prohibits usage of new
  573.       // Function().
  574.       if (storedContent || percent) return null;
  575.     },
  576.     usePersistentLicense: true
  577.   };
  578. };
  581. /**
  582.  * Initializes the IStorageEngine if it is not already.
  583.  *
  584.  * @return {!Promise}
  585.  * @private
  586.  */
  587. shaka.offline.Storage.prototype.initIfNeeded_ = function() {
  588.   if (!this.storageEngine_) {
  589.     return Promise.reject(new shaka.util.Error(
  590.         shaka.util.Error.Severity.CRITICAL,
  591.         shaka.util.Error.Category.STORAGE,
  592.         shaka.util.Error.Code.STORAGE_NOT_SUPPORTED));
  593.   } else if (this.storageEngine_.initialized()) {
  594.     return Promise.resolve();
  595.   } else {
  596.     var scheme = shaka.offline.OfflineUtils.DB_SCHEME;
  597.     return this.storageEngine_.init(scheme);
  598.   }
  599. };
  602. /**
  603.  * @param {shakaExtern.Period} period
  604.  * @private
  605.  */
  606. shaka.offline.Storage.prototype.filterPeriod_ = function(period) {
  607.   var StreamUtils = shaka.util.StreamUtils;
  608.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  609.   var activeStreams = {};
  610.   if (this.firstPeriodTracks_) {
  611.     var variantTracks = this.firstPeriodTracks_.filter(function(track) {
  612.       return track.type == 'variant';
  613.     });
  614.     var variant = null;
  615.     if (variantTracks.length)
  616.       variant = StreamUtils.findVariantForTrack(period, variantTracks[0]);
  618.     if (variant) {
  619.       // Use the first variant as the container of "active streams".  This
  620.       // is then used to filter out the streams that are not compatible with it.
  621.       // This ensures that in multi-Period content, all Periods have streams
  622.       // with compatible MIME types.
  623.       if (variant.video) activeStreams[ContentType.VIDEO] = variant.video;
  624.       if (variant.audio) activeStreams[ContentType.AUDIO] = variant.audio;
  625.     }
  626.   }
  627.   StreamUtils.filterNewPeriod(this.drmEngine_, activeStreams, period);
  628.   StreamUtils.applyRestrictions(
  629.       period, this.player_.getConfiguration().restrictions,
  630.       /* maxHwRes */ { width: Infinity, height: Infinity });
  631. };
  634. /**
  635.  * Cleans up the current store and destroys any objects.  This object is still
  636.  * usable after this.
  637.  *
  638.  * @return {!Promise}
  639.  * @private
  640.  */
  641. shaka.offline.Storage.prototype.cleanup_ = function() {
  642.   var ret = this.drmEngine_ ? this.drmEngine_.destroy() : Promise.resolve();
  643.   this.drmEngine_ = null;
  644.   this.manifest_ = null;
  645.   this.storeInProgress_ = false;
  646.   this.firstPeriodTracks_ = null;
  647.   this.manifestId_ = -1;
  648.   return ret;
  649. };
  652. /**
  653.  * Calls createSegmentIndex for all streams in the manifest.
  654.  *
  655.  * @param {shakaExtern.Manifest} manifest
  656.  * @return {!Promise}
  657.  * @private
  658.  */
  659. shaka.offline.Storage.prototype.createSegmentIndex_ = function(manifest) {
  660.   var Functional = shaka.util.Functional;
  661.   var streams = manifest.periods
  662.       .map(function(period) { return period.variants; })
  663.       .reduce(Functional.collapseArrays, [])
  664.       .map(function(variant) {
  665.         var variantStreams = [];
  666.         if (variant.audio) variantStreams.push(variant.audio);
  667.         if (variant.video) variantStreams.push(variant.video);
  668.         return variantStreams;
  669.       })
  670.       .reduce(Functional.collapseArrays, [])
  671.       .filter(Functional.isNotDuplicate);
  673.   var textStreams = manifest.periods
  674.       .map(function(period) { return period.textStreams; })
  675.       .reduce(Functional.collapseArrays, []);
  677.   streams.push.apply(streams, textStreams);
  678.   return Promise.all(
  679.       streams.map(function(stream) { return stream.createSegmentIndex(); }));
  680. };
  683. /**
  684.  * Creates an offline 'manifest' for the real manifest.  This does not store
  685.  * the segments yet, only adds them to the download manager through
  686.  * createPeriod_.
  687.  *
  688.  * @param {string} originalManifestUri
  689.  * @param {!Object} appMetadata
  690.  * @return {shakaExtern.ManifestDB}
  691.  * @private
  692.  */
  693. shaka.offline.Storage.prototype.createOfflineManifest_ = function(
  694.     originalManifestUri, appMetadata) {
  695.   var periods = this.manifest_.periods.map(this.createPeriod_.bind(this));
  696.   var drmInfo = this.drmEngine_.getDrmInfo();
  697.   var sessions = this.drmEngine_.getSessionIds();
  698.   if (drmInfo) {
  699.     if (!sessions.length) {
  700.       throw new shaka.util.Error(
  701.           shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.STORAGE,
  702.           shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE, originalManifestUri);
  703.     }
  704.     // Don't store init data since we have stored sessions.
  705.     drmInfo.initData = [];
  706.   }
  708.   return {
  709.     key: this.manifestId_,
  710.     originalManifestUri: originalManifestUri,
  711.     duration: this.duration_,
  712.     size: 0,
  713.     expiration: this.drmEngine_.getExpiration(),
  714.     periods: periods,
  715.     sessionIds: this.config_.usePersistentLicense ? sessions : [],
  716.     drmInfo: drmInfo,
  717.     appMetadata: appMetadata
  718.   };
  719. };
  722. /**
  723.  * Converts a manifest Period to a database Period.  This will use the current
  724.  * configuration to get the tracks to use, then it will search each segment
  725.  * index and add all the segments to the download manager through createStream_.
  726.  *
  727.  * @param {shakaExtern.Period} period
  728.  * @return {shakaExtern.PeriodDB}
  729.  * @private
  730.  */
  731. shaka.offline.Storage.prototype.createPeriod_ = function(period) {
  732.   var StreamUtils = shaka.util.StreamUtils;
  734.   var variantTracks = StreamUtils.getVariantTracks(period, null, null);
  735.   var textTracks = StreamUtils.getTextTracks(period, null);
  736.   var allTracks = variantTracks.concat(textTracks);
  738.   var chosenTracks = this.config_.trackSelectionCallback(allTracks);
  740.   if (this.firstPeriodTracks_ == null) {
  741.     this.firstPeriodTracks_ = chosenTracks;
  742.     // Now that the first tracks are chosen, filter again.  This ensures all
  743.     // Periods have compatible content types.
  744.     this.manifest_.periods.forEach(this.filterPeriod_.bind(this));
  745.   }
  747.   for (var i = chosenTracks.length - 1; i > 0; --i) {
  748.     var foundSimilarTracks = false;
  749.     for (var j = i - 1; j >= 0; --j) {
  750.       if (chosenTracks[i].type == chosenTracks[j].type &&
  751.           chosenTracks[i].kind == chosenTracks[j].kind &&
  752.           chosenTracks[i].language == chosenTracks[j].language) {
  753.         shaka.log.warning(
  754.             'Multiple tracks of the same type/kind/language given.');
  755.         foundSimilarTracks = true;
  756.         break;
  757.       }
  758.     }
  759.     if (foundSimilarTracks) break;
  760.   }
  762.   var streams = [];
  764.   for (var i = 0; i < chosenTracks.length; i++) {
  765.     var variant = StreamUtils.findVariantForTrack(period, chosenTracks[i]);
  766.     if (variant) {
  767.       // Make a rough estimation of the streams' bandwidth so download manager
  768.       // can track the progress of the download.
  769.       var bandwidthEstimation;
  770.       if (variant.audio) {
  771.         // If the audio stream has already been added to the DB
  772.         // as part of another variant, add the ID to the list.
  773.         // Otherwise, add it to the DB.
  774.         var stream = streams.filter(function(s) {
  775.           return s.id == variant.audio.id;
  776.         })[0];
  777.         if (stream) {
  778.           stream.variantIds.push(variant.id);
  779.         } else {
  780.           // If variant has both audio and video, roughly estimate them
  781.           // both to be 1/2 of the variant's bandwidth.
  782.           // If variant only has one stream, it's bandwidth equals to
  783.           // the bandwidth of the variant.
  784.           bandwidthEstimation =
  785.               variant.video ? variant.bandwidth / 2 : variant.bandwidth;
  786.           streams.push(this.createStream_(period,
  787.                                           variant.audio,
  788.                                           bandwidthEstimation,
  789.                                           variant.id));
  790.         }
  791.       }
  792.       if (variant.video) {
  793.         var stream = streams.filter(function(s) {
  794.           return s.id == variant.video.id;
  795.         })[0];
  796.         if (stream) {
  797.           stream.variantIds.push(variant.id);
  798.         } else {
  799.           bandwidthEstimation =
  800.               variant.audio ? variant.bandwidth / 2 : variant.bandwidth;
  801.           streams.push(this.createStream_(period,
  802.                                           variant.video,
  803.                                           bandwidthEstimation,
  804.                                           variant.id));
  805.         }
  806.       }
  807.     } else {
  808.       var textStream =
  809.           StreamUtils.findTextStreamForTrack(period, chosenTracks[i]);
  810.       goog.asserts.assert(
  811.           textStream, 'Could not find track with id ' + chosenTracks[i].id);
  812.       streams.push(this.createStream_(
  813.           period, textStream, 0 /* estimatedStreamBandwidth */));
  814.     }
  815.   }
  817.   return {
  818.     startTime: period.startTime,
  819.     streams: streams
  820.   };
  821. };
  824. /**
  825.  * Converts a manifest stream to a database stream.  This will search the
  826.  * segment index and add all the segments to the download manager.
  827.  *
  828.  * @param {shakaExtern.Period} period
  829.  * @param {shakaExtern.Stream} stream
  830.  * @param {number} estimatedStreamBandwidth
  831.  * @param {number=} opt_variantId
  832.  * @return {shakaExtern.StreamDB}
  833.  * @private
  834.  */
  835. shaka.offline.Storage.prototype.createStream_ = function(
  836.     period, stream, estimatedStreamBandwidth, opt_variantId) {
  837.   /** @type {!Array.<shakaExtern.SegmentDB>} */
  838.   var segmentsDb = [];
  839.   var startTime =
  840.       this.manifest_.presentationTimeline.getSegmentAvailabilityStart();
  841.   var endTime = startTime;
  842.   var i = stream.findSegmentPosition(startTime);
  843.   var ref = (i != null ? stream.getSegmentReference(i) : null);
  844.   while (ref) {
  845.     var id = this.storageEngine_.reserveId('segment');
  846.     var bandwidthSize =
  847.         (ref.endTime - ref.startTime) * estimatedStreamBandwidth / 8;
  849.     /** @type {shakaExtern.SegmentDataDB} */
  850.     var segmentDataDb = {
  851.       key: id,
  852.       data: null,
  853.       manifestKey: this.manifestId_,
  854.       streamNumber: stream.id,
  855.       segmentNumber: id
  856.     };
  857.     this.downloadManager_.addSegment(
  858.         stream.type, ref, bandwidthSize, segmentDataDb);
  860.     segmentsDb.push({
  861.       startTime: ref.startTime,
  862.       endTime: ref.endTime,
  863.       uri: 'offline:' + this.manifestId_ + '/' + stream.id + '/' + id
  864.     });
  866.     endTime = ref.endTime + period.startTime;
  867.     ref = stream.getSegmentReference(++i);
  868.   }
  870.   this.duration_ = Math.max(this.duration_, (endTime - startTime));
  871.   var initUri = null;
  872.   if (stream.initSegmentReference) {
  873.     var id = this.storageEngine_.reserveId('segment');
  874.     initUri = 'offline:' + this.manifestId_ + '/' + stream.id + '/' + id;
  876.     /** @type {shakaExtern.SegmentDataDB} */
  877.     var initDataDb = {
  878.       key: id,
  879.       data: null,
  880.       manifestKey: this.manifestId_,
  881.       streamNumber: stream.id,
  882.       segmentNumber: -1
  883.     };
  885.     this.downloadManager_.addSegment(
  886.         stream.contentType, stream.initSegmentReference, 0, initDataDb);
  887.   }
  889.   var variantIds = [];
  890.   if (opt_variantId != null) variantIds.push(opt_variantId);
  892.   return {
  893.     id: stream.id,
  894.     primary: stream.primary,
  895.     presentationTimeOffset: stream.presentationTimeOffset || 0,
  896.     contentType: stream.type,
  897.     mimeType: stream.mimeType,
  898.     codecs: stream.codecs,
  899.     frameRate: stream.frameRate,
  900.     kind: stream.kind,
  901.     language: stream.language,
  902.     label: stream.label,
  903.     width: stream.width || null,
  904.     height: stream.height || null,
  905.     initSegmentUri: initUri,
  906.     encrypted: stream.encrypted,
  907.     keyId: stream.keyId,
  908.     segments: segmentsDb,
  909.     variantIds: variantIds
  910.   };
  911. };
  914. /**
  915.  * Throws an error if the object is destroyed.
  916.  * @private
  917.  */
  918. shaka.offline.Storage.prototype.checkDestroyed_ = function() {
  919.   if (!this.player_) {
  920.     throw new shaka.util.Error(
  921.         shaka.util.Error.Severity.CRITICAL,
  922.         shaka.util.Error.Category.STORAGE,
  923.         shaka.util.Error.Code.OPERATION_ABORTED);
  924.   }
  925. };
  928. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);