rx-player 3.26.2 → 3.27.0-dev.20220317

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

@@ -0,0 +1,77 @@
+/**
+ * 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 { Observable } from "rxjs";
+import { ICustomMediaKeySession } from "../../compat";
+import { ICustomError } from "../../errors";
+import { IEMEWarningEvent, IKeySystemOption } from "./types";
+/**
+ * Error thrown when the MediaKeySession is blacklisted.
+ * Such MediaKeySession should not be re-used but other MediaKeySession for the
+ * same content can still be used.
+ * @class BlacklistedSessionError
+ * @extends Error
+ */
+export declare class BlacklistedSessionError extends Error {
+    sessionError: ICustomError;
+    constructor(sessionError: ICustomError);
+}
+/**
+ * listen to various events from a MediaKeySession and react accordingly
+ * depending on the configuration given.
+ * @param {MediaKeySession} session - The MediaKeySession concerned.
+ * @param {Object} keySystemOptions - The key system options.
+ * @param {String} keySystem - The configuration keySystem used for deciphering
+ * @returns {Observable}
+ */
+export default function SessionEventsListener(session: MediaKeySession | ICustomMediaKeySession, keySystemOptions: IKeySystemOption, keySystem: string): Observable<IEMEWarningEvent | IKeysUpdateEvent>;
+/**
+ * Some key ids have updated their status.
+ *
+ * We put them in two different list:
+ *
+ *   - `blacklistedKeyIDs`: Those key ids won't be used for decryption and the
+ *     corresponding media it decrypts should not be pushed to the buffer
+ *     Note that a blacklisted key id can become whitelisted in the future.
+ *
+ *   - `whitelistedKeyIds`: Those key ids were found and their corresponding
+ *     keys are now being considered for decryption.
+ *     Note that a whitelisted key id can become blacklisted in the future.
+ *
+ * Note that each `IKeysUpdateEvent` is independent of any other.
+ *
+ * A new `IKeysUpdateEvent` does not completely replace a previously emitted
+ * one, as it can for example be linked to a whole other decryption session.
+ *
+ * However, if a key id is encountered in both an older and a newer
+ * `IKeysUpdateEvent`, only the older status should be considered.
+ */
+export interface IKeysUpdateEvent {
+    type: "keys-update";
+    value: IKeyUpdateValue;
+}
+/** Information on key ids linked to a MediaKeySession. */
+export interface IKeyUpdateValue {
+    /**
+     * The list of key ids that are blacklisted.
+     * As such, their corresponding keys won't be used by that session, despite
+     * the fact that they were part of the pushed license.
+     *
+     * Reasons for blacklisting a keys depend on options, but mainly involve unmet
+     * output restrictions and CDM internal errors linked to that key id.
+     */
+    blacklistedKeyIDs: Uint8Array[];
+    whitelistedKeyIds: Uint8Array[];
+}

package/dist/_esm5.processed/core/{eme → decrypt}/session_events_listener.js

@@ -28,7 +28,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { catchError, concat as observableConcat, concatMap, defer as observableDefer, EMPTY, identity, map, merge as observableMerge, mergeMap, of as observableOf, startWith, Subject, takeUntil, tap, timeout, TimeoutError, } from "rxjs";
+import { catchError, concat as observableConcat, concatMap, defer as observableDefer, EMPTY, identity, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, Subject, tap, takeUntil, timeout, TimeoutError, } from "rxjs";
 import { events, } from "../../compat";
 import { EncryptedMediaError, } from "../../errors";
 import log from "../../log";
@@ -37,7 +37,7 @@ import isNonEmptyString from "../../utils/is_non_empty_string";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import retryObsWithBackoff from "../../utils/rx-retry_with_backoff";
 import tryCatch from "../../utils/rx-try_catch";
-import checkKeyStatuses from "./check_key_statuses";
+import checkKeyStatuses from "./utils/check_key_statuses";
 var onKeyError$ = events.onKeyError$, onKeyMessage$ = events.onKeyMessage$, onKeyStatusesChange$ = events.onKeyStatusesChange$;
 /**
  * Error thrown when the MediaKeySession is blacklisted.
@@ -64,16 +64,15 @@ export { BlacklistedSessionError };
  * @param {MediaKeySession} session - The MediaKeySession concerned.
  * @param {Object} keySystemOptions - The key system options.
  * @param {String} keySystem - The configuration keySystem used for deciphering
- * @param {Object} initializationData - The initialization data linked to that
- * session.
  * @returns {Observable}
  */
-export default function SessionEventsListener(session, keySystemOptions, keySystem, initializationData) {
-    log.info("EME: Binding session events", session.sessionId);
+export default function SessionEventsListener(session, keySystemOptions, keySystem) {
+    log.info("DRM: Binding session events", session.sessionId);
     var sessionWarningSubject$ = new Subject();
     var _a = keySystemOptions.getLicenseConfig, getLicenseConfig = _a === void 0 ? {} : _a;
-    var keyErrors = onKeyError$(session)
-        .pipe(map(function (error) { throw new EncryptedMediaError("KEY_ERROR", error.type); }));
+    var keyErrors = onKeyError$(session).pipe(map(function (error) {
+        throw new EncryptedMediaError("KEY_ERROR", error.type);
+    }));
     var keyStatusesChange$ = onKeyStatusesChange$(session)
         .pipe(mergeMap(function (keyStatusesEvent) {
         return handleKeyStatusesChangeEvent(session, keySystemOptions, keySystem, keyStatusesEvent);
@@ -83,7 +82,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
         var messageType = isNonEmptyString(messageEvent.messageType) ?
             messageEvent.messageType :
             "license-request";
-        log.info("EME: Received message event, type ".concat(messageType), session.sessionId, messageEvent);
+        log.info("DRM: Received message event, type ".concat(messageType), session.sessionId, messageEvent);
         var getLicense$ = observableDefer(function () {
             var getLicense = keySystemOptions.getLicense(message, messageType);
             var getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
@@ -102,21 +101,24 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             if (!isNullOrUndefined(err)) {
                 var fallbackOnLastTry = err.fallbackOnLastTry;
                 if (fallbackOnLastTry === true) {
-                    log.warn("EME: Last `getLicense` attempt failed. " +
+                    log.warn("DRM: Last `getLicense` attempt failed. " +
                         "Blacklisting the current session.");
                     throw new BlacklistedSessionError(formattedError);
                 }
             }
             throw formattedError;
-        }), startWith({ type: "session-message",
-            value: { messageType: messageType, initializationData: initializationData } }));
+        }));
     }));
     var sessionUpdates = observableMerge(keyMessages$, keyStatusesChange$)
         .pipe(concatMap(function (evt) {
         switch (evt.type) {
             case "key-message-handled":
             case "key-status-change-handled":
-                return updateSessionWithMessage(session, evt.value.license, initializationData);
+                if (isNullOrUndefined(evt.value.license)) {
+                    log.info("DRM: No message given, skipping session.update");
+                    return EMPTY;
+                }
+                return updateSessionWithMessage(session, evt.value.license);
             default:
                 return observableOf(evt);
         }
@@ -177,22 +179,21 @@ function formatGetLicenseError(error) {
  * Returns the right event depending on the action taken.
  * @param {MediaKeySession} session
  * @param {ArrayBuffer|TypedArray|null} message
- * @param {Object} initializationData
  * @returns {Observable}
  */
-function updateSessionWithMessage(session, message, initializationData) {
-    if (isNullOrUndefined(message)) {
-        log.info("EME: No message given, skipping session.update");
-        return observableOf({ type: "no-update",
-            value: { initializationData: initializationData } });
-    }
-    log.info("EME: Updating MediaKeySession with message");
+function updateSessionWithMessage(session, message) {
+    log.info("DRM: Updating MediaKeySession with message");
     return castToObservable(session.update(message)).pipe(catchError(function (error) {
         var reason = error instanceof Error ? error.toString() :
             "`session.update` failed";
         throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason);
-    }), tap(function () { log.info("EME: MediaKeySession update succeeded."); }), map(function () { return ({ type: "session-updated",
-        value: { session: session, license: message, initializationData: initializationData } }); }));
+    }), tap(function () { log.info("DRM: MediaKeySession update succeeded."); }), 
+    // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+    // first type parameter as `any` instead of the perfectly fine `unknown`,
+    // leading to linter issues, as it forbids the usage of `any`.
+    // This is why we're disabling the eslint rule.
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
+    ignoreElements());
 }
 /**
  * @param {MediaKeySession}
@@ -201,7 +202,7 @@ function updateSessionWithMessage(session, message, initializationData) {
  * @returns {Observable}
  */
 function handleKeyStatusesChangeEvent(session, keySystemOptions, keySystem, keyStatusesEvent) {
-    log.info("EME: keystatuseschange event received", session.sessionId);
+    log.info("DRM: keystatuseschange event received", session.sessionId);
     var callback$ = observableDefer(function () {
         return tryCatch(function () {
             if (typeof keySystemOptions.onKeyStatusesChange !== "function") {

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

@@ -13,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { ICustomMediaKeys } from "../../compat";
-import { IEMEWarningEvent } from "./types";
+import { ICustomError } from "../../errors";
 /**
  * Call the setServerCertificate API with the given certificate.
- * Complete observable on success, throw when failed.
+ * Resolves on success, rejects on failure.
  *
  * TODO Handle returned value?
  * From the spec:
@@ -28,9 +27,9 @@ import { IEMEWarningEvent } from "./types";
  *
  * @param {MediaKeys} mediaKeys
  * @param {ArrayBuffer} serverCertificate
- * @returns {Observable}
+ * @returns {Promise}
  */
-declare function setServerCertificate(mediaKeys: ICustomMediaKeys | MediaKeys, serverCertificate: BufferSource): Observable<boolean>;
+declare function setServerCertificate(mediaKeys: ICustomMediaKeys | MediaKeys, serverCertificate: BufferSource): Promise<unknown>;
 /**
  * Call the setCertificate API. If it fails just emit the error as warning
  * and complete.
@@ -38,5 +37,15 @@ declare function setServerCertificate(mediaKeys: ICustomMediaKeys | MediaKeys, s
  * @param {ArrayBuffer} serverCertificate
  * @returns {Observable}
  */
-export default function trySettingServerCertificate(mediaKeys: ICustomMediaKeys | MediaKeys, serverCertificate: BufferSource): Observable<IEMEWarningEvent>;
+export default function trySettingServerCertificate(mediaKeys: ICustomMediaKeys | MediaKeys, serverCertificate: BufferSource): Promise<{
+    type: "success";
+    value: unknown;
+} | {
+    type: "already-has-one";
+} | {
+    type: "method-not-implemented";
+} | {
+    type: "error";
+    value: ICustomError;
+}>;
 export { trySettingServerCertificate, setServerCertificate, };

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

@@ -0,0 +1,141 @@
+/**
+ * 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 { EncryptedMediaError, isKnownError, } from "../../errors";
+import log from "../../log";
+import ServerCertificateStore from "./utils/server_certificate_store";
+/**
+ * Call the setServerCertificate API with the given certificate.
+ * Resolves on success, rejects on failure.
+ *
+ * TODO Handle returned value?
+ * From the spec:
+ *   - setServerCertificate resolves with true if everything worked
+ *   - it resolves with false if the CDM does not support server
+ *     certificates.
+ *
+ * @param {MediaKeys} mediaKeys
+ * @param {ArrayBuffer} serverCertificate
+ * @returns {Promise}
+ */
+function setServerCertificate(mediaKeys, serverCertificate) {
+    return __awaiter(this, void 0, void 0, function () {
+        var res, error_1, reason;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, mediaKeys.setServerCertificate(serverCertificate)];
+                case 1:
+                    res = _a.sent();
+                    // Note: Even if `setServerCertificate` technically should return a
+                    // Promise.<boolean>, this is not technically always true.
+                    // Thus we prefer to return unknown here.
+                    return [2 /*return*/, res];
+                case 2:
+                    error_1 = _a.sent();
+                    log.warn("DRM: mediaKeys.setServerCertificate returned an error", error_1);
+                    reason = error_1 instanceof Error ? error_1.toString() :
+                        "`setServerCertificate` error";
+                    throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason);
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Call the setCertificate API. If it fails just emit the error as warning
+ * and complete.
+ * @param {MediaKeys} mediaKeys
+ * @param {ArrayBuffer} serverCertificate
+ * @returns {Observable}
+ */
+export default function trySettingServerCertificate(mediaKeys, serverCertificate) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, error_2, formattedErr;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (ServerCertificateStore.hasOne(mediaKeys) === true) {
+                        log.info("DRM: The MediaKeys already has a server certificate, skipping...");
+                        return [2 /*return*/, { type: "already-has-one" }];
+                    }
+                    if (typeof mediaKeys.setServerCertificate !== "function") {
+                        log.warn("DRM: Could not set the server certificate." +
+                            " mediaKeys.setServerCertificate is not a function");
+                        return [2 /*return*/, { type: "method-not-implemented" }];
+                    }
+                    log.info("DRM: Setting server certificate on the MediaKeys");
+                    // Because of browser errors, or a user action that can lead to interrupting
+                    // server certificate setting, we might be left in a status where we don't
+                    // know if we attached the server certificate or not.
+                    // Calling `prepare` allow to invalidate temporarily that status.
+                    ServerCertificateStore.prepare(mediaKeys);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, setServerCertificate(mediaKeys, serverCertificate)];
+                case 2:
+                    result = _a.sent();
+                    ServerCertificateStore.set(mediaKeys, serverCertificate);
+                    return [2 /*return*/, { type: "success", value: result }];
+                case 3:
+                    error_2 = _a.sent();
+                    formattedErr = isKnownError(error_2) ?
+                        error_2 :
+                        new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", "Unknown error when setting the server certificate.");
+                    return [2 /*return*/, { type: "error", value: formattedErr }];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+export { trySettingServerCertificate, setServerCertificate, };