rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

package/src/core/eme/__tests__/init_media_keys.test.ts

@@ -1,182 +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.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-
-import {
-  of as observableOf,
-  skip,
-  take,
-  tap,
-  throwError,
-} from "rxjs";
-
-describe("core - eme - initMediaKeys", () => {
-  beforeEach(() => {
-    jest.resetModules();
-  });
-
-  it("should emit `created-media-keys` event once MediaKeys has been created", done => {
-    const fakeResult = { mediaKeySystemAccess: { a: 5, keySystem: "toto" },
-                         mediaKeys: { b: 4 },
-                         stores: { loadedSessionsStore: { c: 3 },
-                                   persistentSessionsStore: { d: 2 } },
-                         options: { e: 1 } };
-    const spyGetMediaKeysInfos = jest.fn(() => {
-      return observableOf(fakeResult);
-    });
-    jest.mock("../get_media_keys", () => ({
-      __esModule: true as const,
-      default: spyGetMediaKeysInfos,
-    }));
-    const spyAttachMediaKeys = jest.fn(() => {
-      return observableOf(undefined);
-    });
-    const spyDisableOldMediaKeys = jest.fn(() => {
-      return observableOf(undefined);
-    });
-    jest.mock("../attach_media_keys", () => ({
-      __esModule: true as const,
-      default: spyAttachMediaKeys,
-      disableOldMediaKeys: spyDisableOldMediaKeys,
-    }));
-    const initMediaKeys = require("../init_media_keys").default;
-
-    const mediaElement = document.createElement("video");
-    const keySystemsConfigs = [{ l: 4 }, { d: 12 }];
-    initMediaKeys(mediaElement, keySystemsConfigs)
-      .pipe(take(1))
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .subscribe((result : { type : string; value : any }) => {
-        expect(result.type).toEqual("created-media-keys");
-        expect(result.value.mediaKeys).toEqual(fakeResult.mediaKeys);
-        expect(result.value.mediaKeySystemAccess)
-          .toEqual(fakeResult.mediaKeySystemAccess);
-        expect(result.value.stores).toEqual(fakeResult.stores);
-        expect(result.value.options).toEqual(fakeResult.options);
-        expect(typeof result.value.canAttachMediaKeys.setValue === "function")
-          .toBeTruthy();
-
-        expect(spyGetMediaKeysInfos).toHaveBeenCalledTimes(1);
-        expect(spyGetMediaKeysInfos)
-          .toHaveBeenCalledWith(mediaElement, keySystemsConfigs);
-
-        expect(spyAttachMediaKeys).toHaveBeenCalledTimes(0);
-        done();
-      });
-  });
-
-  it("should return MediaKeys information after media keys has been attached", (done) => {
-    const fakeResult = { mediaKeySystemAccess: { a: 5, keySystem: "toto" },
-                         mediaKeys: { b: 4 },
-                         stores: { loadedSessionsStore: { c: 3 },
-                                   persistentSessionsStore: { d: 2 } },
-                         options: { e: 1 } };
-    const spyGetMediaKeysInfos = jest.fn(() => {
-      return observableOf(fakeResult);
-    });
-    jest.mock("../get_media_keys", () => ({
-      __esModule: true as const,
-      default: spyGetMediaKeysInfos,
-    }));
-    const spyAttachMediaKeys = jest.fn(() => {
-      return observableOf(undefined);
-    });
-    const spyDisableOldMediaKeys = jest.fn(() => {
-      return observableOf(undefined);
-    });
-    jest.mock("../attach_media_keys", () => ({
-      __esModule: true as const,
-      default: spyAttachMediaKeys,
-      disableOldMediaKeys: spyDisableOldMediaKeys,
-    }));
-    const initMediaKeys = require("../init_media_keys").default;
-
-    const mediaElement = document.createElement("video");
-    const keySystemsConfigs = [{ l: 4 }, { d: 12 }];
-    initMediaKeys(mediaElement, keySystemsConfigs)
-      .pipe(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        tap((evt: { type : string; value : any }) => {
-          if (evt.type === "created-media-keys") {
-            evt.value.canAttachMediaKeys.setValue(true);
-          }
-        }),
-        skip(1)
-      )
-      .subscribe((result : unknown) => {
-        expect(result).toEqual({
-          type: "attached-media-keys",
-          value: fakeResult,
-        });
-
-        expect(spyGetMediaKeysInfos).toHaveBeenCalledTimes(1);
-        expect(spyGetMediaKeysInfos)
-          .toHaveBeenCalledWith(mediaElement, keySystemsConfigs);
-
-        expect(spyAttachMediaKeys).toHaveBeenCalledTimes(1);
-        expect(spyAttachMediaKeys)
-          .toHaveBeenCalledWith(
-            mediaElement,
-            { mediaKeySystemAccess: fakeResult.mediaKeySystemAccess,
-              mediaKeys: fakeResult.mediaKeys,
-              loadedSessionsStore: fakeResult.stores.loadedSessionsStore,
-              keySystemOptions: fakeResult.options });
-        done();
-      });
-  });
-
-  it("Should throw if getMediaKeys throws", (done) => {
-    const err = new Error("a");
-    const spyGetMediaKeysInfos = jest.fn(() => throwError(() => err));
-    jest.mock("../get_media_keys", () => ({
-      __esModule: true as const,
-      default: spyGetMediaKeysInfos,
-    }));
-    const spyAttachMediaKeys = jest.fn(() => {
-      return observableOf(undefined);
-    });
-    const spyDisableOldMediaKeys = jest.fn(() => {
-      return observableOf(undefined);
-    });
-    jest.mock("../attach_media_keys", () => ({
-      __esModule: true as const,
-      default: spyAttachMediaKeys,
-      disableOldMediaKeys: spyDisableOldMediaKeys,
-    }));
-    const initMediaKeys = require("../init_media_keys").default;
-
-    const mediaElement = document.createElement("video");
-    const keySystemsConfigs = [{ l: 4 }, { d: 12 }];
-    initMediaKeys(mediaElement, keySystemsConfigs)
-      .subscribe(null, (e : Error) => {
-        expect(e).toBe(err);
-
-        expect(spyGetMediaKeysInfos).toHaveBeenCalledTimes(1);
-        expect(spyGetMediaKeysInfos)
-          .toHaveBeenCalledWith(mediaElement, keySystemsConfigs);
-
-        expect(spyAttachMediaKeys).not.toHaveBeenCalled();
-        done();
-      });
-  });
-
-});

package/src/core/eme/clean_old_loaded_sessions.ts

@@ -1,96 +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 {
-  EMPTY,
-  mapTo,
-  merge as observableMerge,
-  Observable,
-  startWith,
-} from "rxjs";
-import { ICustomMediaKeySession } from "../../compat";
-import { IInitializationDataInfo } from "./types";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
-
-/**
- * Event emitted when an old MediaKeySession has been closed to respect the
- * maximum limit of concurrent MediaKeySession active.
- */
-export interface ICleanedOldSessionEvent {
-  type : "cleaned-old-session";
-  value : {
-    /** The MediaKeySession cleaned. */
-    mediaKeySession : MediaKeySession |
-                      ICustomMediaKeySession;
-    /** The type of MediaKeySession (e.g. "temporary"). */
-    sessionType : MediaKeySessionType;
-    /** Initialization data assiociated to this MediaKeySession. */
-    initializationData : IInitializationDataInfo;
-  };
-}
-
-/**
- * Event emitted when we are beginning to close an old MediaKeySession to
- * respect the maximum limit of concurrent MediaKeySession active.
- */
-export interface ICleaningOldSessionEvent {
-  type : "cleaning-old-session";
-  value : {
-    /** The MediaKeySession that we are currently cleaning. */
-    mediaKeySession : MediaKeySession |
-                      ICustomMediaKeySession;
-    /** The type of MediaKeySession (e.g. "temporary"). */
-    sessionType : MediaKeySessionType;
-    /** Initialization data assiociated to this MediaKeySession. */
-    initializationData : IInitializationDataInfo;
-  };
-}
-
-/**
- * Close sessions from the loadedSessionsStore to allow at maximum `limit`
- * stored MediaKeySessions in it.
- *
- * Emit event when a MediaKeySession begin to be closed and another when the
- * MediaKeySession is closed.
- * @param {Object} loadedSessionsStore
- * @returns {Observable}
- */
-export default function cleanOldLoadedSessions(
-  loadedSessionsStore : LoadedSessionsStore,
-  limit : number
-) : Observable<ICleaningOldSessionEvent | ICleanedOldSessionEvent> {
-  if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
-    return EMPTY;
-  }
-
-  const cleaningOldSessions$ : Array<Observable<ICleanedOldSessionEvent |
-                                                 ICleaningOldSessionEvent>> = [];
-  const entries = loadedSessionsStore
-    .getAll()
-    .slice(); // clone
-  const toDelete = entries.length - limit;
-  for (let i = 0; i < toDelete; i++) {
-    const entry = entries[i];
-    const cleaning$ = loadedSessionsStore
-      .closeSession(entry.initializationData)
-      .pipe(mapTo({ type: "cleaned-old-session" as const,
-                    value: entry }),
-            startWith({ type: "cleaning-old-session" as const,
-                        value: entry }));
-    cleaningOldSessions$.push(cleaning$);
-  }
-  return observableMerge(...cleaningOldSessions$);
-}

package/src/core/eme/clear_eme_session.ts

@@ -1,62 +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 {
-  defer as observableDefer,
-  EMPTY,
-  ignoreElements ,
-  Observable,
-} from "rxjs";
-import { shouldUnsetMediaKeys } from "../../compat/";
-import log from "../../log";
-import disposeMediaKeys from "./dispose_media_keys";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-
-/**
- * Clear EME ressources that should be cleared when the current content stops
- * its playback.
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-export default function clearEMESession(
-  mediaElement : HTMLMediaElement
-) : Observable<never> {
-  return observableDefer(() => {
-    log.info("EME: Clearing-up EME session.");
-    if (shouldUnsetMediaKeys()) {
-      log.info("EME: disposing current MediaKeys.");
-      return disposeMediaKeys(mediaElement)
-        .pipe(ignoreElements());
-    }
-
-    const currentState = MediaKeysInfosStore.getState(mediaElement);
-    if (currentState !== null &&
-        currentState.keySystemOptions.closeSessionsOnStop === true)
-    {
-      log.info("EME: closing all current sessions.");
-      return currentState.loadedSessionsStore.closeAllSessions()
-        // 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 */
-        .pipe(ignoreElements());
-    }
-    log.info("EME: Nothing to clear. Returning right away. No state =",
-             currentState === null);
-    return EMPTY;
-  });
-}

package/src/core/eme/create_session.ts

@@ -1,187 +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,
-  map,
-  mergeMap,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
-  ICustomMediaKeySession,
-  loadSession,
-} from "../../compat";
-import log from "../../log";
-import {
-  IInitializationDataInfo,
-  IMediaKeySessionStores,
-} from "./types";
-import isSessionUsable from "./utils/is_session_usable";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
-import PersistentSessionsStore from "./utils/persistent_sessions_store";
-
-export interface INewSessionCreatedEvent {
-  type : "created-session";
-  value : { mediaKeySession : MediaKeySession |
-                              ICustomMediaKeySession;
-            sessionType : MediaKeySessionType; };
-}
-
-export interface IPersistentSessionRecoveryEvent {
-  type : "loaded-persistent-session";
-  value : { mediaKeySession : MediaKeySession |
-                              ICustomMediaKeySession;
-            sessionType : MediaKeySessionType; };
-}
-
-export type ICreateSessionEvent = INewSessionCreatedEvent |
-                                  IPersistentSessionRecoveryEvent;
-
-/**
- * Create a new Session on the given MediaKeys, corresponding to the given
- * initializationData.
- * If session creating fails, remove the oldest MediaKeySession loaded and
- * retry.
- *
- * /!\ This only creates new sessions.
- * It will fail if loadedSessionsStore already has a MediaKeySession with
- * the given initializationData.
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- * @param {Object} mediaKeysInfos
- * @returns {Observable}
- */
-export default function createSession(
-  stores : IMediaKeySessionStores,
-  initializationData : IInitializationDataInfo,
-  wantedSessionType : MediaKeySessionType
-) : Observable<ICreateSessionEvent> {
-  return observableDefer(() => {
-    const { loadedSessionsStore,
-            persistentSessionsStore } = stores;
-
-    if (wantedSessionType === "temporary") {
-      return createTemporarySession(loadedSessionsStore, initializationData);
-    } else if (persistentSessionsStore === null) {
-      log.warn("EME: Cannot create persistent MediaKeySession, " +
-               "PersistentSessionsStore not created.");
-      return createTemporarySession(loadedSessionsStore, initializationData);
-    }
-    return createAndTryToRetrievePersistentSession(loadedSessionsStore,
-                                                   persistentSessionsStore,
-                                                   initializationData);
-  });
-}
-
-/**
- * Create a new temporary MediaKeySession linked to the given initData and
- * initDataType.
- * @param {Object} loadedSessionsStore
- * @param {Object} initData
- * @returns {Observable}
- */
-function createTemporarySession(
-  loadedSessionsStore : LoadedSessionsStore,
-  initData : IInitializationDataInfo
-) : Observable<INewSessionCreatedEvent> {
-  return observableDefer(() => {
-    log.info("EME: Creating a new temporary session");
-    const session = loadedSessionsStore.createSession(initData, "temporary");
-    return observableOf({ type: "created-session" as const,
-                          value: { mediaKeySession: session,
-                                   sessionType: "temporary" as const } });
-  });
-}
-
-/**
- * Create a persistent MediaKeySession and try to load on it a previous
- * MediaKeySession linked to the same initData and initDataType.
- * @param {Object} loadedSessionsStore
- * @param {Object} persistentSessionsStore
- * @param {Object} initData
- * @returns {Observable}
- */
-function createAndTryToRetrievePersistentSession(
-  loadedSessionsStore : LoadedSessionsStore,
-  persistentSessionsStore : PersistentSessionsStore,
-  initData : IInitializationDataInfo
-) : Observable<INewSessionCreatedEvent | IPersistentSessionRecoveryEvent> {
-  return observableDefer(() => {
-    log.info("EME: Creating persistent MediaKeySession");
-
-    const session = loadedSessionsStore
-      .createSession(initData, "persistent-license");
-    const storedEntry = persistentSessionsStore.getAndReuse(initData);
-
-    if (storedEntry === null) {
-      return observableOf({ type: "created-session" as const,
-                            value: { mediaKeySession: session,
-                                     sessionType: "persistent-license" as const } });
-    }
-
-    /**
-     * Helper function to close and restart the current persistent session
-     * considered, and re-create it from scratch.
-     * @returns {Observable}
-     */
-    const recreatePersistentSession = () : Observable<INewSessionCreatedEvent> => {
-      log.info("EME: Removing previous persistent session.");
-      if (persistentSessionsStore.get(initData) !== null) {
-        persistentSessionsStore.delete(initData);
-      }
-      return loadedSessionsStore.closeSession(initData)
-        .pipe(map(() => {
-          const newSession = loadedSessionsStore.createSession(initData,
-                                                               "persistent-license");
-          return { type: "created-session" as const,
-                   value: { mediaKeySession: newSession,
-                            sessionType: "persistent-license" } };
-        }));
-    };
-
-    return loadSession(session, storedEntry.sessionId).pipe(
-      mergeMap((hasLoadedSession) : Observable<ICreateSessionEvent> => {
-        if (!hasLoadedSession) {
-          log.warn("EME: No data stored for the loaded session");
-          persistentSessionsStore.delete(initData);
-          return observableOf({ type: "created-session" as const,
-                                value: { mediaKeySession: session,
-                                         sessionType: "persistent-license" } });
-        }
-
-        if (hasLoadedSession && isSessionUsable(session)) {
-          persistentSessionsStore.add(initData, session);
-          log.info("EME: Succeeded to load persistent session.");
-          return observableOf({ type: "loaded-persistent-session" as const,
-                                value: { mediaKeySession: session,
-                                         sessionType: "persistent-license" } });
-        }
-
-        // Unusable persistent session: recreate a new session from scratch.
-        log.warn("EME: Previous persistent session not usable anymore.");
-        return recreatePersistentSession();
-      }),
-      catchError((err : unknown) : Observable<INewSessionCreatedEvent> => {
-        log.warn("EME: Unable to load persistent session: " +
-                 (err instanceof Error ? err.toString() :
-                                         "Unknown Error"));
-        return recreatePersistentSession();
-      })
-    );
-  });
-}

package/src/core/eme/dispose_eme.ts

@@ -1,25 +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 noop from "../../utils/noop";
-import disposeMediaKeys from "./dispose_media_keys";
-
-/**
- * Free up all ressources taken by the EME management.
- */
-export default function disposeEME(mediaElement : HTMLMediaElement) : void {
-  disposeMediaKeys(mediaElement).subscribe(noop);
-}

package/src/core/eme/dispose_media_keys.ts

@@ -1,46 +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 {
-  defer as observableDefer,
-  mergeMap,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import { setMediaKeys } from "../../compat";
-import log from "../../log";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-
-/**
- * @param {Object} mediaKeysInfos
- * @returns {Observable}
- */
-export default function disposeMediaKeys(
-  mediaElement : HTMLMediaElement
-) : Observable<unknown> {
-  return observableDefer(() => {
-    const currentState = MediaKeysInfosStore.getState(mediaElement);
-    if (currentState === null) {
-      return observableOf(null);
-    }
-
-    log.info("EME: Disposing of the current MediaKeys");
-    const { loadedSessionsStore } = currentState;
-    MediaKeysInfosStore.clearState(mediaElement);
-    return loadedSessionsStore.closeAllSessions()
-      .pipe(mergeMap(() => setMediaKeys(mediaElement, null)));
-  });
-}