rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/compat/eme/eme-api-implementation.ts

@@ -3,8 +3,9 @@ import assert from "../../utils/assert";
 import globalScope from "../../utils/global_scope";
 import isNode from "../../utils/is_node";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import objectAssign from "../../utils/object_assign";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import type { ICompatHTMLMediaElement } from "../browser_compatibility_types";
+import type { IMediaElement } from "../browser_compatibility_types";
 import { isIE11 } from "../browser_detection";
 import type { IEventTargetLike } from "../event_listeners";
 import { createCompatibleEventListener } from "../event_listeners";
@@ -19,7 +20,10 @@ import getMozMediaKeysCallbacks, {
 import getOldKitWebKitMediaKeyCallbacks, {
   isOldWebkitMediaElement,
 } from "./custom_media_keys/old_webkit_media_keys";
-import type { ICustomMediaKeys } from "./custom_media_keys/types";
+import type {
+  ICustomMediaEncryptedEvent,
+  ICustomMediaKeys,
+} from "./custom_media_keys/types";
 import getWebKitMediaKeysCallbacks from "./custom_media_keys/webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./custom_media_keys/webkit_media_keys_constructor";
 
@@ -63,7 +67,7 @@ export interface IEmeApiImplementation {
    */
   onEncrypted: (
     target: IEventTargetLike,
-    listener: (evt: unknown) => void,
+    listener: (evt: ICustomMediaEncryptedEvent) => void,
     cancelSignal: CancellationSignal,
   ) => void;
 
@@ -77,7 +81,7 @@ export interface IEmeApiImplementation {
    * scenario.
    */
   setMediaKeys: (
-    mediaElement: HTMLMediaElement,
+    mediaElement: IMediaElement,
     mediaKeys: MediaKeys | ICustomMediaKeys | null,
   ) => Promise<unknown>;
 
@@ -143,8 +147,8 @@ function getEmeApiImplementation(
     let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
 
     if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
-      onEncrypted = createCompatibleEventListener(["needkey"]);
       const callbacks = getWebKitMediaKeysCallbacks();
+      onEncrypted = createOnEncryptedForWebkit();
       isTypeSupported = callbacks.isTypeSupported;
       createCustomMediaKeys = callbacks.createCustomMediaKeys;
       setMediaKeys = callbacks.setMediaKeys;
@@ -160,7 +164,7 @@ function getEmeApiImplementation(
         implementation = "older-webkit";
         // This is for WebKit with prefixed EME api
       } else if (WebKitMediaKeysConstructor !== undefined) {
-        onEncrypted = createCompatibleEventListener(["needkey"]);
+        onEncrypted = createOnEncryptedForWebkit();
         const callbacks = getWebKitMediaKeysCallbacks();
         isTypeSupported = callbacks.isTypeSupported;
         createCustomMediaKeys = callbacks.createCustomMediaKeys;
@@ -274,21 +278,48 @@ function getEmeApiImplementation(
     implementation,
   };
 }
+/**
+ * Create an event listener for the "webkitneedkey" event
+ * @returns
+ */
+function createOnEncryptedForWebkit(): IEmeApiImplementation["onEncrypted"] {
+  const compatibleEventListener = createCompatibleEventListener(
+    ["needkey"],
+    undefined /* prefixes */,
+  );
+  const onEncrypted = (
+    target: IEventTargetLike,
+    listener: (event: ICustomMediaEncryptedEvent) => void,
+    cancelSignal: CancellationSignal,
+  ) => {
+    compatibleEventListener(
+      target,
+      (event?: Event) => {
+        const patchedEvent = objectAssign(
+          { forceSessionRecreation: true },
+          event as MediaEncryptedEvent,
+        );
+        listener(patchedEvent);
+      },
+      cancelSignal,
+    );
+  };
+  return onEncrypted;
+}
 
 /**
  * Set the given MediaKeys on the given HTMLMediaElement.
  * Emits null when done then complete.
- * @param {HTMLMediaElement} mediaElement
+ * @param {HTMLMediaElement} elt
  * @param {Object} mediaKeys
  * @returns {Promise}
  */
 function defaultSetMediaKeys(
-  mediaElement: HTMLMediaElement,
+  elt: IMediaElement,
   mediaKeys: MediaKeys | ICustomMediaKeys | null,
 ): Promise<unknown> {
   try {
     let ret: unknown;
-    const elt: ICompatHTMLMediaElement = mediaElement;
     /* eslint-disable @typescript-eslint/unbound-method */
     if (typeof elt.setMediaKeys === "function") {
       ret = elt.setMediaKeys(mediaKeys as MediaKeys);

package/src/compat/eme/get_init_data.ts

@@ -20,6 +20,7 @@ import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import { be4toi } from "../../utils/byte_parsing";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import { PSSH_TO_INTEGER } from "./constants";
+import type { ICustomMediaEncryptedEvent } from "./custom_media_keys/types";
 
 /** Data recuperated from parsing the payload of an `encrypted` event. */
 export interface IEncryptedEventData {
@@ -50,6 +51,7 @@ export interface IEncryptedEventData {
      */
     data: Uint8Array;
   }>;
+  forceSessionRecreation?: boolean | undefined;
 }
 
 /**
@@ -145,9 +147,9 @@ function isPSSHAlreadyEncountered(
  * encountered in the given event.
  */
 export default function getInitData(
-  encryptedEvent: MediaEncryptedEvent,
+  encryptedEvent: ICustomMediaEncryptedEvent,
 ): IEncryptedEventData | null {
-  const { initData, initDataType } = encryptedEvent;
+  const { initData, initDataType, forceSessionRecreation } = encryptedEvent;
   if (isNullOrUndefined(initData)) {
     log.warn("Compat: No init data found on media encrypted event.");
     return null;
@@ -155,5 +157,5 @@ export default function getInitData(
 
   const initDataBytes = new Uint8Array(initData);
   const values = getInitializationDataValues(initDataBytes);
-  return { type: initDataType, values };
+  return { type: initDataType, values, forceSessionRecreation };
 }

package/src/compat/eme/set_media_keys.ts

@@ -1,5 +1,6 @@
 import log from "../../log";
 import sleep from "../../utils/sleep";
+import type { IMediaElement } from "../browser_compatibility_types";
 import shouldAwaitSetMediaKeys from "../should_await_set_media_keys";
 import type { ICustomMediaKeys } from "./custom_media_keys";
 import type { IEmeApiImplementation } from "./eme-api-implementation";
@@ -12,7 +13,7 @@ import type { IEmeApiImplementation } from "./eme-api-implementation";
  */
 export function setMediaKeys(
   emeImplementation: IEmeApiImplementation,
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   mediaKeys: MediaKeys | ICustomMediaKeys | null,
 ): Promise<unknown> {
   const prom = emeImplementation

package/src/compat/event_listeners.ts

@@ -26,9 +26,11 @@ import SharedReference from "../utils/reference";
 import type { CancellationSignal } from "../utils/task_canceller";
 import type {
   ICompatDocument,
-  ICompatHTMLMediaElement,
   ICompatPictureInPictureWindow,
+  IEventTarget,
+  IMediaElement,
 } from "./browser_compatibility_types";
+import type { ICustomMediaEncryptedEvent } from "./eme/custom_media_keys/types";
 
 const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 
@@ -81,8 +83,14 @@ function eventPrefixed(eventNames: string[], prefixes?: string[]): string[] {
 }
 
 export interface IEventEmitterLike {
-  addEventListener: (eventName: string, handler: () => void) => void;
-  removeEventListener: (eventName: string, handler: () => void) => void;
+  addEventListener: (
+    eventName: string,
+    handler: EventListenerOrEventListenerObject,
+  ) => void;
+  removeEventListener: (
+    eventName: string,
+    handler: EventListenerOrEventListenerObject,
+  ) => void;
 }
 
 export type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<unknown>;
@@ -98,12 +106,31 @@ export type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<u
  * @returns {Function} - Returns function allowing to easily add a callback to
  * be triggered when that event is emitted on a given event target.
  */
+
+function createCompatibleEventListener(
+  eventNames: Array<"needkey" | "encrypted">,
+  prefixes?: string[],
+): (
+  element: IEventTargetLike,
+  listener: (event: ICustomMediaEncryptedEvent) => void,
+  cancelSignal: CancellationSignal,
+) => void;
+
 function createCompatibleEventListener(
   eventNames: string[],
   prefixes?: string[],
 ): (
   element: IEventTargetLike,
-  listener: (event?: unknown) => void,
+  listener: (event?: Event) => void,
+  cancelSignal: CancellationSignal,
+) => void;
+
+function createCompatibleEventListener(
+  eventNames: string[] | Array<"needkey" | "encrypted">,
+  prefixes?: string[],
+): (
+  element: IEventTargetLike,
+  listener: (event?: Event | MediaEncryptedEvent) => void,
   cancelSignal: CancellationSignal,
 ) => void {
   let mem: string | undefined;
@@ -111,13 +138,12 @@ function createCompatibleEventListener(
 
   return (
     element: IEventTargetLike,
-    listener: (event?: unknown) => void,
+    listener: (event?: Event) => void,
     cancelSignal: CancellationSignal,
   ) => {
     if (cancelSignal.isCancelled()) {
       return;
     }
-
     // if the element is a HTMLElement we can detect
     // the supported event, and memoize it in `mem`
     if (typeof HTMLElement !== "undefined" && element instanceof HTMLElement) {
@@ -228,15 +254,14 @@ export interface IPictureInPictureEvent {
 
 /**
  * Emit when video enters and leaves Picture-In-Picture mode.
- * @param {HTMLMediaElement} elt
+ * @param {HTMLMediaElement} mediaElement
  * @param {Object} stopListening
  * @returns {Object}
  */
 function getPictureOnPictureStateRef(
-  elt: HTMLMediaElement,
+  mediaElement: IMediaElement,
   stopListening: CancellationSignal,
 ): IReadOnlySharedReference<IPictureInPictureEvent> {
-  const mediaElement = elt as ICompatHTMLMediaElement;
   if (
     mediaElement.webkitSupportsPresentationMode === true &&
     typeof mediaElement.webkitSetPresentationMode === "function"
@@ -263,7 +288,7 @@ function getPictureOnPictureStateRef(
   }
 
   const isPIPEnabled =
-    (document as ICompatDocument).pictureInPictureElement === mediaElement;
+    document.pictureInPictureElement === (mediaElement as unknown as HTMLElement);
   const ref = new SharedReference<IPictureInPictureEvent>(
     { isEnabled: isPIPEnabled, pipWindow: null },
     stopListening,
@@ -392,7 +417,7 @@ function getScreenResolutionRef(
  * @returns {Object}
  */
 function getElementResolutionRef(
-  mediaElement: HTMLMediaElement,
+  mediaElement: IMediaElement,
   pipStatusRef: IReadOnlySharedReference<IPictureInPictureEvent>,
   stopListening: CancellationSignal,
 ): IReadOnlySharedReference<{
@@ -596,7 +621,7 @@ const onEnded = createCompatibleEventListener(["ended"]);
  * emits
  */
 function addEventListener(
-  elt: IEventEmitterLike,
+  elt: IEventEmitterLike | IEventTarget<Record<string, Event>>,
   evt: string,
   listener: (x?: unknown) => void,
   stopListening: CancellationSignal,

package/src/compat/get_start_date.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import type { IMediaElement } from "./browser_compatibility_types";
+
 /**
  * Calculating a live-offseted media position necessitate to obtain first an
  * offset, and then adding that offset to the wanted position.
@@ -28,8 +30,8 @@
  * @param {HTMLMediaElement} mediaElement
  * @returns {number|undefined}
  */
-export default function getStartDate(mediaElement: HTMLMediaElement): number | undefined {
-  const _mediaElement: HTMLMediaElement & {
+export default function getStartDate(mediaElement: IMediaElement): number | undefined {
+  const _mediaElement: IMediaElement & {
     getStartDate?: () => number | Date | null | undefined;
   } = mediaElement;
   if (typeof _mediaElement.getStartDate === "function") {

package/src/core/README.md

@@ -51,3 +51,8 @@ Those modules are:
   Link the `transports` module with the rest of the code, to download segments,
   download/refresh the manifest and collect data (such as the user's bandwidth) for the
   other modules.
+
+- **the `CmcdDataBuilder` (./cmcd)**
+
+  Perform data collection and retrieval for the "Common Media Client Data" scheme, which
+  is a specification allowing to communicate about playback conditions with a CDN.