rx-player 3.27.0-dev.2022032100 → 3.27.0-dev.2022032500

package/dist/_esm5.processed/core/decrypt/utils/loaded_sessions_store.js

@@ -13,6 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -49,9 +60,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import { closeSession, } from "../../../compat";
-import { onKeyMessage$, onKeyStatusesChange$, } from "../../../compat/event_listeners";
-import config from "../../../config";
+import { closeSession, generateKeyRequest, loadSession, } from "../../../compat";
 import log from "../../../log";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import KeySessionRecord from "./key_session_record";
@@ -75,7 +84,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     }
     /**
      * Create a new MediaKeySession and store it in this store.
-     * @param {Object} initializationData
+     * @param {Object} initData
      * @param {string} sessionType
      * @returns {Object}
      */
@@ -83,7 +92,9 @@ var LoadedSessionsStore = /** @class */ (function () {
         var _this = this;
         var keySessionRecord = new KeySessionRecord(initData);
         var mediaKeySession = this._mediaKeys.createSession(sessionType);
-        var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord };
+        var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord, isGeneratingRequest: false,
+            isLoadingPersistentSession: false,
+            closingStatus: { type: "none" } };
         if (!isNullOrUndefined(mediaKeySession.closed)) {
             mediaKeySession.closed
                 .then(function () {
@@ -99,7 +110,7 @@ var LoadedSessionsStore = /** @class */ (function () {
             });
         }
         log.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
-        this._storage.push({ keySessionRecord: keySessionRecord, mediaKeySession: mediaKeySession, sessionType: sessionType });
+        this._storage.push(__assign({}, entry));
         return entry;
     };
     /**
@@ -120,23 +131,41 @@ var LoadedSessionsStore = /** @class */ (function () {
             if (stored.keySessionRecord.isCompatibleWith(initializationData)) {
                 this._storage.splice(i, 1);
                 this._storage.push(stored);
-                return { keySessionRecord: stored.keySessionRecord,
-                    mediaKeySession: stored.mediaKeySession,
-                    sessionType: stored.sessionType };
+                return __assign({}, stored);
             }
         }
         return null;
     };
     /**
-     * Close a MediaKeySession and remove its related stored information from the
+     * Get `LoadedSessionsStore`'s entry for a given MediaKeySession.
+     * Returns `null` if the given MediaKeySession is not stored in the
      * `LoadedSessionsStore`.
-     * Emit when done.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {Object|null}
+     */
+    LoadedSessionsStore.prototype.getEntryForSession = function (mediaKeySession) {
+        for (var i = this._storage.length - 1; i >= 0; i--) {
+            var stored = this._storage[i];
+            if (stored.mediaKeySession === mediaKeySession) {
+                return __assign({}, stored);
+            }
+        }
+        return null;
+    };
+    /**
+     * Generate a license request on the given MediaKeySession, while indicating
+     * to the LoadedSessionsStore that a license-request is pending so
+     * session-closing orders are properly scheduled after it is done.
      * @param {Object} mediaKeySession
+     * @param {string} initializationDataType - Initialization data type given
+     * e.g. by the "encrypted" event for the corresponding request.
+     * @param {Uint8Array} initializationData - Initialization data given e.g. by
+     * the "encrypted" event for the corresponding request.
      * @returns {Promise}
      */
-    LoadedSessionsStore.prototype.closeSession = function (mediaKeySession) {
+    LoadedSessionsStore.prototype.generateLicenseRequest = function (mediaKeySession, initializationDataType, initializationData) {
         return __awaiter(this, void 0, void 0, function () {
-            var entry, _i, _a, stored;
+            var entry, _i, _a, stored, err_1;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -148,18 +177,132 @@ var LoadedSessionsStore = /** @class */ (function () {
                             }
                         }
                         if (entry === undefined) {
-                            log.warn("DRM-LSS: No MediaKeySession found with " +
+                            log.error("DRM-LSS: generateRequest error. No MediaKeySession found with " +
                                 "the given initData and initDataType");
-                            return [2 /*return*/, Promise.resolve(false)];
+                            return [2 /*return*/, generateKeyRequest(mediaKeySession, initializationDataType, initializationData)];
                         }
-                        return [4 /*yield*/, safelyCloseMediaKeySession(entry.mediaKeySession)];
+                        entry.isGeneratingRequest = true;
+                        // Note the `as string` is needed due to TypeScript not understanding that
+                        // the `closingStatus` might change in the next checks
+                        if (entry.closingStatus.type !== "none") {
+                            throw new Error("The `MediaKeySession` is being closed.");
+                        }
+                        _b.label = 1;
                     case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, generateKeyRequest(mediaKeySession, initializationDataType, initializationData)];
+                    case 2:
                         _b.sent();
-                        return [2 /*return*/, Promise.resolve(true)];
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _b.sent();
+                        if (entry === undefined) {
+                            throw err_1;
+                        }
+                        entry.isGeneratingRequest = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        throw err_1;
+                    case 4:
+                        if (entry === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        entry.isGeneratingRequest = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        return [2 /*return*/];
                 }
             });
         });
     };
+    /**
+     * @param {Object} mediaKeySession
+     * @param {string} sessionId
+     * @returns {Promise}
+     */
+    LoadedSessionsStore.prototype.loadPersistentSession = function (mediaKeySession, sessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry, _i, _a, stored, ret, err_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        for (_i = 0, _a = this._storage; _i < _a.length; _i++) {
+                            stored = _a[_i];
+                            if (stored.mediaKeySession === mediaKeySession) {
+                                entry = stored;
+                                break;
+                            }
+                        }
+                        if (entry === undefined) {
+                            log.error("DRM-LSS: loadPersistentSession error. No MediaKeySession found with " +
+                                "the given initData and initDataType");
+                            return [2 /*return*/, loadSession(mediaKeySession, sessionId)];
+                        }
+                        entry.isLoadingPersistentSession = true;
+                        // Note the `as string` is needed due to TypeScript not understanding that
+                        // the `closingStatus` might change in the next checks
+                        if (entry.closingStatus.type !== "none") {
+                            throw new Error("The `MediaKeySession` is being closed.");
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, loadSession(mediaKeySession, sessionId)];
+                    case 2:
+                        ret = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_2 = _b.sent();
+                        if (entry === undefined) {
+                            throw err_2;
+                        }
+                        entry.isLoadingPersistentSession = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        throw err_2;
+                    case 4:
+                        if (entry === undefined) {
+                            return [2 /*return*/, ret];
+                        }
+                        entry.isLoadingPersistentSession = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        return [2 /*return*/, ret];
+                }
+            });
+        });
+    };
+    /**
+     * Close a MediaKeySession and remove its related stored information from the
+     * `LoadedSessionsStore`.
+     * Emit when done.
+     * @param {Object} mediaKeySession
+     * @returns {Promise}
+     */
+    LoadedSessionsStore.prototype.closeSession = function (mediaKeySession) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry, _i, _a, stored;
+            return __generator(this, function (_b) {
+                for (_i = 0, _a = this._storage; _i < _a.length; _i++) {
+                    stored = _a[_i];
+                    if (stored.mediaKeySession === mediaKeySession) {
+                        entry = stored;
+                        break;
+                    }
+                }
+                if (entry === undefined) {
+                    log.warn("DRM-LSS: No MediaKeySession found with " +
+                        "the given initData and initDataType");
+                    return [2 /*return*/, Promise.resolve(false)];
+                }
+                return [2 /*return*/, this._closeEntry(entry)];
+            });
+        });
+    };
     /**
      * Returns the number of stored MediaKeySessions in this LoadedSessionsStore.
      * @returns {number}
@@ -183,6 +326,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     LoadedSessionsStore.prototype.closeAllSessions = function () {
         return __awaiter(this, void 0, void 0, function () {
             var allEntries, closingProms;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -193,7 +337,7 @@ var LoadedSessionsStore = /** @class */ (function () {
                         // process of removing
                         this._storage = [];
                         closingProms = allEntries
-                            .map(function (entry) { return safelyCloseMediaKeySession(entry.mediaKeySession); });
+                            .map(function (entry) { return _this._closeEntry(entry); });
                         return [4 /*yield*/, Promise.all(closingProms)];
                     case 1:
                         _a.sent();
@@ -202,6 +346,13 @@ var LoadedSessionsStore = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Get the index of a stored MediaKeySession entry based on its
+     * `KeySessionRecord`.
+     * Returns -1 if not found.
+     * @param {Object} record
+     * @returns {number}
+     */
     LoadedSessionsStore.prototype.getIndex = function (record) {
         for (var i = 0; i < this._storage.length; i++) {
             var stored = this._storage[i];
@@ -211,92 +362,82 @@ var LoadedSessionsStore = /** @class */ (function () {
         }
         return -1;
     };
+    /**
+     * Prepare the closure of a `MediaKeySession` stored as an entry of the
+     * `LoadedSessionsStore`.
+     * Allows to postpone the closure action if another MediaKeySession action
+     * is already pending.
+     * @param {Object} entry
+     * @returns {Promise.<boolean>}
+     */
+    LoadedSessionsStore.prototype._closeEntry = function (entry) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mediaKeySession;
+            return __generator(this, function (_a) {
+                mediaKeySession = entry.mediaKeySession;
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (entry !== undefined &&
+                            (entry.isLoadingPersistentSession || entry.isGeneratingRequest)) {
+                            entry.closingStatus = { type: "awaiting",
+                                start: tryClosingEntryAndResolve };
+                        }
+                        else {
+                            tryClosingEntryAndResolve();
+                        }
+                        function tryClosingEntryAndResolve() {
+                            if (entry !== undefined) {
+                                entry.closingStatus = { type: "pending" };
+                            }
+                            safelyCloseMediaKeySession(mediaKeySession)
+                                .then(function () {
+                                if (entry !== undefined) {
+                                    entry.closingStatus = { type: "done" };
+                                }
+                                resolve(true);
+                            })
+                                .catch(function (err) {
+                                if (entry !== undefined) {
+                                    entry.closingStatus = { type: "failed" };
+                                }
+                                reject(err);
+                            });
+                        }
+                    })];
+            });
+        });
+    };
     return LoadedSessionsStore;
 }());
 export default LoadedSessionsStore;
 /**
- * Close a MediaKeySession with multiple attempts if needed and do not throw if
- * this action throws an error.
+ * Close a MediaKeySession and just log an error if it fails (while resolving).
  * Emits then complete when done.
  * @param {MediaKeySession} mediaKeySession
  * @returns {Observable}
  */
 function safelyCloseMediaKeySession(mediaKeySession) {
-    return recursivelyTryToCloseMediaKeySession(0);
-    /**
-     * Perform a new attempt at closing the MediaKeySession.
-     * If this operation fails due to a not-"callable" (an EME term)
-     * MediaKeySession, retry based on either a timer or on MediaKeySession
-     * events, whichever comes first.
-     * Emits then complete when done.
-     * @param {number} retryNb - The attempt number starting at 0.
-     * @returns {Observable}
-     */
-    function recursivelyTryToCloseMediaKeySession(retryNb) {
-        return __awaiter(this, void 0, void 0, function () {
-            var err_1, _a, EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY, nextRetryNb, delay_1, ksChangeSub_1, ksChangeProm, ksMsgSub_1, ksMsgProm, sleepTimer_1, sleepProm;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId, retryNb);
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 3, , 5]);
-                        return [4 /*yield*/, closeSession(mediaKeySession)];
-                    case 2:
-                        _b.sent();
-                        log.debug("DRM: Succeeded to close MediaKeySession");
-                        return [2 /*return*/, undefined];
-                    case 3:
-                        err_1 = _b.sent();
-                        // Unitialized MediaKeySession may not close properly until their
-                        // corresponding `generateRequest` or `load` call are handled by the
-                        // browser.
-                        // In that case the EME specification tells us that the browser is
-                        // supposed to reject the `close` call with an InvalidStateError.
-                        if (!(err_1 instanceof Error) || err_1.name !== "InvalidStateError" ||
-                            mediaKeySession.sessionId !== "") {
-                            return [2 /*return*/, failToCloseSession(err_1)];
-                        }
-                        _a = config.getCurrent(), EME_SESSION_CLOSING_MAX_RETRY = _a.EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY = _a.EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY = _a.EME_SESSION_CLOSING_MAX_DELAY;
-                        nextRetryNb = retryNb + 1;
-                        if (nextRetryNb > EME_SESSION_CLOSING_MAX_RETRY) {
-                            return [2 /*return*/, failToCloseSession(err_1)];
-                        }
-                        delay_1 = Math.min(Math.pow(2, retryNb) * EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY);
-                        log.warn("DRM: attempt to close a mediaKeySession failed, " +
-                            "scheduling retry...", delay_1);
-                        ksChangeProm = new Promise(function (res) {
-                            ksChangeSub_1 = onKeyStatusesChange$(mediaKeySession).subscribe(res);
-                        });
-                        ksMsgProm = new Promise(function (res) {
-                            ksMsgSub_1 = onKeyMessage$(mediaKeySession).subscribe(res);
-                        });
-                        sleepProm = new Promise(function (res) {
-                            sleepTimer_1 = window.setTimeout(res, delay_1);
-                        });
-                        return [4 /*yield*/, Promise.race([ksChangeProm, ksMsgProm, sleepProm])];
-                    case 4:
-                        _b.sent();
-                        ksChangeSub_1 === null || ksChangeSub_1 === void 0 ? void 0 : ksChangeSub_1.unsubscribe();
-                        ksMsgSub_1 === null || ksMsgSub_1 === void 0 ? void 0 : ksMsgSub_1.unsubscribe();
-                        clearTimeout(sleepTimer_1);
-                        return [2 /*return*/, recursivelyTryToCloseMediaKeySession(nextRetryNb)];
-                    case 5: return [2 /*return*/];
-                }
-            });
+    return __awaiter(this, void 0, void 0, function () {
+        var err_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, closeSession(mediaKeySession)];
+                case 2:
+                    _a.sent();
+                    log.debug("DRM: Succeeded to close MediaKeySession");
+                    return [2 /*return*/];
+                case 3:
+                    err_3 = _a.sent();
+                    log.error("DRM: Could not close MediaKeySession: " +
+                        (err_3 instanceof Error ? err_3.toString() :
+                            "Unknown error"));
+                    return [2 /*return*/];
+                case 4: return [2 /*return*/];
+            }
         });
-    }
-    /**
-     * Log error anouncing that we could not close the MediaKeySession and emits
-     * then complete through Observable.
-     * TODO Emit warning?
-     * @returns {Observable}
-     */
-    function failToCloseSession(err) {
-        log.error("DRM: Could not close MediaKeySession: " +
-            (err instanceof Error ? err.toString() :
-                "Unknown error"));
-        return Promise.resolve(null);
-    }
+    });
 }

package/dist/_esm5.processed/core/stream/representation/append_segment_to_buffer.js

@@ -16,7 +16,7 @@
 /**
  * This file allows any Stream to push data to a SegmentBuffer.
  */
-import { catchError, concat as observableConcat, mergeMap, ignoreElements, } from "rxjs";
+import { catchError, concat as observableConcat, mergeMap, ignoreElements, take, } from "rxjs";
 import { MediaError } from "../../../errors";
 import forceGarbageCollection from "./force_garbage_collection";
 /**
@@ -38,10 +38,11 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                 "An unknown error happened when pushing content";
             throw new MediaError("BUFFER_APPEND_ERROR", reason);
         }
-        return playbackObserver.observe(true).pipe(mergeMap(function (observation) {
+        return playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
             var currentPos = observation.position + observation.wantedTimeOffset;
             return observableConcat(forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()), append$).pipe(catchError(function (forcedGCError) {
-                var reason = forcedGCError instanceof Error ? forcedGCError.toString() :
+                var reason = forcedGCError instanceof Error ?
+                    forcedGCError.toString() :
                     "Could not clean the buffer";
                 throw new MediaError("BUFFER_FULL_ERROR", reason);
             }));

package/dist/_esm5.processed/default_config.d.ts

@@ -934,33 +934,6 @@ declare const DEFAULT_CONFIG: {
      * This wasn't battle-tested however.
      */
     EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION: number;
-    /**
-     * Attempts to closing a MediaKeySession can fail, most likely because the
-     * MediaKeySession was not initialized yet.
-     * When we consider that we're in one of these case, we will retry to close it.
-     *
-     * To avoid going into an infinite loop of retry, this number indicates a
-     * maximum number of attemps we're going to make (`0` meaning no retry at all,
-     * `1` only one retry and so on).
-     */
-    EME_SESSION_CLOSING_MAX_RETRY: number;
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the initial value for this delay, in milliseconds.
-     */
-    EME_SESSION_CLOSING_INITIAL_DELAY: number;
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the maximum possible value for this delay, in
-     * milliseconds.
-     */
-    EME_SESSION_CLOSING_MAX_DELAY: number;
     /**
      * After loading a persistent MediaKeySession, the RxPlayer needs to ensure
      * that its keys still allow to decrypt a content.

package/dist/_esm5.processed/default_config.js

@@ -978,33 +978,6 @@ var DEFAULT_CONFIG = {
      * This wasn't battle-tested however.
      */
     EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION: 1000,
-    /**
-     * Attempts to closing a MediaKeySession can fail, most likely because the
-     * MediaKeySession was not initialized yet.
-     * When we consider that we're in one of these case, we will retry to close it.
-     *
-     * To avoid going into an infinite loop of retry, this number indicates a
-     * maximum number of attemps we're going to make (`0` meaning no retry at all,
-     * `1` only one retry and so on).
-     */
-    EME_SESSION_CLOSING_MAX_RETRY: 5,
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the initial value for this delay, in milliseconds.
-     */
-    EME_SESSION_CLOSING_INITIAL_DELAY: 100,
-    /**
-     * When closing a MediaKeySession failed due to the reasons explained for the
-     * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-     * triggers) choose to wait a delay raising exponentially at each retry before
-     * that new attempt.
-     * This value indicates the maximum possible value for this delay, in
-     * milliseconds.
-     */
-    EME_SESSION_CLOSING_MAX_DELAY: 1000,
     /**
      * After loading a persistent MediaKeySession, the RxPlayer needs to ensure
      * that its keys still allow to decrypt a content.