Source: lib/offline/offline_manifest_parser.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.OfflineManifestParser');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.media.ManifestParser');
  23. goog.require('shaka.media.PresentationTimeline');
  24. goog.require('shaka.offline.OfflineUtils');
  25. goog.require('shaka.util.Error');
  29. /**
  30.  * Creates a new offline manifest parser.
  31.  * @struct
  32.  * @constructor
  33.  * @implements {shakaExtern.ManifestParser}
  34.  */
  35. shaka.offline.OfflineManifestParser = function() {
  36.   /** @private {number} */
  37.   this.manifestId_ = -1;
  38. };
  41. /** @override */
  42. shaka.offline.OfflineManifestParser.prototype.configure = function(config) {
  43.   // No-op
  44. };
  47. /** @override */
  48. shaka.offline.OfflineManifestParser.prototype.start =
  49.     function(uri, playerInterface) {
  50.   var parts = /^offline:([0-9]+)$/.exec(uri);
  51.   if (!parts) {
  52.     return Promise.reject(new shaka.util.Error(
  53.         shaka.util.Error.Severity.CRITICAL,
  54.         shaka.util.Error.Category.NETWORK,
  55.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI, uri));
  56.   }
  57.   var manifestId = Number(parts[1]);
  58.   var storageEngine = shaka.offline.OfflineUtils.createStorageEngine();
  59.   this.manifestId_ = manifestId;
  61.   if (!storageEngine) {
  62.     return Promise.reject(new shaka.util.Error(
  63.         shaka.util.Error.Severity.CRITICAL,
  64.         shaka.util.Error.Category.STORAGE,
  65.         shaka.util.Error.Code.STORAGE_NOT_SUPPORTED));
  66.   }
  68.   return storageEngine.init(shaka.offline.OfflineUtils.DB_SCHEME)
  69.       .then(function() { return storageEngine.get('manifest', manifestId); })
  70.       .then(function(manifest) {
  71.         if (!manifest) {
  72.           throw new shaka.util.Error(
  73.               shaka.util.Error.Severity.CRITICAL,
  74.               shaka.util.Error.Category.STORAGE,
  75.               shaka.util.Error.Code.REQUESTED_ITEM_NOT_FOUND, manifestId);
  76.         }
  78.         var OfflineManifestParser = shaka.offline.OfflineManifestParser;
  79.         return OfflineManifestParser.reconstructManifest(manifest);
  80.       })
  81.       .then(
  82.           function(ret) {
  83.             return storageEngine.destroy().then(function() { return ret; });
  84.           },
  85.           function(err) {
  86.             return storageEngine.destroy().then(function() { throw err; });
  87.           });
  88. };
  91. /** @override */
  92. shaka.offline.OfflineManifestParser.prototype.stop = function() {
  93.   return Promise.resolve();
  94. };
  97. /** @override */
  98. shaka.offline.OfflineManifestParser.prototype.update = function() {
  99.   // No-op
  100. };
  103. /** @override */
  104. shaka.offline.OfflineManifestParser.prototype.onExpirationUpdated = function(
  105.     sessionId, expiration) {
  106.   var storageEngine = shaka.offline.OfflineUtils.createStorageEngine();
  107.   goog.asserts.assert(storageEngine, 'Must support offline storage');
  109.   storageEngine.init(shaka.offline.OfflineUtils.DB_SCHEME)
  110.       .then(function() {
  111.         return storageEngine.get('manifest', this.manifestId_);
  112.       }.bind(this))
  113.       .then(function(manifest) {
  114.         if (!manifest) {
  115.           // Manifest was deleted, ignore update.
  116.           return;
  117.         }
  118.         if (manifest.sessionIds.indexOf(sessionId) < 0) {
  119.           shaka.log.debug('Ignoring updated expiration for unknown session');
  120.           return;
  121.         }
  123.         if (manifest.expiration == undefined ||
  124.             manifest.expiration > expiration) {
  125.           shaka.log.debug('Updating expiration for stored content');
  126.           manifest.expiration = expiration;
  127.           return storageEngine.insert('manifest', manifest);
  128.         }
  129.       })
  130.       .catch(function(error) {
  131.         shaka.log.error('Error updating offline manifest expiration', error);
  132.       })
  133.       .then(function() {
  134.         return storageEngine.destroy();
  135.       });
  136. };
  139. /**
  140.  * Reconstructs a manifest object from the given database manifest.
  141.  *
  142.  * @param {shakaExtern.ManifestDB} manifest
  143.  * @return {shakaExtern.Manifest}
  144.  */
  145. shaka.offline.OfflineManifestParser.reconstructManifest = function(manifest) {
  146.   var timeline = new shaka.media.PresentationTimeline(null, 0);
  147.   timeline.setDuration(manifest.duration);
  148.   var drmInfos = manifest.drmInfo ? [manifest.drmInfo] : [];
  149.   return {
  150.     presentationTimeline: timeline,
  151.     minBufferTime: 10,
  152.     offlineSessionIds: manifest.sessionIds,
  153.     periods: manifest.periods.map(function(period) {
  154.       return shaka.offline.OfflineUtils.reconstructPeriod(period,
  155.                                                           drmInfos,
  156.                                                           timeline);
  157.     })
  158.   };
  159. };
  162. shaka.media.ManifestParser.registerParserByMime(
  163.     'application/x-offline-manifest', shaka.offline.OfflineManifestParser);