rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/compat/eme/custom_media_keys/webkit_media_keys.ts

@@ -14,15 +14,10 @@
  * limitations under the License.
  */
 
-import {
-  merge as observableMerge,
-  Subject,
-  takeUntil,
-} from "rxjs";
 import EventEmitter from "../../../utils/event_emitter";
+import noop from "../../../utils/noop";
 import PPromise from "../../../utils/promise";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import * as events from "../../event_listeners";
 import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import {
   ICustomMediaKeys,
@@ -80,17 +75,19 @@ class WebkitMediaKeySession
   extends EventEmitter<IMediaKeySessionEvents>
   implements ICustomMediaKeySession
 {
-  public readonly update: (license: Uint8Array) => Promise<void>;
   public readonly closed: Promise<void>;
   public expiration: number;
   public keyStatuses: ICustomMediaKeyStatusMap;
 
   private readonly _videoElement: HTMLMediaElement;
-  private readonly _closeSession$: Subject<void>;
   private readonly _keyType: string;
   private _nativeSession: undefined | MediaKeySession;
   private _serverCertificate: Uint8Array | undefined;
 
+  private readonly _onEvent : (evt : Event) => void;
+  private _closeSession : () => void;
+  private _unbindSession : () => void;
+
   /**
    * @param {HTMLMediaElement} mediaElement
    * @param {string} keyType
@@ -103,56 +100,43 @@ class WebkitMediaKeySession
   ) {
     super();
     this._serverCertificate = serverCertificate;
-    this._closeSession$ = new Subject();
     this._videoElement = mediaElement;
     this._keyType = keyType;
 
+    this._unbindSession = noop;
+    this._closeSession = noop; // Just here to make TypeScript happy
     this.closed = new PPromise((resolve) => {
-      this._closeSession$.subscribe(resolve);
+      this._closeSession = resolve;
     });
     this.keyStatuses = new Map();
     this.expiration = NaN;
 
-    this.update = (license: BufferSource) => {
-      return new PPromise((resolve, reject) => {
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        if (this._nativeSession === undefined ||
-            this._nativeSession.update === undefined ||
-            typeof this._nativeSession.update !== "function") {
-          return reject("Unavailable WebKit key session.");
-        }
-        try {
-          let uInt8Arraylicense: Uint8Array;
-          if (license instanceof ArrayBuffer) {
-            uInt8Arraylicense = new Uint8Array(license);
-          } else if (license instanceof Uint8Array) {
-            uInt8Arraylicense = license;
-          } else {
-            uInt8Arraylicense = new Uint8Array(license.buffer);
-          }
-          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-          resolve(this._nativeSession.update(uInt8Arraylicense));
-          /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-        } catch (err) {
-          reject(err);
-        }
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      });
+    this._onEvent = (evt : Event) => {
+      this.trigger(evt.type, evt);
     };
   }
 
-  listenEvent(session: MediaKeySession) {
-    observableMerge(events.onKeyMessage$(session),
-                    events.onKeyAdded$(session),
-                    events.onKeyError$(session))
-      .pipe(takeUntil(this._closeSession$))
-      .subscribe((evt: Event) => {
-        this.trigger(evt.type, evt);
-      });
+  public update(license: BufferSource) : Promise<void> {
+    return new PPromise((resolve, reject) => {
+      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+      if (this._nativeSession === undefined ||
+          this._nativeSession.update === undefined ||
+          typeof this._nativeSession.update !== "function") {
+        return reject("Unavailable WebKit key session.");
+      }
+      try {
+        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        resolve(this._nativeSession.update(license));
+        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+      } catch (err) {
+        reject(err);
+      }
+      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+    });
   }
 
-  generateRequest(
+  public generateRequest(
     _initDataType: string,
     initData: ArrayBuffer
   ): Promise<void> {
@@ -178,17 +162,17 @@ class WebkitMediaKeySession
       if (keySession === undefined || keySession === null) {
         throw new Error("Impossible to get the key sessions");
       }
-      this.listenEvent(keySession);
+      this._listenEvent(keySession);
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       this._nativeSession = keySession;
       resolve();
     });
   }
 
-  close(): Promise<void> {
+  public close(): Promise<void> {
     return new PPromise((resolve, reject) => {
-      this._closeSession$.next();
-      this._closeSession$.complete();
+      this._unbindSession();
+      this._closeSession();
       if (this._nativeSession === undefined) {
         reject("No session to close.");
         return;
@@ -215,6 +199,24 @@ class WebkitMediaKeySession
     /* eslint-enable @typescript-eslint/no-unsafe-member-access */
     /* eslint-enable @typescript-eslint/no-unsafe-return */
   }
+
+  private _listenEvent(session: MediaKeySession) : void {
+    this._unbindSession(); // If previous session was linked
+
+    /* eslint-disable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-disable @typescript-eslint/no-unsafe-return */
+    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+      .forEach(evt => session.addEventListener(evt, this._onEvent));
+
+    this._unbindSession = () => {
+      ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+        .forEach(evt => session.removeEventListener(evt, this._onEvent));
+    };
+    /* eslint-disable @typescript-eslint/no-unsafe-return */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-enable @typescript-eslint/no-unsafe-call */
+  }
 }
 
 class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {

package/src/compat/eme/generate_key_request.ts

@@ -14,18 +14,12 @@
  * limitations under the License.
  */
 
-import {
-  catchError,
-  defer as observableDefer,
-  Observable,
-} from "rxjs";
 import log from "../../log";
 import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
 import {
   be4toi,
   concat,
 } from "../../utils/byte_parsing";
-import castToObservable from "../../utils/cast_to_observable";
 import { PSSH_TO_INTEGER } from "./constants";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 
@@ -136,37 +130,35 @@ export function patchInitData(initData : Uint8Array) : Uint8Array {
  * "encrypted" event for the corresponding request.
  * @param {string} sessionType - Type of session you want to generate. Consult
  * EME Specification for more information on session types.
- * @returns {Observable} - Emit when done. Errors if fails.
+ * @returns {Promise} - Emit when done. Errors if fails.
  */
 export default function generateKeyRequest(
   session: MediaKeySession|ICustomMediaKeySession,
   initializationDataType : string | undefined,
   initializationData : Uint8Array
-) : Observable<unknown> {
-  return observableDefer(() => {
-    log.debug("Compat: Calling generateRequest on the MediaKeySession");
-    let patchedInit : Uint8Array;
-    try {
-      patchedInit = patchInitData(initializationData);
-    } catch (_e) {
-      patchedInit = initializationData;
-    }
-    const initDataType = initializationDataType ?? "";
-    return castToObservable(session.generateRequest(initDataType, patchedInit))
-      .pipe(catchError(error => {
-        if (initDataType !== "" || !(error instanceof TypeError)) {
-          throw error;
-        }
+) : Promise<unknown> {
+  log.debug("Compat: Calling generateRequest on the MediaKeySession");
+  let patchedInit : Uint8Array;
+  try {
+    patchedInit = patchInitData(initializationData);
+  } catch (_e) {
+    patchedInit = initializationData;
+  }
+  const initDataType = initializationDataType ?? "";
+  return session.generateRequest(initDataType, patchedInit)
+    .catch((error) => {
+      if (initDataType !== "" || !(error instanceof TypeError)) {
+        throw error;
+      }
 
-        // On newer EME versions of the specification, the initialization data
-        // type given to generateRequest cannot be an empty string (it returns
-        // a rejected promise with a TypeError in that case).
-        // Retry with a default "cenc" value for initialization data type if
-        // we're in that condition.
-        log.warn("Compat: error while calling `generateRequest` with an empty " +
-                 "initialization data type. Retrying with a default \"cenc\" value.",
-                 error);
-        return castToObservable(session.generateRequest("cenc", patchedInit));
-      }));
-  });
+      // On newer EME versions of the specification, the initialization data
+      // type given to generateRequest cannot be an empty string (it returns
+      // a rejected promise with a TypeError in that case).
+      // Retry with a default "cenc" value for initialization data type if
+      // we're in that condition.
+      log.warn("Compat: error while calling `generateRequest` with an empty " +
+               "initialization data type. Retrying with a default \"cenc\" value.",
+               error);
+      return session.generateRequest("cenc", patchedInit);
+    });
 }

package/src/compat/eme/load_session.ts

@@ -14,20 +14,8 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  map,
-  mergeMap,
-  Observable,
-  of as observableOf,
-  race as observableRace,
-  take,
-  timer as observableTimer,
-} from "rxjs";
+import PPromise from "pinkie";
 import log from "../../log";
-import castToObservable from "../../utils/cast_to_observable";
-import tryCatch from "../../utils/rx-try_catch";
-import { onKeyStatusesChange$ } from "../event_listeners";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 
 const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
@@ -46,26 +34,36 @@ const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * @param {string} sessionId
  * @returns {Observable}
  */
-export default function loadSession(
+export default async function loadSession(
   session : MediaKeySession | ICustomMediaKeySession,
   sessionId : string
-) : Observable<boolean> {
-  return observableDefer(() => {
-    log.info("Compat/EME: Load persisted session", sessionId);
-    return tryCatch<undefined, boolean>(() => castToObservable(session.load(sessionId)),
-                                        undefined);
-  }).pipe(mergeMap((isLoaded : boolean) : Observable<boolean> => {
-    if (!isLoaded || session.keyStatuses.size > 0) {
-      return observableOf(isLoaded);
+) : Promise<boolean> {
+  log.info("Compat/DRM: Load persisted session", sessionId);
+  const isLoaded = await session.load(sessionId);
+
+  if (!isLoaded || session.keyStatuses.size > 0) {
+    return isLoaded;
+  }
+
+  // A browser race condition can exist, seen for example in some
+  // Chromium/Chrome versions where the `keyStatuses` property from a loaded
+  // MediaKeySession would not be populated directly as the load answer but
+  // asynchronously after.
+  return new PPromise((resolve) => {
+    (session as MediaKeySession).addEventListener("keystatuseschange",
+                                                  resolveWithLoadedStatus);
+    const timeout = setTimeout(resolveWithLoadedStatus,
+                               EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES);
+
+    function resolveWithLoadedStatus() {
+      cleanUp();
+      resolve(isLoaded);
     }
 
-    // A browser race condition can exist, seen for example in some
-    // Chromium/Chrome versions where the `keyStatuses` property from a loaded
-    // MediaKeySession would not be populated directly as the load answer but
-    // asynchronously after.
-    return observableRace(
-      observableTimer(EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES),
-      onKeyStatusesChange$(session)
-    ).pipe(take(1), map(() => isLoaded));
-  }));
+    function cleanUp() {
+      clearTimeout(timeout);
+      (session as MediaKeySession).removeEventListener("keystatuseschange",
+                                                       resolveWithLoadedStatus);
+    }
+  });
 }

package/src/compat/event_listeners.ts

@@ -49,7 +49,6 @@ import shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
 
 const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 
-const INACTIVITY_DELAY = config.INACTIVITY_DELAY;
 const pixelRatio = isNode ||
                    window.devicePixelRatio == null ||
                    window.devicePixelRatio === 0 ? 1 :
@@ -192,6 +191,7 @@ function visibilityChange() : Observable<boolean> {
  * @returns {Observable}
  */
 function isPageActive() : Observable<boolean> {
+  const { INACTIVITY_DELAY } = config.getCurrent();
   return visibilityChange().pipe(
     switchMap((x) => {
       if (!x) {
@@ -275,6 +275,7 @@ function onPictureInPictureEvent$(
 function isVideoVisible(
   pip$ : Observable<IPictureInPictureEvent>
 ) : Observable<boolean> {
+  const { INACTIVITY_DELAY } = config.getCurrent();
   return observableCombineLatest([visibilityChange(), pip$]).pipe(
     switchMap(([ isVisible, pip ]) => {
       if (pip.isEnabled || isVisible) {

package/src/compat/should_favour_custom_safari_EME.ts

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import { isSafari } from "./browser_detection";
+import {
+  isSafariDesktop,
+  isSafariMobile,
+} from "./browser_detection";
 import {
   WebKitMediaKeysConstructor,
 } from "./eme/custom_media_keys/webkit_media_keys_constructor";
@@ -27,5 +30,5 @@ import {
  * @returns {boolean}
  */
 export default function shouldFavourCustomSafariEME() : boolean {
-  return isSafari && WebKitMediaKeysConstructor !== undefined;
+  return (isSafariDesktop || isSafariMobile) && WebKitMediaKeysConstructor !== undefined;
 }