shaka-player 3.1.4 → 3.3.0

package/lib/util/error.js

@@ -814,6 +814,12 @@ shaka.util.Error.Code = {
    */
   'INIT_DATA_TRANSFORM_ERROR': 6016,
 
+  /**
+   * The server certificate request failed.
+   * <br> error.data[0] is a shaka.util.Error from the networking engine.
+   */
+  'SERVER_CERTIFICATE_REQUEST_FAILED': 6017,
+
 
   /**
    * The call to Player.load() was interrupted by a call to Player.unload()
@@ -980,6 +986,12 @@ shaka.util.Error.Code = {
    */
   'DOWNLOAD_SIZE_CALLBACK_ERROR': 9015,
 
+  /**
+   * The storage cell does not allow new operations that significantly change
+   * existing data.
+   */
+  'MODIFY_OPERATION_NOT_SUPPORTED': 9016,
+
   /**
    * CS IMA SDK, required for ad insertion, has not been included on the page.
    */

package/lib/util/language_utils.js

@@ -13,6 +13,7 @@ goog.require('shaka.util.ManifestParserUtils');
 /**
  * @summary A set of language utility functions.
  * @final
+ * @export
  */
 shaka.util.LanguageUtils = class {
   /**
@@ -32,6 +33,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLocaleCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -62,6 +64,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLanguageCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -102,6 +105,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} possibleParent
    * @param {string} possibleChild
    * @return {boolean}
+   * @export
    */
   static isParentOf(possibleParent, possibleChild) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -146,6 +150,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} localeA
    * @param {string} localeB
    * @return {boolean}
+   * @export
    */
   static isSiblingOf(localeA, localeB) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -181,6 +186,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} locale
    * @return {string}
+   * @export
    */
   static normalize(locale) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -217,6 +223,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} a
    * @param {string} b
    * @return {boolean}
+   * @export
    */
   static areSiblings(a, b) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -235,6 +242,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {string} candidate
    * @return {number}
+   * @export
    */
   static relatedness(target, candidate) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -271,6 +279,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} lang
    * @return {string}
+   * @export
    */
   static getBase(lang) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -300,6 +309,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Stream} stream
    * @return {string}
+   * @export
    */
   static getLocaleForText(stream) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -322,6 +332,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Variant} variant
    * @return {string}
+   * @export
    */
   static getLocaleForVariant(variant) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -356,6 +367,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {!Iterable.<string>} searchSpace
    * @return {?string}
+   * @export
    */
   static findClosestLocale(target, searchSpace) {
     const LanguageUtils = shaka.util.LanguageUtils;

package/lib/util/manifest_parser_utils.js

@@ -55,6 +55,7 @@ shaka.util.ManifestParserUtils = class {
       audioRobustness: '',
       videoRobustness: '',
       serverCertificate: null,
+      serverCertificateUri: '',
       sessionType: '',
       initData: initData || [],
       keyIds: new Set(),

package/lib/util/mp4_box_parsers.js

@@ -14,7 +14,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TFHD Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} flags
+   * @param {number} flags
    * @return {!shaka.util.ParsedTFHDBox}
    */
   static parseTFHD(reader, flags) {
@@ -53,7 +53,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TFDT Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
+   * @param {number} version
    * @return {!shaka.util.ParsedTFDTBox}
    */
   static parseTFDT(reader, version) {
@@ -68,7 +68,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a MDHD Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
+   * @param {number} version
    * @return {!shaka.util.ParsedMDHDBox}
    */
   static parseMDHD(reader, version) {
@@ -107,8 +107,8 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TRUN Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
-   * @param {!number} flags
+   * @param {number} version
+   * @param {number} flags
    * @return {!shaka.util.ParsedTRUNBox}
    */
   static parseTRUN(reader, version, flags) {
@@ -168,7 +168,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TKHD Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
+   * @param {number} version
    * @return {!shaka.util.ParsedTKHDBox}
    */
   static parseTKHD(reader, version) {
@@ -192,12 +192,12 @@ shaka.util.Mp4BoxParsers = class {
 
 /**
  * @typedef {{
- *    trackId: !number,
+ *    trackId: number,
  *    defaultSampleDuration: ?number,
  *    defaultSampleSize: ?number
  * }}
  *
- * @property {!number} trackId
+ * @property {number} trackId
  *   As per the spec: an integer that uniquely identifies this
  *   track over the entire life‐time of this presentation
  * @property {?number} defaultSampleDuration
@@ -213,10 +213,10 @@ shaka.util.ParsedTFHDBox;
 
 /**
  * @typedef {{
- *    baseMediaDecodeTime: !number
+ *    baseMediaDecodeTime: number
  * }}
  *
- * @property {!number} baseMediaDecodeTime
+ * @property {number} baseMediaDecodeTime
  *   As per the spec: the absolute decode time, measured on the media
  *   timeline, of the first sample in decode order in the track fragment
  *
@@ -226,10 +226,10 @@ shaka.util.ParsedTFDTBox;
 
 /**
  * @typedef {{
- *    timescale: !number
+ *    timescale: number
  * }}
  *
- * @property {!number} timescale
+ * @property {number} timescale
  *   As per the spec: an integer that specifies the time‐scale for this media;
  *   this is the number of time units that pass in one second
  *
@@ -239,13 +239,13 @@ shaka.util.ParsedMDHDBox;
 
 /**
  * @typedef {{
- *    defaultSampleDuration: !number,
- *    defaultSampleSize: !number
+ *    defaultSampleDuration: number,
+ *    defaultSampleSize: number
  * }}
  *
- * @property {!number} defaultSampleDuration
+ * @property {number} defaultSampleDuration
  *   The default sample duration to be used in track fragments
- * @property {!number} defaultSampleSize
+ * @property {number} defaultSampleSize
  *   The default sample size to be used in track fragments
  *
  * @exportDoc
@@ -254,11 +254,11 @@ shaka.util.ParsedTREXBox;
 
 /**
  * @typedef {{
- *    sampleCount: !number,
+ *    sampleCount: number,
  *    sampleData: !Array.<shaka.util.ParsedTRUNSample>
  * }}
  *
- * @property {!number} sampleCount
+ * @property {number} sampleCount
  *   As per the spec: the number of samples being added in this run;
  * @property {!Array.<shaka.util.ParsedTRUNSample>} sampleData
  *   An array of size <sampleCount> containing data for each sample
@@ -290,10 +290,10 @@ shaka.util.ParsedTRUNSample;
 
 /**
  * @typedef {{
- *    trackId: !number
+ *    trackId: number
  *  }}
  *
- * @property {!number} trackId
+ * @property {number} trackId
  *   Unique ID indicative of this track
  *
  * @exportDoc

package/lib/util/multi_map.js

@@ -102,4 +102,12 @@ shaka.util.MultiMap = class {
   size() {
     return Object.keys(this.map_).length;
   }
+
+  /**
+   * Get a list of all the keys.
+   * @return {!Array.<string>}
+   */
+  keys() {
+    return Object.keys(this.map_);
+  }
 };

package/lib/util/mutex.js

@@ -0,0 +1,52 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.Mutex');
+
+
+/**
+ * @summary A simple mutex.
+ */
+shaka.util.Mutex = class {
+  /** Creates the mutex. */
+  constructor() {
+    /** @private {!Array.<function()>} */
+    this.waiting_ = [];
+
+    /** @private {number} */
+    this.nextMutexId_ = 0;
+
+    /** @private {number} */
+    this.acquiredMutexId_ = 0;
+  }
+
+  /** @return {!Promise.<number>} mutexId */
+  async acquire() {
+    const mutexId = ++this.nextMutexId_;
+    if (!this.acquiredMutexId_) {
+      this.acquiredMutexId_ = mutexId;
+    } else {
+      await (new Promise((resolve, reject) => {
+        this.waiting_.push(() => {
+          this.acquiredMutexId_ = mutexId;
+          resolve();
+        });
+      }));
+    }
+    return mutexId;
+  }
+
+  /** @param {number} mutexId */
+  release(mutexId) {
+    if (mutexId == this.acquiredMutexId_) {
+      this.acquiredMutexId_ = 0;
+      if (this.waiting_.length > 0) {
+        const callback = this.waiting_.shift();
+        callback();
+      }
+    }
+  }
+};

package/lib/util/periods.js

@@ -547,8 +547,7 @@ shaka.util.PeriodCombiner = class {
       for (const stream of unusedStreams) {
         // Create a new output stream which includes this input stream.
         const outputStream =
-            // eslint-disable-next-line no-await-in-loop
-            await shaka.util.PeriodCombiner.createNewOutputStream_(
+            shaka.util.PeriodCombiner.createNewOutputStream_(
                 stream, streamsPerPeriod, clone, concat,
                 unusedStreamsPerPeriod);
         if (outputStream) {
@@ -619,52 +618,69 @@ shaka.util.PeriodCombiner = class {
   static async extendExistingOutputStream_(
       outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
       unusedStreamsPerPeriod) {
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // We were unable to extend this output stream.
-      shaka.log.error('No matches extending output stream!',
-          outputStream, streamsPerPeriod);
-      return false;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream, and this should only ever be called
     // on Stream types.  StreamDB should not have pre-existing output streams.
     goog.asserts.assert(outputStream.createSegmentIndex,
         'outputStream should be a Stream type!');
 
+    if (!outputStream.matchedStreams) {
+      // We were unable to extend this output stream.
+      shaka.log.error('No matches extending output stream!',
+          outputStream, streamsPerPeriod);
+      return false;
+    }
     // We need to create all the per-period segment indexes and append them to
     // the output's MetaSegmentIndex.
-    await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
-
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
+    if (outputStream.segmentIndex) {
+      await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(outputStream,
+          firstNewPeriodIndex);
+    }
 
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, firstNewPeriodIndex, concat,
-        unusedStreamsPerPeriod);
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        firstNewPeriodIndex, concat, unusedStreamsPerPeriod);
     return true;
   }
 
   /**
-   * Creates all segment indexes for an array of streams.  Returns once every
-   * segment index is created.
+   * Creates the segment indexes for an array of input streams, and append them
+   * to the output stream's segment index.
    *
-   * @param {!Array.<!shaka.extern.Stream>} streams
-   * @return {!Promise}
+   * @param {shaka.extern.Stream} outputStream
+   * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
+   *   represents the first new period that hasn't been processed yet.
    * @private
    */
-  static createSegmentIndexes_(streams) {
+  static async extendOutputSegmentIndex_(outputStream, firstNewPeriodIndex) {
     const operations = [];
+    const streams = outputStream.matchedStreams;
+    goog.asserts.assert(streams, 'matched streams should be valid');
+
     for (const stream of streams) {
       operations.push(stream.createSegmentIndex());
       if (stream.trickModeVideo && !stream.trickModeVideo.segmentIndex) {
         operations.push(stream.trickModeVideo.createSegmentIndex());
       }
     }
-    return Promise.all(operations);
+    await Promise.all(operations);
+
+    // Concatenate the new matches onto the stream, starting at the first new
+    // period.
+    const Iterables = shaka.util.Iterables;
+    // Satisfy the compiler about the type.
+    // Also checks if the segmentIndex is still valid after the async
+    // operations, to make sure we stop if the active stream has changed.
+    if (outputStream.segmentIndex instanceof shaka.media.MetaSegmentIndex) {
+      for (const {i, item: match} of Iterables.enumerate(streams)) {
+        if (match.segmentIndex && i >= firstNewPeriodIndex) {
+          goog.asserts.assert(match.segmentIndex,
+              'stream should have a segmentIndex.');
+          outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
+        }
+      }
+    }
   }
 
   /**
@@ -682,7 +698,7 @@ shaka.util.PeriodCombiner = class {
    * @param {!Array.<!Set.<T>>} unusedStreamsPerPeriod An array of sets of
    *   unused streams from each period.
    *
-   * @return {!Promise.<?T>} A newly-created output Stream, or null if matches
+   * @return {?T} A newly-created output Stream, or null if matches
    *   could not be found.`
    *
    * @template T
@@ -690,35 +706,36 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static async createNewOutputStream_(
+  static createNewOutputStream_(
       stream, streamsPerPeriod, clone, concat, unusedStreamsPerPeriod) {
     // Start by cloning the stream without segments, key IDs, etc.
     const outputStream = clone(stream);
 
     // Find best-matching streams in all periods.
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // This is not a stream we can build output from, but it may become part
-      // of another output based on another period's stream.
-      return null;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream.
     if (outputStream.createSegmentIndex) {
+      // Override the createSegmentIndex function of the outputStream.
+      outputStream.createSegmentIndex = async () => {
+        if (!outputStream.segmentIndex) {
+          outputStream.segmentIndex = new shaka.media.MetaSegmentIndex();
+          await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(
+              outputStream, /* firstNewPeriodIndex= */ 0);
+        }
+      };
       // For T == Stream, we need to create all the per-period segment indexes
       // in advance.  concat() will add them to the output's MetaSegmentIndex.
-      await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
     }
 
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
-
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, /* firstNewPeriodIndex= */ 0, concat,
-        unusedStreamsPerPeriod);
+    if (!outputStream.matchedStreams) {
+      // This is not a stream we can build output from, but it may become part
+      // of another output based on another period's stream.
+      return null;
+    }
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        /* firstNewPeriodIndex= */ 0, concat, unusedStreamsPerPeriod);
 
     return outputStream;
   }
@@ -726,7 +743,6 @@ shaka.util.PeriodCombiner = class {
   /**
    * @param {T} outputStream An existing output stream which needs to be
    *   extended into new periods.
-   * @param {!Array.<T>} matches A list of matching Streams from each period.
    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
    *   represents the first new period that hasn't been processed yet.
    * @param {function(T, T)} concat Concatenate the second stream onto the end
@@ -740,10 +756,15 @@ shaka.util.PeriodCombiner = class {
    * @private
    */
   static extendOutputStream_(
-      outputStream, matches, firstNewPeriodIndex, concat,
-      unusedStreamsPerPeriod) {
+      outputStream, firstNewPeriodIndex, concat, unusedStreamsPerPeriod) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const LanguageUtils = shaka.util.LanguageUtils;
+    const matches = outputStream.matchedStreams;
+
+    // Assure the compiler that matches didn't become null during the async
+    // operation before.
+    goog.asserts.assert(outputStream.matchedStreams,
+        'matchedStreams should be non-null');
 
     // Concatenate the new matches onto the stream, starting at the first new
     // period.
@@ -787,7 +808,23 @@ shaka.util.PeriodCombiner = class {
     // streams that match this output.
     clone.originalId = null;
     clone.createSegmentIndex = () => Promise.resolve();
-    clone.segmentIndex = new shaka.media.MetaSegmentIndex();
+    clone.closeSegmentIndex = () => {
+      if (clone.segmentIndex) {
+        clone.segmentIndex.release();
+        clone.segmentIndex = null;
+      }
+      // Close the segment index of the matched streams.
+      if (clone.matchedStreams) {
+        for (const match of clone.matchedStreams) {
+          if (match.segmentIndex) {
+            match.segmentIndex.release();
+            match.segmentIndex = null;
+          }
+        }
+      }
+    };
+
+    clone.segmentIndex = null;
     clone.emsgSchemeIdUris = [];
     clone.keyIds = new Set();
     clone.closedCaptions = null;
@@ -873,26 +910,24 @@ shaka.util.PeriodCombiner = class {
       }
     }
 
-    // Satisfy the compiler about the type.
-    goog.asserts.assert(
-        output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
-        'Output streams should have a MetaSegmentIndex!');
-    // Satisfy the compiler that the input index has been created.
-    goog.asserts.assert(
-        input.segmentIndex,
-        'Input segment index should have been created by now!');
-
-    output.segmentIndex.appendSegmentIndex(input.segmentIndex);
-
     // Combine trick-play video streams, if present.
     if (input.trickModeVideo) {
       if (!output.trickModeVideo) {
         // Create a fresh output stream for trick-mode playback.
         output.trickModeVideo = shaka.util.PeriodCombiner.cloneStream_(
             input.trickModeVideo);
-        // Start it with whatever non-trick-mode Streams are in the output so
-        // far.
-        output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+        // TODO: fix the createSegmentIndex function for trickModeVideo.
+        // The trick-mode tracks in multi-period content should have trick-mode
+        // segment indexes whenever available, rather than only regular-mode
+        // segment indexes.
+        output.trickModeVideo.createSegmentIndex = () => {
+          // Satisfy the compiler about the type.
+          goog.asserts.assert(
+              output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
+              'The stream should have a MetaSegmentIndex.');
+          output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+          return Promise.resolve();
+        };
       }
 
       // Concatenate the trick mode input onto the trick mode output.
@@ -943,7 +978,6 @@ shaka.util.PeriodCombiner = class {
    *
    * @param {!Array.<!Array.<T>>} streamsPerPeriod
    * @param {T} outputStream
-   * @return {Array.<T>}
    *
    * @template T
    * Accepts either a StreamDB or Stream type.
@@ -956,11 +990,11 @@ shaka.util.PeriodCombiner = class {
       const match = shaka.util.PeriodCombiner.findBestMatchInPeriod_(
           streams, outputStream);
       if (!match) {
-        return null;
+        return;
       }
       matches.push(match);
     }
-    return matches;
+    outputStream.matchedStreams = matches;
   }
 
   /**

package/lib/util/player_configuration.js

@@ -75,6 +75,7 @@ shaka.util.PlayerConfiguration = class {
       initDataTransform: shaka.media.DrmEngine.defaultInitDataTransform,
       logLicenseExchange: false,
       updateExpirationTime: 1,
+      preferredKeySystems: [],
     };
 
     const manifest = {
@@ -108,10 +109,19 @@ shaka.util.PlayerConfiguration = class {
           'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb':
             'com.adobe.primetime',
         },
+        // Need some operation in the callback or else closure may remove calls
+        // to the function as it would be a no-op.  The operation can't just be
+        // a log message, because those are stripped in the compiled build.
+        manifestPreprocessor: (element) => {
+          return element;
+        },
       },
       hls: {
         ignoreTextStreamFailures: false,
+        ignoreImageStreamFailures: false,
         useFullSegmentsForStartTime: false,
+        defaultAudioCodec: 'mp4a.40.2',
+        defaultVideoCodec: 'avc1.42E01E',
       },
     };
 
@@ -154,6 +164,9 @@ shaka.util.PlayerConfiguration = class {
       autoLowLatencyMode: false,
       forceHTTPS: false,
       preferNativeHls: false,
+      updateIntervalSeconds: 1,
+      dispatchAllEmsgBoxes: false,
+      observeQualityChanges: false,
     };
 
     // Some browsers will stop earlier than others before a gap (e.g., Edge
@@ -226,6 +239,19 @@ shaka.util.PlayerConfiguration = class {
         minBandwidth: 0,
         maxBandwidth: Infinity,
       },
+      advanced: {
+        minTotalBytes: 128e3,
+        minBytes: 16e3,
+        fastHalfLife: 2,
+        slowHalfLife: 5,
+      },
+    };
+
+    const cmcd = {
+      enabled: false,
+      sessionId: '',
+      contentId: '',
+      useHeaders: false,
     };
 
     /** @type {shaka.extern.PlayerConfiguration} */
@@ -241,7 +267,10 @@ shaka.util.PlayerConfiguration = class {
       preferredVariantRole: '',
       preferredTextRole: '',
       preferredAudioChannelCount: 2,
+      preferredVideoCodecs: [],
+      preferredAudioCodecs: [],
       preferForcedSubs: false,
+      preferredDecodingAttributes: [],
       restrictions: {
         minWidth: 0,
         maxWidth: Infinity,
@@ -256,8 +285,8 @@ shaka.util.PlayerConfiguration = class {
       },
       playRangeStart: 0,
       playRangeEnd: Infinity,
-      useMediaCapabilities: false,
       textDisplayFactory: () => null,
+      cmcd: cmcd,
     };
 
     // Add this callback so that we can reference the preferred audio language
@@ -293,6 +322,7 @@ shaka.util.PlayerConfiguration = class {
         audioRobustness: '',
         sessionType: '',
         serverCertificate: new Uint8Array(0),
+        serverCertificateUri: '',
         individualizationServer: '',
       },
     };