rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/core/eme/init_media_keys.ts

@@ -1,106 +0,0 @@
-/**
- * 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 {
-  filter,
-  mapTo,
-  mergeMap,
-  Observable,
-  of as observableOf,
-  startWith,
-  take,
-} from "rxjs";
-import log from "../../log";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import createSharedReference from "../../utils/reference";
-import attachMediaKeys, {
-  disableMediaKeys,
-} from "./attach_media_keys";
-import getDrmSystemId from "./get_drm_system_id";
-import getMediaKeysInfos from "./get_media_keys";
-import {
-  IAttachedMediaKeysEvent,
-  ICreatedMediaKeysEvent,
-  IKeySystemOption,
-} from "./types";
-
-/**
- * Get media keys infos from key system configs then attach media keys to media element.
- * @param {HTMLMediaElement} mediaElement
- * @param {Array.<Object>} keySystemsConfigs
- * @returns {Observable}
- */
-export default function initMediaKeys(
-  mediaElement : HTMLMediaElement,
-  keySystemsConfigs: IKeySystemOption[]
-): Observable<ICreatedMediaKeysEvent|IAttachedMediaKeysEvent> {
-  return getMediaKeysInfos(mediaElement, keySystemsConfigs)
-    .pipe(mergeMap(({ mediaKeys, mediaKeySystemAccess, stores, options }) => {
-
-      /**
-       * String identifying the key system, allowing the rest of the code to
-       * only advertise the required initialization data for license requests.
-       *
-       * Note that we only set this value if retro-compatibility to older
-       * persistent logic in the RxPlayer is not important, as the optimizations
-       * this property unlocks can break the loading of MediaKeySessions
-       * persisted in older RxPlayer's versions.
-       */
-      let initializationDataSystemId : string | undefined;
-      if (isNullOrUndefined(options.licenseStorage) ||
-          options.licenseStorage.disableRetroCompatibility === true)
-      {
-        initializationDataSystemId = getDrmSystemId(mediaKeySystemAccess.keySystem);
-      }
-
-      const canAttachMediaKeys = createSharedReference(false);
-      const shouldDisableOldMediaKeys =
-        mediaElement.mediaKeys !== null &&
-        mediaElement.mediaKeys !== undefined &&
-        mediaKeys !== mediaElement.mediaKeys;
-
-      let disableOldMediaKeys$ : Observable<unknown> = observableOf(null);
-      if (shouldDisableOldMediaKeys) {
-        log.debug("EME: Disabling old MediaKeys");
-        disableOldMediaKeys$ = disableMediaKeys(mediaElement);
-      }
-      return disableOldMediaKeys$.pipe(
-        mergeMap(() => {
-          log.debug("EME: Attaching current MediaKeys");
-          return canAttachMediaKeys.asObservable().pipe(
-            filter(canAttach => canAttach),
-            mergeMap(() => {
-              const stateToAttatch = { loadedSessionsStore: stores.loadedSessionsStore,
-                                       mediaKeySystemAccess,
-                                       mediaKeys,
-                                       keySystemOptions: options };
-              return attachMediaKeys(mediaElement, stateToAttatch);
-            }),
-            take(1),
-            mapTo({ type: "attached-media-keys" as const,
-                    value: { mediaKeySystemAccess, mediaKeys, stores, options } }),
-            startWith({ type: "created-media-keys" as const,
-                        value: { mediaKeySystemAccess,
-                                 initializationDataSystemId,
-                                 mediaKeys,
-                                 stores,
-                                 options,
-                                 canAttachMediaKeys } })
-          );
-        })
-      );
-    }));
-}

package/src/core/eme/set_server_certificate.ts

@@ -1,115 +0,0 @@
-/**
- * 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 {
-  catchError,
-  defer as observableDefer,
-  EMPTY,
-  ignoreElements,
-  tap,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import { ICustomMediaKeys } from "../../compat";
-import { EncryptedMediaError } from "../../errors";
-import log from "../../log";
-import castToObservable from "../../utils/cast_to_observable";
-import tryCatch from "../../utils/rx-try_catch";
-import ServerCertificateStore from "./server_certificate_store";
-import { IEMEWarningEvent } from "./types";
-
-/**
- * Call the setServerCertificate API with the given certificate.
- * Complete observable on success, throw when failed.
- *
- * 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 {Observable}
- */
-function setServerCertificate(
-  mediaKeys : ICustomMediaKeys|MediaKeys,
-  serverCertificate : BufferSource
-) : Observable<boolean> {
-  return observableDefer(() => {
-    return tryCatch<void, boolean>(() =>
-      castToObservable(
-        (mediaKeys as MediaKeys).setServerCertificate(serverCertificate)
-      )
-    , undefined).pipe(catchError((error: unknown) => {
-      log.warn("EME: mediaKeys.setServerCertificate returned an error", error);
-      const reason = error instanceof Error ? error.toString() :
-                                              "`setServerCertificate` error";
-      throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason);
-    }));
-  });
-}
-
-/**
- * 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 : ICustomMediaKeys|MediaKeys,
-  serverCertificate : BufferSource
-) : Observable<IEMEWarningEvent> {
-  return observableDefer(() => {
-    if (typeof mediaKeys.setServerCertificate !== "function") {
-      log.warn("EME: Could not set the server certificate." +
-               " mediaKeys.setServerCertificate is not a function");
-      return EMPTY;
-    }
-
-    if (ServerCertificateStore.hasOne(mediaKeys) === true) {
-      log.info("EME: The MediaKeys already has a server certificate, skipping...");
-      return EMPTY;
-    }
-
-    log.info("EME: 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);
-    return setServerCertificate(mediaKeys, serverCertificate).pipe(
-      tap(() => { ServerCertificateStore.set(mediaKeys, serverCertificate); }),
-
-      // 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 @typescript-eslint/no-unsafe-argument */
-      ignoreElements(),
-      catchError(error => observableOf({
-        type: "warning" as const,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        value: error,
-      })));
-  });
-}
-
-export {
-  trySettingServerCertificate,
-  setServerCertificate,
-};

package/src/core/eme/utils/close_session.ts

@@ -1,113 +0,0 @@
-/**
- * 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 {
-  catchError,
-  mergeMap,
-  Observable,
-  of as observableOf,
-  take,
-  tap,
-  timer,
-  race as observableRace,
-} from "rxjs";
-import {
-  closeSession,
-  ICustomMediaKeySession,
-} from "../../../compat";
-import { onKeyMessage$, onKeyStatusesChange$ } from "../../../compat/event_listeners";
-import config from "../../../config";
-import log from "../../../log";
-
-const { EME_SESSION_CLOSING_MAX_RETRY,
-        EME_SESSION_CLOSING_INITIAL_DELAY,
-        EME_SESSION_CLOSING_MAX_DELAY } = config;
-
-/**
- * Close a MediaKeySession with multiple attempts if needed and do not throw if
- * this action throws an error.
- * Emits then complete when done.
- * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
- */
-export default function safelyCloseMediaKeySession(
-  mediaKeySession : MediaKeySession | ICustomMediaKeySession
-) : Observable<unknown> {
-  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 : number
-  ) : Observable<unknown> {
-    log.debug("EME: Trying to close a MediaKeySession",
-              mediaKeySession.sessionId,
-              retryNb);
-    return closeSession(mediaKeySession).pipe(
-      tap(() => { log.debug("EME: Succeeded to close MediaKeySession"); }),
-      catchError((err : unknown) => {
-        // 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 instanceof Error) || err.name !== "InvalidStateError" ||
-            mediaKeySession.sessionId !== "")
-        {
-          return failToCloseSession(err);
-        }
-
-        // We will retry either:
-        //   - when an event indicates that the MediaKeySession is
-        //     initialized (`callable` is the proper EME term here)
-        //   - after a delay, raising exponentially
-        const nextRetryNb = retryNb + 1;
-        if (nextRetryNb > EME_SESSION_CLOSING_MAX_RETRY) {
-          return failToCloseSession(err);
-        }
-        const delay = Math.min(Math.pow(2, retryNb) * EME_SESSION_CLOSING_INITIAL_DELAY,
-                               EME_SESSION_CLOSING_MAX_DELAY);
-        log.warn("EME: attempt to close a mediaKeySession failed, " +
-                 "scheduling retry...", delay);
-        return observableRace([timer(delay),
-                               onKeyStatusesChange$(mediaKeySession),
-                               onKeyMessage$(mediaKeySession)])
-          .pipe(
-            take(1),
-            mergeMap(() => recursivelyTryToCloseMediaKeySession(nextRetryNb)));
-      }));
-  }
-
-  /**
-   * Log error anouncing that we could not close the MediaKeySession and emits
-   * then complete through Observable.
-   * TODO Emit warning?
-   * @returns {Observable}
-   */
-  function failToCloseSession(err : unknown) : Observable<null> {
-    log.error("EME: Could not close MediaKeySession: " +
-              (err instanceof Error ? err.toString() :
-                                      "Unknown error"));
-    return observableOf(null);
-  }
-}

package/src/core/eme/utils/init_data_store.ts

@@ -1,234 +0,0 @@
-/**
- * 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 hashBuffer from "../../../utils/hash_buffer";
-import { IInitializationDataInfo } from "../types";
-import areInitializationValuesCompatible from "./are_init_values_compatible";
-
-/**
- * Store a unique value associated to an initData and initDataType.
- * @class InitDataStore
- */
-export default class InitDataStore<T> {
-  /**
-   * Contains every stored elements alongside the corresponding initialization
-   * data, in storage chronological order (from first stored to last stored).
-   */
-  private _storage : Array<{
-    /** Initialization data type. */
-    type : string | undefined;
-    /** Every initialization data for that type. */
-    values: Array<{
-      /** Hex encoded system id, which identifies the key system. */
-      systemId : string | undefined;
-      /** The initialization data itself for that type and systemId. */
-      data: Uint8Array;
-      /**
-       * A hash of the `data` property, done with the `hashBuffer` util, for
-       * faster comparison.
-       */
-      hash : number;
-    }>;
-    payload : T;
-  }>;
-
-  /** Construct a new InitDataStore.  */
-  constructor() {
-    this._storage = [];
-  }
-
-  /**
-   * Returns all stored value, in the order in which they have been stored.
-   * Note: it is possible to move a value to the end of this array by calling
-   * the `getAndReuse` method.
-   * @returns {Array}
-   */
-  public getAll() : T[] {
-    return this._storage.map(item => item.payload);
-  }
-
-  /**
-   * Returns the number of stored values.
-   * @returns {number}
-   */
-  public getLength() : number {
-    return this._storage.length;
-  }
-
-  /**
-   * Returns `true` if no initialization data is stored yet in this
-   * InitDataStore.
-   * Returns `false` otherwise.
-   * @returns {boolean}
-   */
-  public isEmpty() : boolean {
-    return this._storage.length === 0;
-  }
-
-  /**
-   * Returns the element associated with the given initData and initDataType.
-   * Returns `undefined` if not found.
-   * @param {Uint8Array} initData
-   * @param {string|undefined} initDataType
-   * @returns {*}
-   */
-  public get(initializationData : IInitializationDataInfo) : T | undefined {
-    const index = this._findIndex(initializationData);
-    return index >= 0 ? this._storage[index].payload :
-                        undefined;
-  }
-
-  /**
-   * Like `get`, but also move the corresponding value at the end of the store
-   * (as returned by `getAll`) if found.
-   * This can be used for example to tell when a previously-stored value 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 {Uint8Array} initData
-   * @param {string|undefined} initDataType
-   * @returns {*}
-   */
-  public getAndReuse(
-    initializationData : IInitializationDataInfo
-  ) : T | undefined {
-    const index = this._findIndex(initializationData);
-    if (index === -1) {
-      return undefined;
-    }
-    const item = this._storage.splice(index, 1)[0];
-    this._storage.push(item);
-    return item.payload;
-  }
-
-  /**
-   * Add to the store a value linked to the corresponding initData and
-   * initDataType.
-   * If a value was already stored linked to those, replace it.
-   * @param {Object} initializationData
-   * @param {*} payload
-   */
-  public store(
-    initializationData : IInitializationDataInfo,
-    payload : T
-  ) : void {
-    const indexOf = this._findIndex(initializationData);
-    if (indexOf >= 0) {
-      // this._storage contains the stored value in the same order they have
-      // been put. So here we want to remove the previous element and re-push
-      // it to the end.
-      this._storage.splice(indexOf, 1);
-    }
-    const values = this._formatValuesForStore(initializationData.values);
-    this._storage.push({ type: initializationData.type,
-                         values,
-                         payload });
-  }
-
-  /**
-   * Add to the store a value linked to the corresponding initData and
-   * initDataType.
-   * If a value linked to those was already stored, do nothing and returns
-   * `false`.
-   * If not, add the value and return `true`.
-   *
-   * This can be used as a more performant version of doing both a `get` call -
-   * to see if a value is stored linked to that data - and then if not doing a
-   * store. `storeIfNone` is more performant as it will only perform hashing
-   * and a look-up a single time.
-   * @param {Object} initializationData
-   * @param {*} payload
-   * @returns {boolean}
-   */
-  public storeIfNone(
-    initializationData : IInitializationDataInfo,
-    payload : T
-  ) : boolean {
-    const indexOf = this._findIndex(initializationData);
-    if (indexOf >= 0) {
-      return false;
-    }
-    const values = this._formatValuesForStore(initializationData.values);
-    this._storage.push({ type: initializationData.type,
-                         values,
-                         payload });
-    return true;
-  }
-
-  /**
-   * Remove an initDataType and initData combination from this store.
-   * Returns the associated value if it has been found, `undefined` otherwise.
-   * @param {Uint8Array} initData
-   * @param {string|undefined} initDataType
-   * @returns {*}
-   */
-  public remove(initializationData : IInitializationDataInfo) : T | undefined {
-    const indexOf = this._findIndex(initializationData);
-    if (indexOf === -1) {
-      return undefined;
-    }
-    return this._storage.splice(indexOf, 1)[0].payload;
-  }
-
-  /**
-   * Find the index of the corresponding initialization data in `this._storage`.
-   * Returns `-1` if not found.
-   * @param {Object} initializationData
-   * @returns {boolean}
-   */
-  private _findIndex(
-    initializationData : IInitializationDataInfo
-  ) : number {
-    const formattedVals = this._formatValuesForStore(initializationData.values);
-
-
-    // Begin by the last element as we usually re-encounter the last stored
-    // initData sooner than the first one.
-    for (let i = this._storage.length - 1; i >= 0; i--) {
-      const stored = this._storage[i];
-      if (stored.type === initializationData.type) {
-        if (areInitializationValuesCompatible(stored.values, formattedVals)) {
-          return i;
-        }
-      }
-    }
-    return -1;
-  }
-
-  /**
-   * Format given initializationData's values so they are ready to be stored:
-   *   - sort them by systemId, so they are faster to compare
-   *   - add hash for each initialization data encountered.
-   * @param {Array.<Object>} initialValues
-   * @returns {Array.<Object>}
-   */
-  private _formatValuesForStore(
-    initialValues : Array<{ systemId : string | undefined;
-                            data : Uint8Array; }>
-  ) : Array<{ systemId : string | undefined;
-              hash : number;
-              data : Uint8Array; }> {
-    return initialValues.slice()
-      .sort((a, b) => a.systemId === b.systemId ? 0 :
-                      a.systemId === undefined  ? 1 :
-                      b.systemId === undefined  ? -1 :
-                      a.systemId < b.systemId   ? -1 :
-                      1)
-      .map(({ systemId, data }) => ({ systemId,
-                                      data,
-                                      hash: hashBuffer(data) }));
-  }
-}