rx-player 3.26.2 → 3.27.0-dev.20220317

package/dist/_esm5.processed/core/{eme → decrypt}/attach_media_keys.d.ts

@@ -13,16 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat";
+import { CancellationSignal } from "../../utils/task_canceller";
 import { IKeySystemOption } from "./types";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 /**
- * Dispose the media keys on media element.
+ * Dispose of the MediaKeys instance attached to the given media element, if
+ * one.
  * @param {Object} mediaElement
+ */
+export declare function disableMediaKeys(mediaElement: HTMLMediaElement): void;
+/**
+ * Attach MediaKeys and its associated state to an HTMLMediaElement.
+ *
+ * /!\ Mutates heavily MediaKeysInfosStore
+ * @param {Object} mediaKeysInfos
+ * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-export declare function disableMediaKeys(mediaElement: HTMLMediaElement): Observable<unknown>;
+export default function attachMediaKeys(mediaElement: HTMLMediaElement, { keySystemOptions, loadedSessionsStore, mediaKeySystemAccess, mediaKeys }: IMediaKeysState, cancelSignal: CancellationSignal): Promise<void>;
 /** MediaKeys and associated state attached to a media element. */
 export interface IMediaKeysState {
     /** Options set when the MediaKeys has been attached. */
@@ -34,12 +43,3 @@ export interface IMediaKeysState {
     /** The MediaKeys instance to attach to the media element. */
     mediaKeys: MediaKeys | ICustomMediaKeys;
 }
-/**
- * Attach MediaKeys and its associated state to an HTMLMediaElement.
- *
- * /!\ Mutates heavily MediaKeysInfosStore
- * @param {Object} mediaKeysInfos
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-export default function attachMediaKeys(mediaElement: HTMLMediaElement, { keySystemOptions, loadedSessionsStore, mediaKeySystemAccess, mediaKeys }: IMediaKeysState): Observable<unknown>;

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

@@ -0,0 +1,104 @@
+/**
+ * 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 __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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { setMediaKeys, } from "../../compat";
+import log from "../../log";
+import PPromise from "../../utils/promise";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+/**
+ * Dispose of the MediaKeys instance attached to the given media element, if
+ * one.
+ * @param {Object} mediaElement
+ */
+export function disableMediaKeys(mediaElement) {
+    MediaKeysInfosStore.setState(mediaElement, null);
+    setMediaKeys(mediaElement, null);
+}
+/**
+ * Attach MediaKeys and its associated state to an HTMLMediaElement.
+ *
+ * /!\ Mutates heavily MediaKeysInfosStore
+ * @param {Object} mediaKeysInfos
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+export default function attachMediaKeys(mediaElement, _a, cancelSignal) {
+    var keySystemOptions = _a.keySystemOptions, loadedSessionsStore = _a.loadedSessionsStore, mediaKeySystemAccess = _a.mediaKeySystemAccess, mediaKeys = _a.mediaKeys;
+    return __awaiter(this, void 0, void 0, function () {
+        var previousState, closeAllSessions;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    previousState = MediaKeysInfosStore.getState(mediaElement);
+                    closeAllSessions = previousState !== null &&
+                        previousState.loadedSessionsStore !== loadedSessionsStore ?
+                        previousState.loadedSessionsStore.closeAllSessions() :
+                        PPromise.resolve();
+                    return [4 /*yield*/, closeAllSessions];
+                case 1:
+                    _b.sent();
+                    // If this task has been cancelled while we were closing previous sessions,
+                    // stop now (and thus avoid setting the new media keys);
+                    if (cancelSignal.isCancelled) {
+                        throw cancelSignal.cancellationError;
+                    }
+                    MediaKeysInfosStore.setState(mediaElement, { keySystemOptions: keySystemOptions, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, loadedSessionsStore: loadedSessionsStore });
+                    if (mediaElement.mediaKeys === mediaKeys) {
+                        return [2 /*return*/];
+                    }
+                    log.info("DRM: Attaching MediaKeys to the media element");
+                    setMediaKeys(mediaElement, mediaKeys);
+                    log.info("DRM: MediaKeys attached with success");
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/_esm5.processed/core/{eme/clear_eme_session.d.ts → decrypt/clear_on_stop.d.ts}

@@ -13,11 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 /**
- * Clear EME ressources that should be cleared when the current content stops
- * its playback.
+ * Clear DRM-related resources that should be cleared when the current content
+ * stops its playback.
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-export default function clearEMESession(mediaElement: HTMLMediaElement): Observable<never>;
+export default function clearOnStop(mediaElement: HTMLMediaElement): Promise<void>;

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

@@ -0,0 +1,41 @@
+/**
+ * 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 { shouldUnsetMediaKeys } from "../../compat/";
+import log from "../../log";
+import PPromise from "../../utils/promise";
+import disposeDecryptionResources from "./dispose_decryption_resources";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+/**
+ * Clear DRM-related resources that should be cleared when the current content
+ * stops its playback.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+export default function clearOnStop(mediaElement) {
+    log.info("DRM: Clearing-up DRM session.");
+    if (shouldUnsetMediaKeys()) {
+        log.info("DRM: disposing current MediaKeys.");
+        return disposeDecryptionResources(mediaElement);
+    }
+    var currentState = MediaKeysInfosStore.getState(mediaElement);
+    if (currentState !== null &&
+        currentState.keySystemOptions.closeSessionsOnStop === true) {
+        log.info("DRM: closing all current sessions.");
+        return currentState.loadedSessionsStore.closeAllSessions();
+    }
+    log.info("DRM: Nothing to clear. Returning right away. No state =", currentState === null);
+    return PPromise.resolve();
+}

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

@@ -0,0 +1,216 @@
+/**
+ * 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 { ICustomError } from "../../errors";
+import EventEmitter from "../../utils/event_emitter";
+import { IProtectionData, IKeySystemOption } from "./types";
+/**
+ * Module communicating with the Content Decryption Module (or CDM) to be able
+ * to decrypt contents.
+ *
+ * The `ContentDecryptor` starts communicating with the CDM, to initialize the
+ * key system, as soon as it is created.
+ *
+ * You can be notified of various events, such as fatal errors, by registering
+ * to one of its multiple events (@see IContentDecryptorEvent).
+ *
+ * @class ContentDecryptor
+ */
+export default class ContentDecryptor extends EventEmitter<IContentDecryptorEvent> {
+    /**
+     * Hexadecimal id identifying the currently-chosen key system.
+     * `undefined` if not known or if the key system hasn't been initialized yet.
+     *
+     * When providing protection initialization data to the ContentDecryptor, you
+     * may only provide those linked to that system id. You can also provide all
+     * available protection initialization data, in which case it will be
+     * automatically filtered.
+     *
+     * This `systemId` may only be known once the `ReadyForContent` state (@see
+     * ContentDecryptorState) is reached, and even then, it may still be unknown,
+     * in which case it will stay to `undefined`.
+     */
+    systemId: string | undefined;
+    /**
+     * Set only if the `ContentDecryptor` failed on an error.
+     * The corresponding Error.
+     */
+    error: Error | null;
+    /**
+     * State of the ContentDecryptor (@see ContentDecryptorState) and associated
+     * data.
+     *
+     * The ContentDecryptor goes into a series of steps as it is initializing.
+     * This private property stores the current state and the potentially linked
+     * data.
+     */
+    private _stateData;
+    /**
+     * Contains information about all key sessions loaded for this current
+     * content.
+     * This object is most notably used to check which keys are already obtained,
+     * thus avoiding to perform new unnecessary license requests and CDM interactions.
+     */
+    private _currentSessions;
+    /**
+     * Allows to dispose the resources taken by the current instance of the
+     * ContentDecryptor.
+     */
+    private _canceller;
+    /**
+     * `true` once the `attach` method has been called`.
+     * Allows to avoid calling multiple times that function.
+     */
+    private _wasAttachCalled;
+    /**
+     * This queue stores initialization data which hasn't been processed yet,
+     * probably because the "queue is locked" for now. (@see _stateData private
+     * property).
+     *
+     * For example, this queue stores initialization data communicated while
+     * initializing so it can be processed when the initialization is done.
+     */
+    private _initDataQueue;
+    /**
+     * Create a new `ContentDecryptor`, and initialize its decryption capabilities
+     * right away.
+     * Goes into the `WaitingForAttachment` state once that initialization is
+     * done, after which you should call the `attach` method when you're ready for
+     * those decryption capabilities to be attached to the HTMLMediaElement.
+     *
+     * @param {HTMLMediaElement} mediaElement - The MediaElement which will be
+     * associated to a MediaKeys object
+     * @param {Array.<Object>} ksOptions - key system configuration.
+     * The `ContentDecryptor` can be given one or multiple key system
+     * configurations. It will choose the appropriate one depending on user
+     * settings and browser support.
+     */
+    constructor(mediaElement: HTMLMediaElement, ksOptions: IKeySystemOption[]);
+    /**
+     * Returns the current state of the ContentDecryptor.
+     * @see ContentDecryptorState
+     * @returns {Object}
+     */
+    getState(): ContentDecryptorState;
+    /**
+     * Attach the current decryption capabilities to the HTMLMediaElement.
+     * This method should only be called once the `ContentDecryptor` is in the
+     * `WaitingForAttachment` state.
+     *
+     * You might want to first set the HTMLMediaElement's `src` attribute before
+     * calling this method, and only push data to it once the `ReadyForContent`
+     * state is reached, for compatibility reasons.
+     */
+    attach(): void;
+    /**
+     * Stop this `ContentDecryptor` instance:
+     *   - stop listening and reacting to the various event listeners
+     *   - abort all operations.
+     *
+     * Once disposed, a `ContentDecryptor` cannot be used anymore.
+     */
+    dispose(): void;
+    /**
+     * Method to call when new protection initialization data is encounted on the
+     * content.
+     *
+     * When called, the `ContentDecryptor` will try to obtain the decryption key
+     * if not already obtained.
+     *
+     * @param {Object} initializationData
+     */
+    onInitializationData(initializationData: IProtectionData): void;
+    /**
+     * Async logic run each time new initialization data has to be processed.
+     * The promise return may reject, in which case a fatal error should be linked
+     * the current `ContentDecryptor`.
+     *
+     * The Promise's resolution however provides no semantic value.
+     * @param {Object} initializationData
+     * @returns {Promise.<void>}
+     */
+    private _processInitializationData;
+    private _tryToUseAlreadyCreatedSession;
+    private _onFatalError;
+    /**
+     * Return `true` if the `ContentDecryptor` has either been disposed or
+     * encountered a fatal error which made it stop.
+     * @returns {boolean}
+     */
+    private _isStopped;
+    private _processCurrentInitDataQueue;
+    private _lockInitDataQueue;
+    private _unlockInitDataQueue;
+}
+/** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */
+export interface IContentDecryptorEvent {
+    /**
+     * Event emitted when a major error occured which made the ContentDecryptor
+     * stopped.
+     * When that event is sent, the `ContentDecryptor` is in the `Error` state and
+     * cannot be used anymore.
+     */
+    error: Error;
+    /**
+     * Event emitted when a minor error occured which the ContentDecryptor can
+     * recover from.
+     */
+    warning: ICustomError;
+    /**
+     * Event emitted when the `ContentDecryptor`'s state changed.
+     * States are a central aspect of the `ContentDecryptor`, be sure to check the
+     * ContentDecryptorState type.
+     */
+    stateChange: ContentDecryptorState;
+}
+/** Enumeration of the various "state" the `ContentDecryptor` can be in. */
+export declare enum ContentDecryptorState {
+    /**
+     * The `ContentDecryptor` is not yet ready to create key sessions and request
+     * licenses.
+     * This is is the initial state of the ContentDecryptor.
+     */
+    Initializing = 0,
+    /**
+     * The `ContentDecryptor` has been initialized.
+     * You should now called the `attach` method when you want to add decryption
+     * capabilities to the HTMLMediaElement. The ContentDecryptor won't go to the
+     * `ReadyForContent` state until `attach` is called.
+     *
+     * For compatibility reasons, this should be done after the HTMLMediaElement's
+     * src attribute is set.
+     *
+     * It is also from when this state is reached that the `ContentDecryptor`'s
+     * `systemId` property may be known.
+     *
+     * This state is always coming after the `Initializing` state.
+     */
+    WaitingForAttachment = 1,
+    /**
+     * Content (encrypted or not) can begin to be pushed on the HTMLMediaElement
+     * (this state was needed because some browser quirks sometimes forces us to
+     * call EME API before this can be done).
+     *
+     * This state is always coming after the `WaitingForAttachment` state.
+     */
+    ReadyForContent = 2,
+    /**
+     * The `ContentDecryptor` has encountered a fatal error and has been stopped.
+     * It is now unusable.
+     */
+    Error = 3,
+    /** The `ContentDecryptor` has been disposed of and is now unusable. */
+    Disposed = 4
+}