rx-player 3.33.0 → 3.33.1

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

@@ -1,235 +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 { base64ToBytes } from "../../../utils/base64";
-import EventEmitter from "../../../utils/event_emitter";
-import noop from "../../../utils/noop";
-import { utf8ToStr } from "../../../utils/string_parsing";
-import wrapInPromise from "../../../utils/wrapInPromise";
-import {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
-
-export interface IOldWebkitHTMLMediaElement extends HTMLVideoElement {
-  webkitGenerateKeyRequest : (keyType: string, initData : ArrayBuffer) => void;
-  webkitAddKey : (
-    keyType: string,
-    key : BufferSource,
-    kid : BufferSource|null,
-    sessionId : string
-  ) => void;
-}
-
-/**
- * Returns true if the given media element has old webkit methods
- * corresponding to the IOldWebkitHTMLMediaElement interface.
- * @param {HTMLMediaElement} element
- * @returns {Boolean}
- */
-export function isOldWebkitMediaElement(
-  element : HTMLMediaElement|IOldWebkitHTMLMediaElement
-) : element is IOldWebkitHTMLMediaElement {
-  return typeof (element as IOldWebkitHTMLMediaElement)
-    .webkitGenerateKeyRequest === "function";
-}
-
-/**
- * MediaKeySession implementation for older versions of WebKit relying on APIs
- * such as `webkitGenerateKeyRequest` `webkitAddKey` to be called on the
- * HTMLMediaElement.
- * @class OldWebkitMediaKeySession
- */
-class OldWebkitMediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
-{
-  public readonly closed: Promise<void>;
-  public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
-  public sessionId: string;
-
-  private readonly _vid: IOldWebkitHTMLMediaElement;
-  private readonly _key: string;
-
-  private _closeSession : () => void;
-
-  constructor(mediaElement: IOldWebkitHTMLMediaElement, keySystem: string) {
-    super();
-    this._vid = mediaElement;
-    this._key = keySystem;
-
-    this.sessionId = "";
-    this._closeSession = noop; // Just here to make TypeScript happy
-    this.keyStatuses = new Map();
-    this.expiration = NaN;
-
-    const onSessionRelatedEvent = (evt : Event) => {
-      this.trigger(evt.type, evt);
-    };
-    this.closed = new Promise((resolve) => {
-      this._closeSession = () => {
-        ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-          .forEach(evt => {
-            mediaElement.removeEventListener(evt, onSessionRelatedEvent);
-            mediaElement.removeEventListener(`webkit${evt}`, onSessionRelatedEvent);
-          });
-        resolve();
-      };
-    });
-
-
-    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-      .forEach(evt => {
-        mediaElement.addEventListener(evt, onSessionRelatedEvent);
-        mediaElement.addEventListener(`webkit${evt}`, onSessionRelatedEvent);
-      });
-  }
-
-  public update(license: Uint8Array) : Promise<void> {
-    return new Promise((resolve, reject) => {
-      try {
-        if (this._key.indexOf("clearkey") >= 0) {
-          const licenseTypedArray =
-            license instanceof ArrayBuffer ? new Uint8Array(license) :
-            license;
-          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-          /* eslint-disable @typescript-eslint/no-unsafe-argument */
-          /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-          const json = JSON.parse(utf8ToStr(licenseTypedArray));
-          const key = base64ToBytes(json.keys[0].k);
-          const kid = base64ToBytes(json.keys[0].kid);
-          /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-          /* eslint-enable @typescript-eslint/no-unsafe-argument */
-          /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-          resolve(this._vid.webkitAddKey(this._key, key, kid, /* sessionId */ ""));
-        } else {
-          resolve(this._vid.webkitAddKey(this._key, license, null, /* sessionId */ ""));
-        }
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  public generateRequest(
-    _initDataType: string,
-    initData: ArrayBuffer
-  ): Promise<void> {
-    return new Promise((resolve) => {
-      this._vid.webkitGenerateKeyRequest(this._key, initData);
-      resolve();
-    });
-  }
-
-  public close(): Promise<void> {
-    return new Promise((resolve) => {
-      this._closeSession();
-      resolve();
-    });
-  }
-
-  /**
-   * Load a Persistent MediaKeySession.
-   * Do nothing here because this implementation doesn't handle them.
-   * @returns {Promise.<boolean>}
-   */
-  public load(): Promise<boolean> {
-    // Not implemented. Always return false as in "no session with that id".
-    return Promise.resolve(false);
-  }
-
-  public remove(): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
-  private readonly _keySystem: string;
-  private _videoElement?: IOldWebkitHTMLMediaElement;
-
-  constructor(keySystem: string) {
-    this._keySystem = keySystem;
-  }
-
-  _setVideo(videoElement: IOldWebkitHTMLMediaElement|HTMLMediaElement): Promise<unknown> {
-    return wrapInPromise(() => {
-      if (!isOldWebkitMediaElement(videoElement)) {
-        throw new Error("Video not attached to the MediaKeys");
-      }
-      this._videoElement = videoElement;
-    });
-  }
-
-  createSession(/* sessionType */): ICustomMediaKeySession {
-    if (this._videoElement == null) {
-      throw new Error("Video not attached to the MediaKeys");
-    }
-    return new OldWebkitMediaKeySession(this._videoElement, this._keySystem);
-  }
-
-  setServerCertificate(): Promise<void> {
-    throw new Error("Server certificate is not implemented in your browser");
-  }
-}
-
-export default function getOldWebKitMediaKeysCallbacks() : {
-  isTypeSupported: (keyType: string) => boolean;
-  createCustomMediaKeys: (keyType: string) => OldWebKitCustomMediaKeys;
-  setMediaKeys: (
-    elt: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => Promise<unknown>;
-} {
-  const isTypeSupported = function (keyType: string): boolean {
-    // get any <video> element from the DOM or create one
-    // and try the `canPlayType` method
-    let videoElement = document.querySelector("video");
-    if (videoElement == null) {
-      videoElement = document.createElement("video");
-    }
-    if (videoElement != null && typeof videoElement.canPlayType === "function") {
-      return !!(videoElement.canPlayType as unknown as (
-        mimeType : string,
-        keyType? : string
-      ) => boolean)("video/mp4", keyType);
-    } else {
-      return false;
-    }
-  };
-  const createCustomMediaKeys =
-    (keyType: string) => new OldWebKitCustomMediaKeys(keyType);
-  const setMediaKeys = (
-    elt: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): Promise<unknown> => {
-    if (mediaKeys === null) {
-      return Promise.resolve(undefined);
-    }
-    if (!(mediaKeys instanceof OldWebKitCustomMediaKeys)) {
-      throw new Error("Custom setMediaKeys is supposed to be called " +
-                      "with old webkit custom MediaKeys.");
-    }
-    return mediaKeys._setVideo(elt);
-  };
-  return {
-    isTypeSupported,
-    createCustomMediaKeys,
-    setMediaKeys,
-  };
-}

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

@@ -1,67 +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 { IEventEmitter } from "../../../utils/event_emitter";
-
-export interface ICustomMediaKeySession extends IEventEmitter<IMediaKeySessionEvents> {
-  // Attributes
-  readonly closed: Promise<void>;
-  expiration: number;
-  keyStatuses: ICustomMediaKeyStatusMap;
-  sessionId : string;
-
-  // Event handlers
-  onmessage? : (message : MediaKeyMessageEvent) => void;
-  onkeystatusesChange? : (evt : Event) => void;
-
-  // Functions
-
-  generateRequest(initDataType: string,
-                  initData: BufferSource | null)
-                 : Promise<void>;
-
-  load(sessionId: string) : Promise<boolean>;
-  update(response: BufferSource | null): Promise<void>;
-  close() : Promise<void>;
-  remove() : Promise<void>;
-}
-
-export interface ICustomMediaKeys {
-  _setVideo : (vid : HTMLMediaElement) => Promise<unknown>;
-  createSession(sessionType? : MediaKeySessionType) : ICustomMediaKeySession;
-  setServerCertificate(setServerCertificate : BufferSource) : Promise<void>;
-}
-
-export interface ICustomMediaKeyStatusMap {
-  readonly size: number;
-  forEach(callback: (status : MediaKeyStatus) => void, thisArg?: unknown): void;
-  get(
-    keyId: BufferSource |
-           null
-  ) : MediaKeyStatus|undefined;
-  has(
-    keyId: BufferSource |
-           null
-    ) : boolean;
-}
-
-export interface IMediaKeySessionEvents { [key : string] : MediaKeyMessageEvent|Event;
-                                          // "keymessage"
-                                          // "message"
-                                          // "keyadded"
-                                          // "ready"
-                                          // "keyerror"
-                                          /* "error" */ }

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

@@ -1,308 +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 EventEmitter from "../../../utils/event_emitter";
-import noop from "../../../utils/noop";
-import startsWith from "../../../utils/starts_with";
-import wrapInPromise from "../../../utils/wrapInPromise";
-import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
-import {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
-import {
-  IWebKitMediaKeys,
-  WebKitMediaKeysConstructor,
-} from "./webkit_media_keys_constructor";
-
-export interface ICustomWebKitMediaKeys {
-  _setVideo: (videoElement: HTMLMediaElement) => void;
-  createSession(mimeType: string, initData: Uint8Array): ICustomMediaKeySession;
-  setServerCertificate(setServerCertificate: BufferSource): Promise<void>;
-}
-
-/**
- * Check if keyType is for fairplay DRM
- * @param {string} keyType
- * @returns {boolean}
- */
-function isFairplayKeyType(keyType: string): boolean {
-  return startsWith(keyType, "com.apple.fps");
-}
-
-/**
- * Set media keys on video element using native HTMLMediaElement
- * setMediaKeys from WebKit.
- * @param {HTMLMediaElement} videoElement
- * @param {Object|null} mediaKeys
- * @returns {Promise}
- */
-function setWebKitMediaKeys(
-  videoElement: HTMLMediaElement,
-  mediaKeys: unknown
-): Promise<unknown> {
-  const elt : ICompatHTMLMediaElement = videoElement;
-  return wrapInPromise(() => {
-    if (elt.webkitSetMediaKeys === undefined) {
-      throw new Error("No webKitMediaKeys API.");
-    }
-    elt.webkitSetMediaKeys(mediaKeys);
-  });
-}
-
-/**
- * On Safari browsers (>= 9), there are specific webkit prefixed APIs for cyphered
- * content playback. Standard EME APIs are therefore available since Safari 12.1, but they
- * don't allow to play fairplay cyphered content.
- *
- * This class implements a standard EME API polyfill that wraps webkit prefixed Safari
- * EME custom APIs.
- */
-class WebkitMediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
-{
-  public readonly closed: Promise<void>;
-  public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
-
-  private readonly _videoElement: HTMLMediaElement;
-  private readonly _keyType: string;
-  private _nativeSession: undefined | MediaKeySession;
-  private _serverCertificate: Uint8Array | undefined;
-
-  private _closeSession : () => void;
-  private _unbindSession : () => void;
-
-  /**
-   * @param {HTMLMediaElement} mediaElement
-   * @param {string} keyType
-   * @param {Uint8Array | undefined} serverCertificate
-   */
-  constructor(
-    mediaElement: HTMLMediaElement,
-    keyType: string,
-    serverCertificate?: Uint8Array
-  ) {
-    super();
-    this._serverCertificate = serverCertificate;
-    this._videoElement = mediaElement;
-    this._keyType = keyType;
-
-    this._unbindSession = noop;
-    this._closeSession = noop; // Just here to make TypeScript happy
-    this.closed = new Promise((resolve) => {
-      this._closeSession = resolve;
-    });
-    this.keyStatuses = new Map();
-    this.expiration = NaN;
-  }
-
-  public update(license: BufferSource) : Promise<void> {
-    return new Promise((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 */
-    });
-  }
-
-  public generateRequest(
-    _initDataType: string,
-    initData: ArrayBuffer
-  ): Promise<void> {
-    return new Promise((resolve) => {
-      const elt = this._videoElement as ICompatHTMLMediaElement;
-      if (elt.webkitKeys?.createSession === undefined) {
-        throw new Error("No WebKitMediaKeys API.");
-      }
-
-      let formattedInitData;
-      if (isFairplayKeyType(this._keyType)) {
-        if (this._serverCertificate === undefined) {
-          throw new Error(
-            "A server certificate is needed for creating fairplay session.");
-        }
-        formattedInitData = getWebKitFairplayInitData(initData, this._serverCertificate);
-      } else {
-        formattedInitData = initData;
-      }
-
-      const keySession =
-        elt.webkitKeys.createSession("video/mp4", formattedInitData);
-      if (keySession === undefined || keySession === null) {
-        throw new Error("Impossible to get the key sessions");
-      }
-      this._listenEvent(keySession);
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      this._nativeSession = keySession;
-      resolve();
-    });
-  }
-
-  public close(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this._unbindSession();
-      this._closeSession();
-      if (this._nativeSession === undefined) {
-        reject("No session to close.");
-        return;
-      }
-      /* eslint-disable @typescript-eslint/no-floating-promises */
-      this._nativeSession.close();
-      /* eslint-enable @typescript-eslint/no-floating-promises */
-      resolve();
-    });
-  }
-
-  load(): Promise<boolean> {
-    return Promise.resolve(false);
-  }
-
-  remove(): Promise<void> {
-    return Promise.resolve();
-  }
-
-  get sessionId(): string {
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-disable @typescript-eslint/no-unsafe-return */
-    return this._nativeSession?.sessionId ?? "";
-    /* 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
-
-    const onEvent = (evt : Event) => {
-      this.trigger(evt.type, evt);
-    };
-
-    /* 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, onEvent);
-        session.addEventListener(`webkit${evt}`, onEvent);
-      });
-
-    this._unbindSession = () => {
-      ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-        .forEach(evt => {
-          session.removeEventListener(evt, onEvent);
-          session.removeEventListener(`webkit${evt}`, 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 {
-  private _videoElement?: HTMLMediaElement;
-  private _mediaKeys?: IWebKitMediaKeys;
-  private _serverCertificate?: Uint8Array;
-  private _keyType: string;
-
-  constructor(keyType: string) {
-    if (WebKitMediaKeysConstructor === undefined) {
-      throw new Error("No WebKitMediaKeys API.");
-    }
-    this._keyType = keyType;
-    this._mediaKeys = new WebKitMediaKeysConstructor(keyType);
-  }
-
-  _setVideo(videoElement: HTMLMediaElement): Promise<unknown> {
-    this._videoElement = videoElement;
-    if (this._videoElement === undefined) {
-      throw new Error("Video not attached to the MediaKeys");
-    }
-    return setWebKitMediaKeys(this._videoElement, this._mediaKeys);
-  }
-
-  createSession(/* sessionType */): ICustomMediaKeySession {
-    if (this._videoElement === undefined ||
-        this._mediaKeys === undefined) {
-      throw new Error("Video not attached to the MediaKeys");
-    }
-    return new WebkitMediaKeySession(this._videoElement,
-                                     this._keyType,
-                                     this._serverCertificate);
-  }
-
-  setServerCertificate(serverCertificate: Uint8Array): Promise<void> {
-    this._serverCertificate = serverCertificate;
-    return Promise.resolve();
-  }
-}
-
-export default function getWebKitMediaKeysCallbacks() : {
-  isTypeSupported: (keyType: string) => boolean;
-  createCustomMediaKeys: (keyType: string) => WebKitCustomMediaKeys;
-  setMediaKeys: (
-    elt: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => Promise<unknown>;
-} {
-  if (WebKitMediaKeysConstructor === undefined) {
-    throw new Error("No WebKitMediaKeys API.");
-  }
-  const isTypeSupported = WebKitMediaKeysConstructor.isTypeSupported;
-  const createCustomMediaKeys = (keyType: string) =>
-    new WebKitCustomMediaKeys(keyType);
-  const setMediaKeys = (
-    elt: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): Promise<unknown> => {
-    if (mediaKeys === null) {
-      return setWebKitMediaKeys(elt, mediaKeys);
-    }
-    if (!(mediaKeys instanceof WebKitCustomMediaKeys)) {
-      throw new Error("Custom setMediaKeys is supposed to be called " +
-                      "with webkit custom MediaKeys.");
-    }
-    return mediaKeys._setVideo(elt);
-  };
-  return {
-    isTypeSupported,
-    createCustomMediaKeys,
-    setMediaKeys,
-  };
-}

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

@@ -1,50 +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 { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import isNode from "../../is_node";
-
-type IWebKitMediaKeys = unknown;
-
-interface IWebKitMediaKeysConstructor {
-  new(keySystem: string) : IWebKitMediaKeys;
-  isTypeSupported: (keyType: string) => boolean;
-}
-
-let WebKitMediaKeysConstructor: undefined|IWebKitMediaKeysConstructor;
-
-if (!isNode) {
-  /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-  const { WebKitMediaKeys } = (window as Window & {
-    WebKitMediaKeys? : IWebKitMediaKeysConstructor;
-  });
-
-  if (WebKitMediaKeys !== undefined &&
-      typeof WebKitMediaKeys.isTypeSupported === "function" &&
-      typeof WebKitMediaKeys.prototype.createSession === "function" &&
-      typeof (HTMLMediaElement.prototype as ICompatHTMLMediaElement)
-        .webkitSetMediaKeys === "function") {
-    WebKitMediaKeysConstructor = WebKitMediaKeys;
-  }
-  /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-}
-
-export {
-  WebKitMediaKeysConstructor,
-  IWebKitMediaKeys,
-};