Source: lib/offline/offline_uri.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.OfflineUri');
  21. /**
  22.  * The OfflineUri class contains all the components that make up the offline
  23.  * uri. The components are:
  24.  *    TYPE: Used to know what type of data the uri points to. It can either
  25.  *          be "manifest" or "segment".
  26.  *    MECHANISM: The name of the mechanism that manages the storage cell that
  27.  *               holds the data.
  28.  *    CELL: The name of the cell that holds the data.
  29.  *    KEY: The key that the data is stored under in the cell.
  30.  */
  31. shaka.offline.OfflineUri = class {
  32.   /**
  33.    * @param {string} type
  34.    * @param {string} mechanism
  35.    * @param {string} cell
  36.    * @param {number} key
  37.    */
  38.   constructor(type, mechanism, cell, key) {
  39.     /**
  40.      * @private {string}
  41.      * @const
  42.      */
  43.     this.type_ = type;
  44.     /**
  45.      * @private {string}
  46.      * @const
  47.      */
  48.     this.mechanism_ = mechanism;
  49.     /**
  50.      * @private {string}
  51.      * @const
  52.      */
  53.     this.cell_ = cell;
  54.     /**
  55.      * @private {number}
  56.      * @const
  57.      */
  58.     this.key_ = key;
  60.     /**
  61.      * @private {string}
  62.      * @const
  63.      */
  64.     this.asString_ = [
  65.       'offline:', type, '/', mechanism, '/', cell, '/', key,
  66.     ].join('');
  67.   }
  69.   /** @return {boolean} */
  70.   isManifest() { return this.type_ == 'manifest'; }
  72.   /** @return {boolean} */
  73.   isSegment() { return this.type_ == 'segment'; }
  75.   /** @return {string} */
  76.   mechanism() { return this.mechanism_; }
  78.   /** @return {string} */
  79.   cell() { return this.cell_; }
  81.   /** @return {number} */
  82.   key() { return this.key_; }
  84.   /** @override */
  85.   toString() { return this.asString_; }
  87.   /**
  88.    * @param {string} uri
  89.    * @return {?shaka.offline.OfflineUri}
  90.    */
  91.   static parse(uri) {
  92.     let parts = /^offline:([a-z]+)\/([^/]+)\/([^/]+)\/([0-9]+)$/.exec(uri);
  93.     if (parts == null) { return null; }
  95.     let type = parts[1];
  96.     if (type != 'manifest' && type != 'segment') { return null; }
  98.     let mechanism = parts[2];
  99.     if (!mechanism) { return null; }
  101.     let cell = parts[3];
  102.     if (!cell) { return null; }
  104.     let key = Number(parts[4]);
  105.     if (type == null) { return null; }
  107.     return new shaka.offline.OfflineUri(type, mechanism, cell, key);
  108.   }
  110.   /**
  111.    * @param {string} mechanism
  112.    * @param {string} cell
  113.    * @param {number} key
  114.    * @return {!shaka.offline.OfflineUri}
  115.    */
  116.   static manifest(mechanism, cell, key) {
  117.     return new shaka.offline.OfflineUri('manifest', mechanism, cell, key);
  118.   }
  120.   /**
  121.    * @param {string} mechanism
  122.    * @param {string} cell
  123.    * @param {number} key
  124.    * @return {!shaka.offline.OfflineUri}
  125.    */
  126.   static segment(mechanism, cell, key) {
  127.     return new shaka.offline.OfflineUri('segment', mechanism, cell, key);
  128.   }
  129. };