Source: lib/offline/indexeddb/v1_storage_cell.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.indexeddb.V1StorageCell');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.offline.indexeddb.DBConnection');
  23. goog.require('shaka.util.Error');
  24. goog.require('shaka.util.ManifestParserUtils');
  25. goog.require('shaka.util.PublicPromise');
  28. /**
  29.  * The V1StorageCell is for all stores that follow the shakaExterns V2 offline
  30.  * types. This storage cell will only work for version 1 indexed db database
  31.  * schemes.
  32.  *
  33.  * @implements {shakaExtern.StorageCell}
  34.  */
  35. shaka.offline.indexeddb.V1StorageCell = class {
  36.   /**
  37.    * @param {IDBDatabase} connection
  38.    * @param {string} segmentStore
  39.    * @param {string} manifestStore
  40.    */
  41.   constructor(connection, segmentStore, manifestStore) {
  42.     /** @private {!shaka.offline.indexeddb.DBConnection} */
  43.     this.connection_ = new shaka.offline.indexeddb.DBConnection(connection);
  45.     /** @private {string} */
  46.     this.segmentStore_ = segmentStore;
  47.     /** @private {string} */
  48.     this.manifestStore_ = manifestStore;
  49.   }
  51.   /**
  52.    * @override
  53.    */
  54.   destroy() { return this.connection_.destroy(); }
  56.   /**
  57.    * @override
  58.    */
  59.   hasFixedKeySpace() {
  60.     // We do not allow adding new values to V1 databases.
  61.     return true;
  62.   }
  64.   /**
  65.    * @override
  66.    */
  67.   addSegments(segments) { return this.rejectAdd_(this.segmentStore_); }
  69.   /**
  70.    * @override
  71.    */
  72.   removeSegments(keys, onRemove) {
  73.     return this.remove_(this.segmentStore_, keys, onRemove);
  74.   }
  76.   /**
  77.    * @override
  78.    */
  79.   getSegments(keys) {
  80.     const convertSegmentData =
  81.         shaka.offline.indexeddb.V1StorageCell.convertSegmentData_;
  83.     return this.get_(this.segmentStore_, keys).then((segments) => {
  84.       return segments.map(convertSegmentData);
  85.     });
  86.   }
  88.   /**
  89.    * @override
  90.    */
  91.   addManifests(manifests) { return this.rejectAdd_(this.manifestStore_); }
  93.   /**
  94.    * @override
  95.    */
  96.   updateManifestExpiration(key, newExpiration) {
  97.     let op = this.connection_.startReadWriteOperation(this.manifestStore_);
  98.     let store = op.store();
  100.     let p = new shaka.util.PublicPromise();
  102.     store.get(key).onsuccess = (event) => {
  103.       // Make sure a defined value was found. Indexeddb treats "no value found"
  104.       // as a success with an undefined result.
  105.       let manifest = event.target.result;
  107.       // Indexeddb does not fail when you get a value that is not in the
  108.       // database. It will return an undefined value. However, we expect
  109.       // the value to never be null, so something is wrong if we get a
  110.       // falsey value.
  111.       if (manifest) {
  112.         // Since this store's scheme uses in-line keys, we don't need to specify
  113.         // the key with |put|.
  114.         goog.asserts.assert(
  115.             manifest.key == key,
  116.             'With in-line keys, the keys should match');
  118.         manifest.expiration = newExpiration;
  119.         store.put(manifest);
  121.         p.resolve();
  122.       } else {
  123.         p.reject(new shaka.util.Error(
  124.             shaka.util.Error.Severity.CRITICAL,
  125.             shaka.util.Error.Category.STORAGE,
  126.             shaka.util.Error.Code.KEY_NOT_FOUND,
  127.             'Could not find values for ' + key));
  128.       }
  129.     };
  131.     // Only return our promise after the operation completes.
  132.     return op.promise().then(() => p);
  133.   }
  135.   /**
  136.    * @override
  137.    */
  138.   removeManifests(keys, onRemove) {
  139.     return this.remove_(this.manifestStore_, keys, onRemove);
  140.   }
  142.   /**
  143.    * @override
  144.    */
  145.   getManifests(keys) {
  146.     const convertManifest =
  147.         shaka.offline.indexeddb.V1StorageCell.convertManifest_;
  149.     return this.get_(this.manifestStore_, keys).then((manifests) => {
  150.       return manifests.map(convertManifest);
  151.     });
  152.   }
  154.   /**
  155.    * @override
  156.    */
  157.   getAllManifests() {
  158.     const convertManifest =
  159.         shaka.offline.indexeddb.V1StorageCell.convertManifest_;
  161.     let op = this.connection_.startReadOnlyOperation(this.manifestStore_);
  162.     let store = op.store();
  164.     let values = {};
  166.     store.openCursor().onsuccess = (event) => {
  167.       // When we reach the end of the data that the cursor is iterating
  168.       // over, |event.target.result| will be null to signal the end of the
  169.       // iteration.
  170.       // https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor/continue
  171.       let cursor = event.target.result;
  172.       if (!cursor) {
  173.         return;
  174.       }
  176.       values[cursor.key] = convertManifest(cursor.value);
  178.       // Go to the next item in the store, which will cause |onsuccess| to be
  179.       // called again.
  180.       cursor.continue();
  181.     };
  183.     // Wait until the operation completes or else values may be missing from
  184.     // |values|.
  185.     return op.promise().then(() => values);
  186.   }
  188.   /**
  189.    * @param {string} storeName
  190.    * @return {!Promise}
  191.    * @private
  192.    */
  193.   rejectAdd_(storeName) {
  194.     return Promise.reject(new shaka.util.Error(
  195.       shaka.util.Error.Severity.CRITICAL,
  196.       shaka.util.Error.Category.STORAGE,
  197.       shaka.util.Error.Code.NEW_KEY_OPERATION_NOT_SUPPORTED,
  198.       'Cannot add new value to ' + storeName));
  199.   }
  201.   /**
  202.    * @param {string} storeName
  203.    * @param {!Array.<number>} keys
  204.    * @param {function(number)} onRemove
  205.    * @return {!Promise}
  206.    * @private
  207.    */
  208.   remove_(storeName, keys, onRemove) {
  209.     let op = this.connection_.startReadWriteOperation(storeName);
  210.     let store = op.store();
  212.     keys.forEach((key) => {
  213.       store.delete(key).onsuccess = () => onRemove(key);
  214.     });
  216.     return op.promise();
  217.   }
  219.   /**
  220.    * @param {string} storeName
  221.    * @param {!Array.<number>} keys
  222.    * @return {!Promise.<!Array.<T>>}
  223.    * @template T
  224.    * @private
  225.    */
  226.   get_(storeName, keys) {
  227.     let op = this.connection_.startReadOnlyOperation(storeName);
  228.     let store = op.store();
  230.     let values = {};
  231.     let missing = [];
  233.     // Use a map to store the objects so that we can reorder the results to
  234.     // match the order of |keys|.
  235.     keys.forEach((key) => {
  236.       store.get(key).onsuccess = (event) => {
  237.         let value = event.target.result;
  238.         // Make sure a defined value was found. Indexeddb treats no-value found
  239.         // as a success with an undefined result.
  240.         if (value == undefined) {
  241.           missing.push(key);
  242.         }
  244.         values[key] = value;
  245.       };
  246.     });
  248.     // Wait until the operation completes or else values may be missing from
  249.     // |values|. Use the original key list to convert the map to a list so that
  250.     // the order will match.
  251.     return op.promise().then(() => {
  252.       if (missing.length) {
  253.         return Promise.reject(new shaka.util.Error(
  254.             shaka.util.Error.Severity.CRITICAL,
  255.             shaka.util.Error.Category.STORAGE,
  256.             shaka.util.Error.Code.KEY_NOT_FOUND,
  257.             'Could not find values for ' + missing
  258.         ));
  259.       }
  261.       return keys.map((key) => values[key]);
  262.     });
  263.   }
  265.   /**
  266.    * @param {!Object} old
  267.    * @return {shakaExtern.ManifestDB}
  268.    * @private
  269.    */
  270.   static convertManifest_(old) {
  271.     // Old Manifest Format:
  272.     // {
  273.     //   key: number,
  274.     //   originalManifestUri: string,
  275.     //   duration: number,
  276.     //   size: number,
  277.     //   expiration: number,
  278.     //   periods: !Array.<shakaExtern.PeriodDB>,
  279.     //   sessionIds: !Array.<string>,
  280.     //   drmInfo: ?shakaExtern.DrmInfo,
  281.     //   appMetadata: Object
  282.     //  }
  284.     goog.asserts.assert(
  285.         old.originalManifestUri != null,
  286.         'Old manifest format should have an originalManifestUri field');
  287.     goog.asserts.assert(
  288.         old.duration != null,
  289.         'Old manifest format should have a duration field');
  290.     goog.asserts.assert(
  291.         old.size != null,
  292.         'Old manifest format should have a size field');
  293.     goog.asserts.assert(
  294.         old.periods != null,
  295.         'Old manifest format should have a periods field');
  296.     goog.asserts.assert(
  297.         old.sessionIds != null,
  298.         'Old manifest format should have a session ids field');
  299.     goog.asserts.assert(
  300.         old.appMetadata != null,
  301.         'Old manifest format should have an app metadata field');
  303.     const convertPeriod = shaka.offline.indexeddb.V1StorageCell.convertPeriod_;
  305.     return {
  306.       originalManifestUri: old.originalManifestUri,
  307.       duration: old.duration,
  308.       size: old.size,
  309.       expiration: old.expiration == null ? Infinity : old.expiration,
  310.       periods: old.periods.map(convertPeriod),
  311.       sessionIds: old.sessionIds,
  312.       drmInfo: old.drmInfo,
  313.       appMetadata: old.appMetadata
  314.     };
  315.   }
  317.   /**
  318.    * @param {!Object} old
  319.    * @return {shakaExtern.PeriodDB}
  320.    * @private
  321.    */
  322.   static convertPeriod_(old) {
  323.     // Old Period Format:
  324.     // {
  325.     //   startTime: number,
  326.     //   streams: !Array.<shakaExtern.StreamDB>
  327.     // }
  329.     goog.asserts.assert(
  330.       old.startTime != null,
  331.       'Old period format should have a start time field');
  332.     goog.asserts.assert(
  333.       old.streams != null,
  334.       'Old period format should have a streams field');
  336.     const convertStream = shaka.offline.indexeddb.V1StorageCell.convertStream_;
  337.     const fillMissingVariants =
  338.         shaka.offline.indexeddb.V1StorageCell.fillMissingVariants_;
  340.     // In the case that this is really old (like really old, like dinosaurs
  341.     // roaming the Earth old) there may be no variants, so we need to add those.
  342.     fillMissingVariants(old);
  344.     old.streams.forEach((stream) => {
  345.       const message = 'After filling in missing variants, ' +
  346.                       'each stream should have variant ids';
  347.       goog.asserts.assert(stream.variantIds, message);
  348.     });
  350.     return {
  351.       startTime: old.startTime,
  352.       streams: old.streams.map(convertStream)
  353.     };
  354.   }
  356.   /**
  357.    * @param {!Object} old
  358.    * @return {shakaExtern.StreamDB}
  359.    * @private
  360.    */
  361.   static convertStream_(old) {
  362.     // Old Stream Format
  363.     // {
  364.     //   id: number,
  365.     //   primary: boolean,
  366.     //   presentationTimeOffset: number,
  367.     //   contentType: string,
  368.     //   mimeType: string,
  369.     //   codecs: string,
  370.     //   frameRate: (number|undefined),
  371.     //   kind: (string|undefined),
  372.     //   language: string,
  373.     //   label: ?string,
  374.     //   width: ?number,
  375.     //   height: ?number,
  376.     //   initSegmentUri: ?string,
  377.     //   encrypted: boolean,
  378.     //   keyId: ?string,
  379.     //   segments: !Array.<shakaExtern.SegmentDB>,
  380.     //   variantIds: ?Array.<number>
  381.     // }
  383.     goog.asserts.assert(
  384.         old.id != null,
  385.         'Old stream format should have an id field');
  386.     goog.asserts.assert(
  387.         old.primary != null,
  388.         'Old stream format should have a primary field');
  389.     goog.asserts.assert(
  390.         old.presentationTimeOffset != null,
  391.         'Old stream format should have a presentation time offset field');
  392.     goog.asserts.assert(
  393.         old.contentType != null,
  394.         'Old stream format should have a content type field');
  395.     goog.asserts.assert(
  396.         old.mimeType != null,
  397.         'Old stream format should have a mime type field');
  398.     goog.asserts.assert(
  399.         old.codecs != null,
  400.         'Old stream format should have a codecs field');
  401.     goog.asserts.assert(
  402.         old.language != null,
  403.         'Old stream format should have a language field');
  404.     goog.asserts.assert(
  405.         old.encrypted != null,
  406.         'Old stream format should have an encrypted field');
  407.     goog.asserts.assert(
  408.         old.segments != null,
  409.         'Old stream format should have a segments field');
  412.     const getKeyFromUri =
  413.         shaka.offline.indexeddb.V1StorageCell.getKeyFromSegmentUri_;
  414.     const convertSegment =
  415.         shaka.offline.indexeddb.V1StorageCell.convertSegment_;
  417.     let initSegmentKey = old.initSegmentUri ?
  418.                       getKeyFromUri(old.initSegmentUri) :
  419.                       null;
  421.     return {
  422.       id: old.id,
  423.       primary: old.primary,
  424.       presentationTimeOffset: old.presentationTimeOffset,
  425.       contentType: old.contentType,
  426.       mimeType: old.mimeType,
  427.       codecs: old.codecs,
  428.       frameRate: old.frameRate,
  429.       kind: old.kind,
  430.       language: old.language,
  431.       label: old.label,
  432.       width: old.width,
  433.       height: old.height,
  434.       initSegmentKey: initSegmentKey,
  435.       encrypted: old.encrypted,
  436.       keyId: old.keyId,
  437.       segments: old.segments.map(convertSegment),
  438.       variantIds: old.variantIds
  439.     };
  440.   }
  442.   /**
  443.    * @param {!Object} old
  444.    * @return {shakaExtern.SegmentDB}
  445.    * @private
  446.    */
  447.   static convertSegment_(old) {
  448.     // Old Segment Format
  449.     // {
  450.     //   startTime: number,
  451.     //   endTime: number,
  452.     //   uri: string
  453.     // }
  455.     goog.asserts.assert(
  456.         old.startTime != null,
  457.         'The old segment format should have a start time field');
  458.     goog.asserts.assert(
  459.         old.endTime != null,
  460.         'The old segment format should have an end time field');
  461.     goog.asserts.assert(
  462.         old.uri != null,
  463.         'The old segment format should have a uri field');
  465.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  466.     const getKeyFromUri = V1StorageCell.getKeyFromSegmentUri_;
  468.     // Since we don't want to use the uri anymore, we need to parse the key
  469.     // from it.
  470.     let dataKey = getKeyFromUri(old.uri);
  472.     return {
  473.       startTime: old.startTime,
  474.       endTime: old.endTime,
  475.       dataKey: dataKey
  476.     };
  477.   }
  479.   /**
  480.    * @param {!Object} old
  481.    * @return {shakaExtern.SegmentDataDB}
  482.    * @private
  483.    */
  484.   static convertSegmentData_(old) {
  485.     // Old Segment Format:
  486.     // {
  487.     //   key: number,
  488.     //   data: ArrayBuffer
  489.     // }
  491.     goog.asserts.assert(
  492.         old.key != null,
  493.         'The old segment data format should have a key field');
  494.     goog.asserts.assert(
  495.         old.data != null,
  496.         'The old segment data format should have a data field');
  498.     return {data: old.data};
  499.   }
  501.   /**
  502.    * @param {string} uri
  503.    * @return {number}
  504.    * @private
  505.    */
  506.   static getKeyFromSegmentUri_(uri) {
  507.     let parts = null;
  509.     // Try parsing the uri as the original Shaka Player 2.0 uri.
  510.     parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(uri);
  511.     if (parts) {
  512.       return Number(parts[1]);
  513.     }
  515.     // Just before Shaka Player 2.3 the uri format was changed to remove some
  516.     // of the un-used information from the uri and make the segment uri and
  517.     // manifest uri follow a similar format. However the old storage system
  518.     // was still in place, so it is possible for Storage V1 Cells to have
  519.     // Storage V2 uris.
  520.     parts = /^offline:segment\/([0-9]+)$/.exec(uri);
  521.     if (parts) {
  522.       return Number(parts[1]);
  523.     }
  525.     throw new shaka.util.Error(
  526.         shaka.util.Error.Severity.CRITICAL,
  527.         shaka.util.Error.Category.STORAGE,
  528.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  529.         'Could not parse uri ' + uri);
  530.   }
  532.   /**
  533.    * Take a period and check if the streams need to have variants generated.
  534.    * Before Shaka Player moved to its variants model, there were no variants.
  535.    * This will fill missing variants into the given object.
  536.    *
  537.    * @param {!Object} period
  538.    * @private
  539.    */
  540.   static fillMissingVariants_(period) {
  541.     const AUDIO = shaka.util.ManifestParserUtils.ContentType.AUDIO;
  542.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  544.     // There are three cases:
  545.     //  1. All streams' variant ids are null
  546.     //  2. All streams' variant ids are non-null
  547.     //  3. Some streams' variant ids are null and other are non-null
  548.     // Case 3 is invalid and should never happen in production.
  550.     let audio = period.streams.filter((s) => s.contentType == AUDIO);
  551.     let video = period.streams.filter((s) => s.contentType == VIDEO);
  553.     // Case 2 - There is nothing we need to do, so let's just get out of here.
  554.     if (audio.every((s) => s.variantIds) && video.every((s) => s.variantIds)) {
  555.       return;
  556.     }
  558.     // Case 3... We don't want to be in case three.
  559.     goog.asserts.assert(
  560.         audio.every((s) => !s.variantIds),
  561.         'Some audio streams have variant ids and some do not.');
  562.     goog.asserts.assert(
  563.         video.every((s) => !s.variantIds),
  564.         'Some video streams have variant ids and some do not.');
  566.     // Case 1 - Populate all the variant ids (putting us back to case 2).
  567.     // Since all the variant ids are null, we need to first make them into
  568.     // valid arrays.
  569.     audio.forEach((s) => { s.variantIds = []; });
  570.     video.forEach((s) => { s.variantIds = []; });
  572.     let nextId = 0;
  574.     // It is not possible in Shaka Player's pre-variant world to have audio-only
  575.     // and video-only content mixed in with audio-video content. So we can
  576.     // assume that there is only audio-only or video-only if one group is empty.
  578.     // Everything is video-only content - so each video stream gets to be its
  579.     // own variant.
  580.     if (video.length && !audio.length) {
  581.       shaka.log.debug('Found video-only content. Creating variants for video.');
  582.       let variantId = nextId++;
  583.       video.forEach((s) => { s.variantIds.push(variantId); });
  584.     }
  586.     // Everything is audio-only content - so each audio stream gets to be its
  587.     // own variant.
  588.     if (!video.length && audio.length) {
  589.       shaka.log.debug('Found audio-only content. Creating variants for audio.');
  590.       let variantId = nextId++;
  591.       audio.forEach((s) => { s.variantIds.push(variantId); });
  592.     }
  594.     // Everything is audio-video content.
  595.     if (video.length && audio.length) {
  596.       shaka.log.debug('Found audio-video content. Creating variants.');
  597.       audio.forEach((a) => {
  598.         video.forEach((v) => {
  599.           let variantId = nextId++;
  600.           a.variantIds.push(variantId);
  601.           v.variantIds.push(variantId);
  602.         });
  603.       });
  604.     }
  605.   }
  606. };