rx-player 3.27.0-dev.20220317 → 3.27.0-dev.2022032800

package/dist/_esm5.processed/core/decrypt/create_session.d.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { ICustomMediaKeySession } from "../../compat";
+import { CancellationSignal } from "../../utils/task_canceller";
 import { IProcessedProtectionData, IMediaKeySessionStores, MediaKeySessionLoadingType } from "./types";
 import KeySessionRecord from "./utils/key_session_record";
 /**
@@ -29,9 +30,10 @@ import KeySessionRecord from "./utils/key_session_record";
  * @param {Object} stores
  * @param {Object} initData
  * @param {string} wantedSessionType
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function createSession(stores: IMediaKeySessionStores, initData: IProcessedProtectionData, wantedSessionType: MediaKeySessionType): Promise<ICreateSessionEvent>;
+export default function createSession(stores: IMediaKeySessionStores, initData: IProcessedProtectionData, wantedSessionType: MediaKeySessionType, cancelSignal: CancellationSignal): Promise<ICreateSessionEvent>;
 export interface INewSessionCreatedEvent {
     type: MediaKeySessionLoadingType.Created;
     value: {

package/dist/_esm5.processed/core/decrypt/create_session.js

@@ -49,8 +49,6 @@ 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 PPromise from "pinkie";
-import { loadSession, } from "../../compat";
 import log from "../../log";
 import isSessionUsable from "./utils/is_session_usable";
 /**
@@ -66,9 +64,10 @@ import isSessionUsable from "./utils/is_session_usable";
  * @param {Object} stores
  * @param {Object} initData
  * @param {string} wantedSessionType
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function createSession(stores, initData, wantedSessionType) {
+export default function createSession(stores, initData, wantedSessionType, cancelSignal) {
     var loadedSessionsStore = stores.loadedSessionsStore, persistentSessionsStore = stores.persistentSessionsStore;
     if (wantedSessionType === "temporary") {
         return createTemporarySession(loadedSessionsStore, initData);
@@ -78,7 +77,7 @@ export default function createSession(stores, initData, wantedSessionType) {
             "PersistentSessionsStore not created.");
         return createTemporarySession(loadedSessionsStore, initData);
     }
-    return createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initData);
+    return createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initData, cancelSignal);
 }
 /**
  * Create a new temporary MediaKeySession linked to the given initData and
@@ -90,7 +89,7 @@ export default function createSession(stores, initData, wantedSessionType) {
 function createTemporarySession(loadedSessionsStore, initData) {
     log.info("DRM: Creating a new temporary session");
     var entry = loadedSessionsStore.createSession(initData, "temporary");
-    return PPromise.resolve({ type: "created-session" /* Created */,
+    return Promise.resolve({ type: "created-session" /* Created */,
         value: entry });
 }
 /**
@@ -99,9 +98,10 @@ function createTemporarySession(loadedSessionsStore, initData) {
  * @param {Object} loadedSessionsStore
  * @param {Object} persistentSessionsStore
  * @param {Object} initData
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
-function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initData) {
+function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initData, cancelSignal) {
     return __awaiter(this, void 0, void 0, function () {
         /**
          * Helper function to close and restart the current persistent session
@@ -114,6 +114,9 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
+                            if (cancelSignal.cancellationError !== null) {
+                                throw cancelSignal.cancellationError;
+                            }
                             log.info("DRM: Removing previous persistent session.");
                             persistentEntry = persistentSessionsStore.get(initData);
                             if (persistentEntry !== null) {
@@ -122,6 +125,9 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
                             return [4 /*yield*/, loadedSessionsStore.closeSession(entry.mediaKeySession)];
                         case 1:
                             _a.sent();
+                            if (cancelSignal.cancellationError !== null) {
+                                throw cancelSignal.cancellationError;
+                            }
                             newEntry = loadedSessionsStore.createSession(initData, "persistent-license");
                             return [2 /*return*/, { type: "created-session" /* Created */,
                                     value: newEntry }];
@@ -133,6 +139,9 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    if (cancelSignal.cancellationError !== null) {
+                        throw cancelSignal.cancellationError;
+                    }
                     log.info("DRM: Creating persistent MediaKeySession");
                     entry = loadedSessionsStore.createSession(initData, "persistent-license");
                     storedEntry = persistentSessionsStore.getAndReuse(initData);
@@ -143,7 +152,7 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
                     _a.label = 1;
                 case 1:
                     _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, loadSession(entry.mediaKeySession, storedEntry.sessionId)];
+                    return [4 /*yield*/, loadedSessionsStore.loadPersistentSession(entry.mediaKeySession, storedEntry.sessionId)];
                 case 2:
                     hasLoadedSession = _a.sent();
                     if (!hasLoadedSession) {

package/dist/_esm5.processed/core/decrypt/find_key_system.js

@@ -55,7 +55,6 @@ import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import arrayIncludes from "../../utils/array_includes";
 import flatMap from "../../utils/flat_map";
-import PPromise from "../../utils/promise";
 import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 /**
  * @param {Array.<Object>} keySystems
@@ -213,7 +212,7 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
         var cachedKeySystemAccess = checkCachedMediaKeySystemAccess(keySystemsConfigs, currentState.mediaKeySystemAccess, currentState.keySystemOptions);
         if (cachedKeySystemAccess !== null) {
             log.info("DRM: Found cached compatible keySystem");
-            return PPromise.resolve({
+            return Promise.resolve({
                 type: "reuse-media-key-system-access",
                 value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
                     options: cachedKeySystemAccess.keySystemOptions },

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

@@ -49,7 +49,6 @@ 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 PPromise from "../../../utils/promise";
 /**
  * Close sessions from the loadedSessionsStore to allow at maximum `limit`
  * stored MediaKeySessions in it.
@@ -75,7 +74,7 @@ export default function cleanOldLoadedSessions(loadedSessionsStore, limit) {
                         entry = entries[i];
                         proms.push(loadedSessionsStore.closeSession(entry.mediaKeySession));
                     }
-                    return [4 /*yield*/, PPromise.all(proms)];
+                    return [4 /*yield*/, Promise.all(proms)];
                 case 1:
                     _a.sent();
                     return [2 /*return*/];

package/dist/_esm5.processed/core/decrypt/utils/loaded_sessions_store.d.ts

@@ -37,7 +37,7 @@ export default class LoadedSessionsStore {
     constructor(mediaKeys: MediaKeys | ICustomMediaKeys);
     /**
      * Create a new MediaKeySession and store it in this store.
-     * @param {Object} initializationData
+     * @param {Object} initData
      * @param {string} sessionType
      * @returns {Object}
      */
@@ -55,6 +55,32 @@ export default class LoadedSessionsStore {
      * @returns {Object|null}
      */
     reuse(initializationData: IProcessedProtectionData): IStoredSessionEntry | null;
+    /**
+     * Get `LoadedSessionsStore`'s entry for a given MediaKeySession.
+     * Returns `null` if the given MediaKeySession is not stored in the
+     * `LoadedSessionsStore`.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {Object|null}
+     */
+    getEntryForSession(mediaKeySession: MediaKeySession | ICustomMediaKeySession): IStoredSessionEntry | 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}
+     */
+    generateLicenseRequest(mediaKeySession: MediaKeySession | ICustomMediaKeySession, initializationDataType: string | undefined, initializationData: Uint8Array): Promise<unknown>;
+    /**
+     * @param {Object} mediaKeySession
+     * @param {string} sessionId
+     * @returns {Promise}
+     */
+    loadPersistentSession(mediaKeySession: MediaKeySession | ICustomMediaKeySession, sessionId: string): Promise<boolean>;
     /**
      * Close a MediaKeySession and remove its related stored information from the
      * `LoadedSessionsStore`.
@@ -80,7 +106,23 @@ export default class LoadedSessionsStore {
      * @returns {Promise}
      */
     closeAllSessions(): Promise<void>;
+    /**
+     * Get the index of a stored MediaKeySession entry based on its
+     * `KeySessionRecord`.
+     * Returns -1 if not found.
+     * @param {Object} record
+     * @returns {number}
+     */
     private getIndex;
+    /**
+     * 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>}
+     */
+    private _closeEntry;
 }
 /** Information linked to a `MediaKeySession` created by the `LoadedSessionsStore`. */
 export interface IStoredSessionEntry {
@@ -105,4 +147,55 @@ export interface IStoredSessionEntry {
      * which the MediaKeySession was created.
      */
     sessionType: MediaKeySessionType;
+    /**
+     * Set to `true` while a `generateRequest` call is pending.
+     * This information might be useful as it is one of the operation we have to
+     * wait for before closing a MediaKeySession.
+     */
+    isGeneratingRequest: boolean;
+    /**
+     * Set to `true` while a `load` call is pending.
+     * This information might be useful as it is one of the operation we have to
+     * wait for before closing a MediaKeySession.
+     */
+    isLoadingPersistentSession: boolean;
+    /**
+     * The status of a potential `MediaKeySession`'s close request.
+     * Closing a MediaKeySession could be made complex as it normally cannot
+     * happen until `generateRequest` or `load` has been called.
+     *
+     * To avoid problems while still staying compatible to the most devices
+     * possible - which may have strange implementation of the specification -
+     * we're adding the `closingStatus` property allowing to perform multiple
+     * type of interaction while a close operation is either pending or is
+     * awaited.
+     */
+    closingStatus: 
+    /** Status when the MediaKeySession is currently being closed. */
+    {
+        type: "pending";
+    } | 
+    /** Status when the MediaKeySession has been closed. */
+    {
+        type: "done";
+    } | 
+    /** Status when the MediaKeySession failed to close. */
+    {
+        type: "failed";
+    } | 
+    /**
+     * Status when a close order has been received for this MediaKeySession
+     * while some sensitive operation (examples are `generateRequest` and `load`
+     * calls).
+     * The `LoadedSessionsStore` should call `start` once it has finished those
+     * operations.
+     */
+    {
+        type: "awaiting";
+        start: () => void;
+    } | 
+    /** Status when the MediaKeySession failed to close. */
+    {
+        type: "none";
+    };
 }