rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/commonjs/main_thread/decrypt/utils/key_session_record.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var are_arrays_of_numbers_equal_1 = require("../../../utils/are_arrays_of_numbers_equal");
+var key_id_comparison_1 = require("./key_id_comparison");
+/**
+ * Class storing key-related information linked to a created `MediaKeySession`.
+ *
+ * This class allows to regroup one or multiple key ids and can be linked to a
+ * single MediaKeySession so you can know which key that MediaKeySession
+ * handles.
+ *
+ * The main use case behind the complexities of this `KeySessionRecord` is to
+ * better handle the `singleLicensePer` RxPlayer option, which allows the
+ * recuperation of a license containing multiple keys, even if only one of
+ * those keys was asked for (which in turn allows to reduce the number of
+ * requests and to improve performance).
+ * Here, the `KeySessionRecord` will regroup all those key's id and can be
+ * linked to the corresponding MediaKeySession.
+ * That way, you can later check if another encrypted content is compatible with
+ * that session through the `KeySessionRecord`'s `isCompatibleWith` method.
+ *
+ * @example
+ * ```js
+ * const record = new KeySessionRecord(initData);
+ *
+ * // Create a MediaKeySession linked to that initialization data and fetch the
+ * // license
+ * // ...
+ *
+ * // Once the license has been loaded to the MediaKeySession linked to that
+ - // initialization data, associate the license's key Ids with the latter.
+ * record.associateKeyIds(someKeyIds);
+ *
+ * // Function called when new initialization data is encountered
+ * function onNewInitializationData(newInitializationData) {
+ *   if (record.isCompatibleWith(newInitializationData)) {
+ *     console.log("This initialization data should already be handled, ignored.");
+ *   } else {
+ *     console.log("This initialization data is not handled yet.";
+ *   }
+ * }
+ * ```
+ * @class KeySessionRecord
+ */
+var KeySessionRecord = /** @class */ (function () {
+    /**
+     * Create a new `KeySessionRecord`, linked to its corresponding initialization
+     * data,
+     * @param {Object} initializationData
+     */
+    function KeySessionRecord(initializationData) {
+        this._initializationData = initializationData;
+        this._keyIds = null;
+    }
+    /**
+     * Associate supplementary key ids to this `KeySessionRecord` so it becomes
+     * "compatible" to them.
+     *
+     * After this call, new initialization data linked to subsets of those key
+     * ids will be considered compatible  to this `KeySessionRecord` (calls to
+     * `isCompatibleWith` with the corresponding initialization data will return
+     * `true`).
+     * @param {Array.<Uint8Array>} keyIds
+     */
+    KeySessionRecord.prototype.associateKeyIds = function (keyIds) {
+        var e_1, _a;
+        if (this._keyIds === null) {
+            this._keyIds = [];
+        }
+        var keyIdsArr = Array.from(keyIds);
+        try {
+            for (var keyIdsArr_1 = __values(keyIdsArr), keyIdsArr_1_1 = keyIdsArr_1.next(); !keyIdsArr_1_1.done; keyIdsArr_1_1 = keyIdsArr_1.next()) {
+                var keyId = keyIdsArr_1_1.value;
+                if (!this.isAssociatedWithKeyId(keyId)) {
+                    this._keyIds.push(keyId);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (keyIdsArr_1_1 && !keyIdsArr_1_1.done && (_a = keyIdsArr_1.return)) _a.call(keyIdsArr_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    /**
+     * @param {Uint8Array} keyId
+     * @returns {boolean}
+     */
+    KeySessionRecord.prototype.isAssociatedWithKeyId = function (keyId) {
+        var e_2, _a;
+        if (this._keyIds === null) {
+            return false;
+        }
+        try {
+            for (var _b = __values(this._keyIds), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var storedKeyId = _c.value;
+                if ((0, are_arrays_of_numbers_equal_1.default)(storedKeyId, keyId)) {
+                    return true;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return false;
+    };
+    /**
+     * @returns {Array.<Uint8Array>}
+     */
+    KeySessionRecord.prototype.getAssociatedKeyIds = function () {
+        if (this._keyIds === null) {
+            return [];
+        }
+        return this._keyIds;
+    };
+    /**
+     * Check if that `KeySessionRecord` is compatible to the initialization data
+     * given.
+     *
+     * If it returns `true`, it means that this `KeySessionRecord` is already
+     * linked to that initialization data's key. As such, if that
+     * `KeySessionRecord` is already associated to an active MediaKeySession for
+     * example, the content linked to that initialization data should already be
+     * handled.
+     *
+     * If it returns `false`, it means that this `KeySessionRecord` has no
+     * relation with the given initialization data.
+     *
+     * @param {Object} initializationData
+     * @returns {boolean}
+     */
+    KeySessionRecord.prototype.isCompatibleWith = function (initializationData) {
+        var keyIds = initializationData.keyIds;
+        if (keyIds !== undefined && keyIds.length > 0) {
+            if (this._keyIds !== null && (0, key_id_comparison_1.areAllKeyIdsContainedIn)(keyIds, this._keyIds)) {
+                return true;
+            }
+            if (this._initializationData.keyIds !== undefined) {
+                return (0, key_id_comparison_1.areAllKeyIdsContainedIn)(keyIds, this._initializationData.keyIds);
+            }
+        }
+        return this._checkInitializationDataCompatibility(initializationData);
+    };
+    KeySessionRecord.prototype._checkInitializationDataCompatibility = function (initializationData) {
+        if (initializationData.keyIds !== undefined &&
+            initializationData.keyIds.length > 0 &&
+            this._initializationData.keyIds !== undefined) {
+            return (0, key_id_comparison_1.areAllKeyIdsContainedIn)(initializationData.keyIds, this._initializationData.keyIds);
+        }
+        if (this._initializationData.type !== initializationData.type) {
+            return false;
+        }
+        return this._initializationData.values.isCompatibleWith(initializationData.values);
+    };
+    return KeySessionRecord;
+}());
+exports.default = KeySessionRecord;

package/dist/commonjs/main_thread/decrypt/utils/loaded_sessions_store.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IMediaKeySession, IMediaKeys } from "../../../compat/browser_compatibility_types";
+import type { IProcessedProtectionData } from "../types";
+import KeySessionRecord from "./key_session_record";
+/**
+ * Create and store MediaKeySessions linked to a single MediaKeys
+ * instance.
+ *
+ * Keep track of sessionTypes and of the initialization data each
+ * MediaKeySession is created for.
+ * @class LoadedSessionsStore
+ */
+export default class LoadedSessionsStore {
+    /** MediaKeys instance on which the MediaKeySessions are created. */
+    private readonly _mediaKeys;
+    /** Store unique MediaKeySession information per initialization data. */
+    private _storage;
+    /**
+     * Create a new LoadedSessionsStore, which will store information about
+     * loaded MediaKeySessions on the given MediaKeys instance.
+     * @param {MediaKeys} mediaKeys
+     */
+    constructor(mediaKeys: IMediaKeys);
+    /**
+     * Create a new MediaKeySession and store it in this store.
+     * @param {Object} initData
+     * @param {string} sessionType
+     * @returns {Object}
+     */
+    createSession(initData: IProcessedProtectionData, sessionType: MediaKeySessionType): IStoredSessionEntry;
+    /**
+     * Find a stored entry compatible with the initialization data given and moves
+     * this entry at the end of the `LoadedSessionsStore`''s storage, returned by
+     * its `getAll` method.
+     *
+     * This can be used for example to tell when a previously-stored
+     * entry is re-used to then be able to implement a caching replacement
+     * algorithm based on the least-recently-used values by just evicting the first
+     * values returned by `getAll`.
+     * @param {Object} initializationData
+     * @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: IMediaKeySession): 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|undefined} 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: IMediaKeySession, initializationDataType: string | undefined, initializationData: Uint8Array<ArrayBuffer>): Promise<unknown>;
+    /**
+     * @param {Object} mediaKeySession
+     * @param {string} sessionId
+     * @returns {Promise}
+     */
+    loadPersistentSession(mediaKeySession: IMediaKeySession, sessionId: string): Promise<boolean>;
+    /**
+     * Close a MediaKeySession and remove its related stored information from the
+     * `LoadedSessionsStore`.
+     * Emit when done.
+     * @param {Object} mediaKeySession
+     * @returns {Promise}
+     */
+    closeSession(mediaKeySession: IMediaKeySession): Promise<boolean>;
+    /**
+     * Returns the number of stored MediaKeySessions in this LoadedSessionsStore.
+     * @returns {number}
+     */
+    getLength(): number;
+    /**
+     * Returns information about all stored MediaKeySession, in the order in which
+     * the MediaKeySession have been created.
+     * @returns {Array.<Object>}
+     */
+    getAll(): IStoredSessionEntry[];
+    /**
+     * Close all sessions in this store.
+     * Emit `null` when done.
+     * @returns {Promise}
+     */
+    closeAllSessions(): Promise<void>;
+    /**
+     * Find the given `MediaKeySession` in the `LoadedSessionsStore` and removes
+     * any reference to it without actually closing it.
+     *
+     * Returns `true` if the given `mediaKeySession` has been found and removed,
+     * `false` otherwise.
+     *
+     * Note that this may create a `MediaKeySession` leakage in the wrong
+     * conditions, cases where this method should be called should be very
+     * carefully evaluated.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {boolean}
+     */
+    removeSessionWithoutClosingIt(mediaKeySession: IMediaKeySession): boolean;
+    /**
+     * 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 {
+    /**
+     * The `KeySessionRecord` linked to the MediaKeySession.
+     * It keeps track of all key ids that are currently known to be associated to
+     * the MediaKeySession.
+     *
+     * Initially only assiociated with the initialization data given, you may want
+     * to add to it other key ids if you find out that there are also linked to
+     * that session.
+     *
+     * Regrouping all those key ids into the `KeySessionRecord` in that way allows
+     * the `LoadedSessionsStore` to perform compatibility checks when future
+     * initialization data is encountered.
+     */
+    keySessionRecord: KeySessionRecord;
+    /** The MediaKeySession created. */
+    mediaKeySession: IMediaKeySession;
+    /**
+     * The MediaKeySessionType (e.g. "temporary" or "persistent-license") with
+     * 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: {
+        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";
+    };
+}
+//# sourceMappingURL=loaded_sessions_store.d.ts.map

package/dist/commonjs/main_thread/decrypt/utils/loaded_sessions_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loaded_sessions_store.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/decrypt/utils/loaded_sessions_store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACX,MAAM,6CAA6C,CAAC;AAKrD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,gBAAgB,MAAM,sBAAsB,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB;IACtC,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IAExC,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAwB;IAExC;;;;OAIG;gBACS,SAAS,EAAE,UAAU;IAKjC;;;;;OAKG;IACI,aAAa,CAClB,QAAQ,EAAE,wBAAwB,EAClC,WAAW,EAAE,mBAAmB,GAC/B,mBAAmB;IAqCtB;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,kBAAkB,EAAE,wBAAwB,GAAG,mBAAmB,GAAG,IAAI;IAgBtF;;;;;;OAMG;IACI,kBAAkB,CACvB,eAAe,EAAE,gBAAgB,GAChC,mBAAmB,GAAG,IAAI;IAU7B;;;;;;;;;;OAUG;IACU,sBAAsB,CACjC,eAAe,EAAE,gBAAgB,EACjC,sBAAsB,EAAE,MAAM,GAAG,SAAS,EAC1C,kBAAkB,EAAE,UAAU,CAAC,WAAW,CAAC,GAC1C,OAAO,CAAC,OAAO,CAAC;IAqDnB;;;;OAIG;IACU,qBAAqB,CAChC,eAAe,EAAE,gBAAgB,EACjC,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC;IA8CnB;;;;;;OAMG;IACU,YAAY,CAAC,eAAe,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAkB9E;;;OAGG;IACI,SAAS,IAAI,MAAM;IAI1B;;;;OAIG;IACI,MAAM,IAAI,mBAAmB,EAAE;IAItC;;;;OAIG;IACU,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAe9C;;;;;;;;;;;;OAYG;IACI,6BAA6B,CAAC,eAAe,EAAE,gBAAgB,GAAG,OAAO;IAkBhF;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAUhB;;;;;;;OAOG;YACW,WAAW;CAkC1B;AAED,sFAAsF;AACtF,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;OAYG;IACH,gBAAgB,EAAE,gBAAgB,CAAC;IAEnC,mCAAmC;IACnC,eAAe,EAAE,gBAAgB,CAAC;IAElC;;;OAGG;IACH,WAAW,EAAE,mBAAmB,CAAC;IAEjC;;;;OAIG;IACH,mBAAmB,EAAE,OAAO,CAAC;IAE7B;;;;OAIG;IACH,0BAA0B,EAAE,OAAO,CAAC;IAEpC;;;;;;;;;;OAUG;IACH,aAAa,EACX;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE;IACnB,uDAAuD;OACrD;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;IAClB,uDAAuD;OACrD;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE;IACpB;;;;;;OAMG;OACD;QACE,IAAI,EAAE,UAAU,CAAC;QACjB,KAAK,EAAE,MAAM,IAAI,CAAC;KACnB;IACH,uDAAuD;OACrD;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACtB"}