Source: lib/offline/download_manager.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.DownloadManager');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.net.NetworkingEngine');
  22. goog.require('shaka.offline.OfflineUtils');
  23. goog.require('shaka.util.Error');
  24. goog.require('shaka.util.IDestroyable');
  25. goog.require('shaka.util.MapUtils');
  29. /**
  30.  * This manages downloading segments and notifying the app of progress.
  31.  *
  32.  * @param {shaka.offline.IStorageEngine} storageEngine
  33.  * @param {!shaka.net.NetworkingEngine} netEngine
  34.  * @param {shakaExtern.RetryParameters} retryParams
  35.  * @param {shakaExtern.OfflineConfiguration} config
  36.  *
  37.  * @struct
  38.  * @constructor
  39.  * @implements {shaka.util.IDestroyable}
  40.  */
  41. shaka.offline.DownloadManager = function(
  42.     storageEngine, netEngine, retryParams, config) {
  43.   /**
  44.    * @private {!Object.<
  45.    *     string, !Array.<shaka.offline.DownloadManager.Segment>>}
  46.    */
  47.   this.segments_ = {};
  49.   /**
  50.    * The IDs of the segments that have been stored for an in-progress
  51.    * download().  This is used to cleanup in destroy().
  52.    * @private {!Array.<number>}
  53.    */
  54.   this.storedSegments_ = [];
  56.   /** @private {?shakaExtern.OfflineConfiguration} */
  57.   this.config_ = config;
  59.   /** @private {shaka.offline.IStorageEngine} */
  60.   this.storageEngine_ = storageEngine;
  62.   /** @private {shaka.net.NetworkingEngine} */
  63.   this.netEngine_ = netEngine;
  65.   /** @private {?shakaExtern.RetryParameters} */
  66.   this.retryParams_ = retryParams;
  68.   /** @private {?shakaExtern.ManifestDB} */
  69.   this.manifest_ = null;
  71.   /** @private {Promise} */
  72.   this.promise_ = null;
  74.   /**
  75.    * The total number of bytes for segments that include a byte range.
  76.    * @private {number}
  77.    */
  78.   this.givenBytesTotal_ = 0;
  80.   /**
  81.    * The number of bytes downloaded for segments that include a byte range.
  82.    * @private {number}
  83.    */
  84.   this.givenBytesDownloaded_ = 0;
  86.   /**
  87.    * The total number of bytes estimated based on bandwidth for segments that
  88.    * do not include a byte range.
  89.    * @private {number}
  90.    */
  91.   this.bandwidthBytesTotal_ = 0;
  93.   /**
  94.    * The estimated number of bytes downloaded for segments that do not have
  95.    * a byte range.
  96.    * @private {number}
  97.    */
  98.   this.bandwidthBytesDownloaded_ = 0;
  99. };
  102. /**
  103.  * @typedef {{
  104.  *   uris: !Array.<string>,
  105.  *   startByte: number,
  106.  *   endByte: ?number,
  107.  *   bandwidthSize: number,
  108.  *   segmentDb: shakaExtern.SegmentDataDB
  109.  * }}
  110.  *
  111.  * @property {!Array.<string>} uris
  112.  *   The URIs to download the segment.
  113.  * @property {number} startByte
  114.  *   The byte index the segment starts at.
  115.  * @property {?number} endByte
  116.  *   The byte index the segment ends at, if present.
  117.  * @property {number} bandwidthSize
  118.  *   The size of the segment as estimated by the bandwidth and segment duration.
  119.  * @property {shakaExtern.SegmentDataDB} segmentDb
  120.  *   The data to store in the database.
  121.  */
  122. shaka.offline.DownloadManager.Segment;
  125. /** @override */
  126. shaka.offline.DownloadManager.prototype.destroy = function() {
  127.   var storage = this.storageEngine_;
  128.   var segments = this.storedSegments_;
  129.   var p = this.promise_ || Promise.resolve();
  131.   // Don't try to remove segments if there are none.  That may trigger an error
  132.   // in storage if the DB connection was never created.
  133.   if (segments.length) {
  134.     p = p.then(function() { return storage.removeKeys('segment', segments); });
  135.   }
  137.   // Don't destroy() storageEngine since it is owned by Storage.
  139.   this.segments_ = {};
  140.   this.storedSegments_ = [];
  141.   this.config_ = null;
  142.   this.storageEngine_ = null;
  143.   this.netEngine_ = null;
  144.   this.retryParams_ = null;
  145.   this.manifest_ = null;
  146.   this.promise_ = null;
  147.   return p;
  148. };
  151. /**
  152.  * Adds a segment to the list to be downloaded.
  153.  *
  154.  * @param {string} type
  155.  * @param {!shaka.media.SegmentReference|!shaka.media.InitSegmentReference} ref
  156.  * @param {number} bandwidthSize
  157.  * @param {shakaExtern.SegmentDataDB} segmentDb
  158.  *   The data to store in the database with the data.  The |data| field of this
  159.  *   object will contain the downloaded data.
  160.  */
  161. shaka.offline.DownloadManager.prototype.addSegment = function(
  162.     type, ref, bandwidthSize, segmentDb) {
  163.   this.segments_[type] = this.segments_[type] || [];
  164.   this.segments_[type].push({
  165.     uris: ref.getUris(),
  166.     startByte: ref.startByte,
  167.     endByte: ref.endByte,
  168.     bandwidthSize: bandwidthSize,
  169.     segmentDb: segmentDb
  170.   });
  171. };
  174. /**
  175.  * Downloads all the segments, stores them in the database, and stores the given
  176.  * manifest object.
  177.  *
  178.  * @param {shakaExtern.ManifestDB} manifest
  179.  * @return {!Promise}
  180.  */
  181. shaka.offline.DownloadManager.prototype.downloadAndStore = function(manifest) {
  182.   var MapUtils = shaka.util.MapUtils;
  183.   // Calculate progress estimates.
  184.   this.givenBytesTotal_ = 0;
  185.   this.givenBytesDownloaded_ = 0;
  186.   this.bandwidthBytesTotal_ = 0;
  187.   this.bandwidthBytesDownloaded_ = 0;
  188.   MapUtils.values(this.segments_).forEach(function(segments) {
  189.     segments.forEach(function(segment) {
  190.       if (segment.endByte != null)
  191.         this.givenBytesTotal_ += (segment.endByte - segment.startByte + 1);
  192.       else
  193.         this.bandwidthBytesTotal_ += segment.bandwidthSize;
  194.     }.bind(this));
  195.   }.bind(this));
  197.   this.manifest_ = manifest;
  198.   // Will be updated as we download for segments without a byte-range.
  199.   this.manifest_.size = this.givenBytesTotal_;
  201.   // Create separate download chains for different content types.  This will
  202.   // allow audio and video to be downloaded in parallel.
  203.   var async = MapUtils.values(this.segments_).map(function(segments) {
  204.     var i = 0;
  205.     var downloadNext = (function() {
  206.       if (!this.config_) {
  207.         return Promise.reject(new shaka.util.Error(
  208.             shaka.util.Error.Severity.CRITICAL,
  209.             shaka.util.Error.Category.STORAGE,
  210.             shaka.util.Error.Code.OPERATION_ABORTED));
  211.       }
  212.       if (i >= segments.length) return Promise.resolve();
  213.       var segment = segments[i++];
  214.       return this.downloadSegment_(segment).then(downloadNext);
  215.     }.bind(this));
  216.     return downloadNext();
  217.   }.bind(this));
  218.   this.segments_ = {};
  220.   this.promise_ = Promise.all(async).then(function() {
  221.     return this.storageEngine_.insert('manifest', manifest);
  222.   }.bind(this)).then(function() {
  223.     this.storedSegments_ = [];
  224.   }.bind(this));
  225.   return this.promise_;
  226. };
  229. /**
  230.  * Downloads the given segment and calls the callback.
  231.  *
  232.  * @param {shaka.offline.DownloadManager.Segment} segment
  233.  * @return {!Promise}
  234.  * @private
  235.  */
  236. shaka.offline.DownloadManager.prototype.downloadSegment_ = function(segment) {
  237.   goog.asserts.assert(this.retryParams_,
  238.                       'DownloadManager must not be destroyed');
  239.   var type = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  240.   var request =
  241.       shaka.net.NetworkingEngine.makeRequest(segment.uris, this.retryParams_);
  242.   if (segment.startByte != 0 || segment.endByte != null) {
  243.     var end = segment.endByte == null ? '' : segment.endByte;
  244.     request.headers['Range'] = 'bytes=' + segment.startByte + '-' + end;
  245.   }
  247.   var byteCount;
  248.   return this.netEngine_.request(type, request)
  249.       .then(function(response) {
  250.         if (!this.manifest_) {
  251.           return Promise.reject(new shaka.util.Error(
  252.               shaka.util.Error.Severity.CRITICAL,
  253.               shaka.util.Error.Category.STORAGE,
  254.               shaka.util.Error.Code.OPERATION_ABORTED));
  255.         }
  256.         byteCount = response.data.byteLength;
  258.         this.storedSegments_.push(segment.segmentDb.key);
  259.         segment.segmentDb.data = response.data;
  260.         return this.storageEngine_.insert('segment', segment.segmentDb);
  261.       }.bind(this))
  262.       .then(function() {
  263.         if (!this.manifest_) {
  264.           return Promise.reject(new shaka.util.Error(
  265.               shaka.util.Error.Severity.CRITICAL,
  266.               shaka.util.Error.Category.STORAGE,
  267.               shaka.util.Error.Code.OPERATION_ABORTED));
  268.         }
  269.         if (segment.endByte == null) {
  270.           // We didn't know the size, so it was an estimate.
  271.           this.manifest_.size += byteCount;
  272.           this.bandwidthBytesDownloaded_ += segment.bandwidthSize;
  273.         } else {
  274.           goog.asserts.assert(
  275.               byteCount == (segment.endByte - segment.startByte + 1),
  276.               'Incorrect download size');
  277.           this.givenBytesDownloaded_ += byteCount;
  278.         }
  279.         this.updateProgress_();
  280.       }.bind(this));
  281. };
  284. /**
  285.  * Calls the progress callback.
  286.  * @private
  287.  */
  288. shaka.offline.DownloadManager.prototype.updateProgress_ = function() {
  289.   var progress = (this.givenBytesDownloaded_ + this.bandwidthBytesDownloaded_) /
  290.       (this.givenBytesTotal_ + this.bandwidthBytesTotal_);
  292.   goog.asserts.assert(this.manifest_, 'Must not be destroyed');
  293.   var manifest = shaka.offline.OfflineUtils.getStoredContent(this.manifest_);
  294.   this.config_.progressCallback(manifest, progress);
  295. };