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 shaka.externs V2 offline
  30.  * types. This storage cell will only work for version 1 indexed db database
  31.  * schemes.
  32.  *
  33.  * @implements {shaka.extern.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 {shaka.extern.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.<shaka.extern.PeriodDB>,
  279.     //   sessionIds: !Array.<string>,
  280.     //   drmInfo: ?shaka.extern.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 {shaka.extern.PeriodDB}
  320.    * @private
  321.    */
  322.   static convertPeriod_(old) {
  323.     // Old Period Format:
  324.     // {
  325.     //   startTime: number,
  326.     //   streams: !Array.<shaka.extern.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 {shaka.extern.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.<shaka.extern.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.       originalId: null,
  424.       primary: old.primary,
  425.       presentationTimeOffset: old.presentationTimeOffset,
  426.       contentType: old.contentType,
  427.       mimeType: old.mimeType,
  428.       codecs: old.codecs,
  429.       frameRate: old.frameRate,
  430.       kind: old.kind,
  431.       language: old.language,
  432.       label: old.label,
  433.       width: old.width,
  434.       height: old.height,
  435.       initSegmentKey: initSegmentKey,
  436.       encrypted: old.encrypted,
  437.       keyId: old.keyId,
  438.       segments: old.segments.map(convertSegment),
  439.       variantIds: old.variantIds,
  440.     };
  441.   }
  443.   /**
  444.    * @param {!Object} old
  445.    * @return {shaka.extern.SegmentDB}
  446.    * @private
  447.    */
  448.   static convertSegment_(old) {
  449.     // Old Segment Format
  450.     // {
  451.     //   startTime: number,
  452.     //   endTime: number,
  453.     //   uri: string
  454.     // }
  456.     goog.asserts.assert(
  457.         old.startTime != null,
  458.         'The old segment format should have a start time field');
  459.     goog.asserts.assert(
  460.         old.endTime != null,
  461.         'The old segment format should have an end time field');
  462.     goog.asserts.assert(
  463.         old.uri != null,
  464.         'The old segment format should have a uri field');
  466.     const V1StorageCell = shaka.offline.indexeddb.V1StorageCell;
  467.     const getKeyFromUri = V1StorageCell.getKeyFromSegmentUri_;
  469.     // Since we don't want to use the uri anymore, we need to parse the key
  470.     // from it.
  471.     let dataKey = getKeyFromUri(old.uri);
  473.     return {
  474.       startTime: old.startTime,
  475.       endTime: old.endTime,
  476.       dataKey: dataKey,
  477.     };
  478.   }
  480.   /**
  481.    * @param {!Object} old
  482.    * @return {shaka.extern.SegmentDataDB}
  483.    * @private
  484.    */
  485.   static convertSegmentData_(old) {
  486.     // Old Segment Format:
  487.     // {
  488.     //   key: number,
  489.     //   data: ArrayBuffer
  490.     // }
  492.     goog.asserts.assert(
  493.         old.key != null,
  494.         'The old segment data format should have a key field');
  495.     goog.asserts.assert(
  496.         old.data != null,
  497.         'The old segment data format should have a data field');
  499.     return {data: old.data};
  500.   }
  502.   /**
  503.    * @param {string} uri
  504.    * @return {number}
  505.    * @private
  506.    */
  507.   static getKeyFromSegmentUri_(uri) {
  508.     let parts = null;
  510.     // Try parsing the uri as the original Shaka Player 2.0 uri.
  511.     parts = /^offline:[0-9]+\/[0-9]+\/([0-9]+)$/.exec(uri);
  512.     if (parts) {
  513.       return Number(parts[1]);
  514.     }
  516.     // Just before Shaka Player 2.3 the uri format was changed to remove some
  517.     // of the un-used information from the uri and make the segment uri and
  518.     // manifest uri follow a similar format. However the old storage system
  519.     // was still in place, so it is possible for Storage V1 Cells to have
  520.     // Storage V2 uris.
  521.     parts = /^offline:segment\/([0-9]+)$/.exec(uri);
  522.     if (parts) {
  523.       return Number(parts[1]);
  524.     }
  526.     throw new shaka.util.Error(
  527.         shaka.util.Error.Severity.CRITICAL,
  528.         shaka.util.Error.Category.STORAGE,
  529.         shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  530.         'Could not parse uri ' + uri);
  531.   }
  533.   /**
  534.    * Take a period and check if the streams need to have variants generated.
  535.    * Before Shaka Player moved to its variants model, there were no variants.
  536.    * This will fill missing variants into the given object.
  537.    *
  538.    * @param {!Object} period
  539.    * @private
  540.    */
  541.   static fillMissingVariants_(period) {
  542.     const AUDIO = shaka.util.ManifestParserUtils.ContentType.AUDIO;
  543.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  545.     // There are three cases:
  546.     //  1. All streams' variant ids are null
  547.     //  2. All streams' variant ids are non-null
  548.     //  3. Some streams' variant ids are null and other are non-null
  549.     // Case 3 is invalid and should never happen in production.
  551.     let audio = period.streams.filter((s) => s.contentType == AUDIO);
  552.     let video = period.streams.filter((s) => s.contentType == VIDEO);
  554.     // Case 2 - There is nothing we need to do, so let's just get out of here.
  555.     if (audio.every((s) => s.variantIds) && video.every((s) => s.variantIds)) {
  556.       return;
  557.     }
  559.     // Case 3... We don't want to be in case three.
  560.     goog.asserts.assert(
  561.         audio.every((s) => !s.variantIds),
  562.         'Some audio streams have variant ids and some do not.');
  563.     goog.asserts.assert(
  564.         video.every((s) => !s.variantIds),
  565.         'Some video streams have variant ids and some do not.');
  567.     // Case 1 - Populate all the variant ids (putting us back to case 2).
  568.     // Since all the variant ids are null, we need to first make them into
  569.     // valid arrays.
  570.     audio.forEach((s) => { s.variantIds = []; });
  571.     video.forEach((s) => { s.variantIds = []; });
  573.     let nextId = 0;
  575.     // It is not possible in Shaka Player's pre-variant world to have audio-only
  576.     // and video-only content mixed in with audio-video content. So we can
  577.     // assume that there is only audio-only or video-only if one group is empty.
  579.     // Everything is video-only content - so each video stream gets to be its
  580.     // own variant.
  581.     if (video.length && !audio.length) {
  582.       shaka.log.debug('Found video-only content. Creating variants for video.');
  583.       let variantId = nextId++;
  584.       video.forEach((s) => { s.variantIds.push(variantId); });
  585.     }
  587.     // Everything is audio-only content - so each audio stream gets to be its
  588.     // own variant.
  589.     if (!video.length && audio.length) {
  590.       shaka.log.debug('Found audio-only content. Creating variants for audio.');
  591.       let variantId = nextId++;
  592.       audio.forEach((s) => { s.variantIds.push(variantId); });
  593.     }
  595.     // Everything is audio-video content.
  596.     if (video.length && audio.length) {
  597.       shaka.log.debug('Found audio-video content. Creating variants.');
  598.       audio.forEach((a) => {
  599.         video.forEach((v) => {
  600.           let variantId = nextId++;
  601.           a.variantIds.push(variantId);
  602.           v.variantIds.push(variantId);
  603.         });
  604.       });
  605.     }
  606.   }
  607. };