rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -16,6 +16,7 @@
 
 import EventEmitter from "../../../utils/event_emitter";
 import TaskCanceller from "../../../utils/task_canceller";
+import wrapInPromise from "../../../utils/wrapInPromise";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import * as events from "../../event_listeners";
 import {
@@ -119,11 +120,13 @@ class IE11CustomMediaKeys implements ICustomMediaKeys {
     this._mediaKeys = new MSMediaKeysConstructor(keyType);
   }
 
-  _setVideo(videoElement: HTMLMediaElement): void {
-    this._videoElement = videoElement as ICompatHTMLMediaElement;
-    if (this._videoElement.msSetMediaKeys !== undefined) {
-      return this._videoElement.msSetMediaKeys(this._mediaKeys);
-    }
+  _setVideo(videoElement: HTMLMediaElement): Promise<unknown> {
+    return wrapInPromise(() => {
+      this._videoElement = videoElement as ICompatHTMLMediaElement;
+      if (this._videoElement.msSetMediaKeys !== undefined) {
+        this._videoElement.msSetMediaKeys(this._mediaKeys);
+      }
+    });
   }
 
   createSession(/* sessionType */): ICustomMediaKeySession {
@@ -144,7 +147,7 @@ export default function getIE11MediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string|null) => {
     if (MSMediaKeysConstructor === undefined) {
@@ -160,12 +163,12 @@ export default function getIE11MediaKeysCallbacks() : {
   const setMediaKeys = (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
+  ): Promise<unknown> => {
     if (mediaKeys === null) {
       // msSetMediaKeys only accepts native MSMediaKeys as argument.
       // Calling it with null or undefined will raise an exception.
       // There is no way to unset the mediakeys in that case, so return here.
-      return;
+      return Promise.resolve(undefined);
     }
     if (!(mediaKeys instanceof IE11CustomMediaKeys)) {
       throw new Error("Custom setMediaKeys is supposed to be called " +

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

@@ -1,26 +1,3 @@
-/**
- * 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 { MediaError } from "../../../errors";
-import assert from "../../../utils/assert";
-import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import { isIE11 } from "../../browser_detection";
-import isNode from "../../is_node";
-import shouldFavourCustomSafariEME from "../../should_favour_custom_safari_EME";
-import CustomMediaKeySystemAccess from "./../custom_key_system_access";
 import getIE11MediaKeysCallbacks, {
   MSMediaKeysConstructor,
 } from "./ie11_media_keys";
@@ -37,168 +14,15 @@ import {
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-/** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
-type ICompatRequestMediaKeySystemAccessFn =
-  (keyType : string, config : MediaKeySystemConfiguration[]) =>
-    Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
-
-let requestMediaKeySystemAccess : ICompatRequestMediaKeySystemAccessFn | null = null;
-
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- */
-let setMediaKeys :
-((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown) =
-  function defaultSetMediaKeys(
-    mediaElement: HTMLMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null
-  ) {
-    const elt : ICompatHTMLMediaElement = mediaElement;
-    /* eslint-disable @typescript-eslint/unbound-method */
-    if (typeof elt.setMediaKeys === "function") {
-      return elt.setMediaKeys(mediaKeys as MediaKeys);
-    }
-    /* eslint-enable @typescript-eslint/unbound-method */
-
-    // If we get in the following code, it means that no compat case has been
-    // found and no standard setMediaKeys API exists. This case is particulary
-    // rare. We will try to call each API with native media keys.
-    if (typeof elt.webkitSetMediaKeys === "function") {
-      return elt.webkitSetMediaKeys(mediaKeys);
-    }
-
-    if (typeof elt.mozSetMediaKeys === "function") {
-      return elt.mozSetMediaKeys(mediaKeys);
-    }
-
-    if (typeof elt.msSetMediaKeys === "function" && mediaKeys !== null) {
-      return elt.msSetMediaKeys(mediaKeys);
-    }
-  };
-
-/**
- * Since Safari 12.1, EME APIs are available without webkit prefix.
- * However, it seems that since fairplay CDM implementation within the browser is not
- * standard with EME w3c current spec, the requestMediaKeySystemAccess API doesn't resolve
- * positively, even if the drm (fairplay in most cases) is supported.
- *
- * Therefore, we prefer not to use requestMediaKeySystemAccess on Safari when webkit API
- * is available.
- */
-if (isNode ||
-    (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())
-) {
-  requestMediaKeySystemAccess = (...args) =>
-    navigator.requestMediaKeySystemAccess(...args);
-} else {
-  let isTypeSupported: (keyType: string) => boolean;
-  let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
-
-  // This is for Chrome with unprefixed EME api
-  if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
-    const callbacks = getOldKitWebKitMediaKeyCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  // This is for WebKit with prefixed EME api
-  } else if (WebKitMediaKeysConstructor !== undefined) {
-    const callbacks = getWebKitMediaKeysCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  } else if (isIE11 && MSMediaKeysConstructor !== undefined) {
-    const callbacks = getIE11MediaKeysCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  } else if (MozMediaKeysConstructor !== undefined) {
-    const callbacks = getMozMediaKeysCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  } else {
-    const MK = window.MediaKeys as unknown as typeof MediaKeys & {
-      isTypeSupported? : (keyType : string) => boolean;
-      new(keyType? : string) : ICustomMediaKeys;
-    };
-    const checkForStandardMediaKeys = () => {
-      if (MK === undefined) {
-        throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED",
-                             "No `MediaKeys` implementation found " +
-                             "in the current browser.");
-      }
-      if (typeof MK.isTypeSupported === "undefined") {
-        const message = "This browser seems to be unable to play encrypted contents " +
-                        "currently. Note: Some browsers do not allow decryption " +
-                        "in some situations, like when not using HTTPS.";
-        throw new Error(message);
-      }
-    };
-    isTypeSupported = (keyType: string): boolean => {
-      checkForStandardMediaKeys();
-      assert(typeof MK.isTypeSupported === "function");
-      return MK.isTypeSupported(keyType);
-    };
-    createCustomMediaKeys = (keyType: string) => {
-      checkForStandardMediaKeys();
-      return new MK(keyType);
-    };
-  }
-
-  requestMediaKeySystemAccess = function(
-    keyType : string,
-    keySystemConfigurations : MediaKeySystemConfiguration[]
-  ) : Promise<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
-    if (!isTypeSupported(keyType)) {
-      return Promise.reject(new Error("Unsupported key type"));
-    }
-
-    for (let i = 0; i < keySystemConfigurations.length; i++) {
-      const keySystemConfiguration = keySystemConfigurations[i];
-      const { videoCapabilities,
-              audioCapabilities,
-              initDataTypes,
-              distinctiveIdentifier } = keySystemConfiguration;
-      let supported = true;
-      supported = supported &&
-                  (initDataTypes == null ||
-                   initDataTypes.some((idt) => idt === "cenc"));
-      supported = supported && (distinctiveIdentifier !== "required");
-
-      if (supported) {
-        const keySystemConfigurationResponse : MediaKeySystemConfiguration = {
-          initDataTypes: ["cenc"],
-          distinctiveIdentifier: "not-allowed" as const,
-          persistentState: "required" as const,
-          sessionTypes: ["temporary", "persistent-license"],
-        };
-        if (videoCapabilities !== undefined) {
-          keySystemConfigurationResponse.videoCapabilities = videoCapabilities;
-        }
-        if (audioCapabilities !== undefined) {
-          keySystemConfigurationResponse.audioCapabilities = audioCapabilities;
-        }
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const customMediaKeys = createCustomMediaKeys(keyType);
-        return Promise.resolve(
-          new CustomMediaKeySystemAccess(keyType,
-                                         customMediaKeys,
-                                         keySystemConfigurationResponse)
-        );
-      }
-    }
-
-    return Promise.reject(new Error("Unsupported configuration"));
-  };
-}
-
 export {
-  requestMediaKeySystemAccess,
-  setMediaKeys,
+  getIE11MediaKeysCallbacks,
+  MSMediaKeysConstructor,
+  getMozMediaKeysCallbacks,
+  MozMediaKeysConstructor,
+  getOldKitWebKitMediaKeyCallbacks,
+  isOldWebkitMediaElement,
   ICustomMediaKeys,
   ICustomMediaKeySession,
+  getWebKitMediaKeysCallbacks,
+  WebKitMediaKeysConstructor,
 };

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

@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 
+import wrapInPromise from "../../../utils/wrapInPromise";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import isNode from "../../is_node";
+import globalScope from "../../global_scope";
 import { ICustomMediaKeys } from "./types";
 
 interface IMozMediaKeysConstructor {
@@ -24,20 +25,18 @@ interface IMozMediaKeysConstructor {
 }
 
 let MozMediaKeysConstructor: IMozMediaKeysConstructor|undefined;
-if (!isNode) {
-  const { MozMediaKeys } = (window as Window & {
-    MozMediaKeys? : IMozMediaKeysConstructor;
-  });
-  if (
-    MozMediaKeys !== undefined &&
-    MozMediaKeys.prototype !== undefined &&
-    typeof MozMediaKeys.isTypeSupported === "function" &&
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    typeof MozMediaKeys.prototype.createSession === "function"
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-  ) {
-    MozMediaKeysConstructor = MozMediaKeys;
-  }
+const { MozMediaKeys } = (globalScope as typeof globalThis & {
+  MozMediaKeys? : IMozMediaKeysConstructor;
+});
+if (
+  MozMediaKeys !== undefined &&
+  MozMediaKeys.prototype !== undefined &&
+  typeof MozMediaKeys.isTypeSupported === "function" &&
+  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+  typeof MozMediaKeys.prototype.createSession === "function"
+  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+) {
+  MozMediaKeysConstructor = MozMediaKeys;
 }
 export { MozMediaKeysConstructor };
 
@@ -47,7 +46,7 @@ export default function getMozMediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string|null) => {
     if (MozMediaKeysConstructor === undefined) {
@@ -67,12 +66,17 @@ export default function getMozMediaKeysCallbacks() : {
   const setMediaKeys = (
     mediaElement: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
-    const elt : ICompatHTMLMediaElement = mediaElement;
-    if (elt.mozSetMediaKeys === undefined || typeof elt.mozSetMediaKeys !== "function") {
-      throw new Error("Can't set video on MozMediaKeys.");
-    }
-    return elt.mozSetMediaKeys(mediaKeys);
+  ): Promise<unknown> => {
+    return wrapInPromise(() => {
+      const elt : ICompatHTMLMediaElement = mediaElement;
+      if (
+        elt.mozSetMediaKeys === undefined ||
+        typeof elt.mozSetMediaKeys !== "function"
+      ) {
+        throw new Error("Can't set video on MozMediaKeys.");
+      }
+      return elt.mozSetMediaKeys(mediaKeys);
+    });
   };
   return {
     isTypeSupported,

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import isNode from "../../is_node";
+import globalScope from "../../global_scope";
 
 export interface MSMediaKeyError {
     readonly code: number;
@@ -51,19 +51,17 @@ interface IMSMediaKeysConstructor {
 }
 
 let MSMediaKeysConstructor: IMSMediaKeysConstructor|undefined;
-if (!isNode) {
-  const { MSMediaKeys } = (window as Window & {
-    MSMediaKeys? : IMSMediaKeysConstructor;
-  });
-  if (
-    MSMediaKeys !== undefined &&
-    MSMediaKeys.prototype !== undefined &&
-    typeof MSMediaKeys.isTypeSupported === "function" &&
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    typeof MSMediaKeys.prototype.createSession === "function"
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-  ) {
-    MSMediaKeysConstructor = MSMediaKeys;
-  }
+const { MSMediaKeys } = (globalScope as typeof globalThis & {
+  MSMediaKeys? : IMSMediaKeysConstructor;
+});
+if (
+  MSMediaKeys !== undefined &&
+  MSMediaKeys.prototype !== undefined &&
+  typeof MSMediaKeys.isTypeSupported === "function" &&
+  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+  typeof MSMediaKeys.prototype.createSession === "function"
+  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+) {
+  MSMediaKeysConstructor = MSMediaKeys;
 }
 export { MSMediaKeysConstructor };

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

@@ -18,6 +18,7 @@ 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,
@@ -166,11 +167,13 @@ class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
     this._keySystem = keySystem;
   }
 
-  _setVideo(videoElement: IOldWebkitHTMLMediaElement|HTMLMediaElement): void {
-    if (!isOldWebkitMediaElement(videoElement)) {
-      throw new Error("Video not attached to the MediaKeys");
-    }
-    this._videoElement = videoElement;
+  _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 {
@@ -191,7 +194,7 @@ export default function getOldWebKitMediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   const isTypeSupported = function (keyType: string): boolean {
     // get any <video> element from the DOM or create one
@@ -214,9 +217,9 @@ export default function getOldWebKitMediaKeysCallbacks() : {
   const setMediaKeys = (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
+  ): Promise<unknown> => {
     if (mediaKeys === null) {
-      return;
+      return Promise.resolve(undefined);
     }
     if (!(mediaKeys instanceof OldWebKitCustomMediaKeys)) {
       throw new Error("Custom setMediaKeys is supposed to be called " +

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

@@ -40,7 +40,7 @@ export interface ICustomMediaKeySession extends IEventEmitter<IMediaKeySessionEv
 }
 
 export interface ICustomMediaKeys {
-  _setVideo : (vid : HTMLMediaElement) => void;
+  _setVideo : (vid : HTMLMediaElement) => Promise<unknown>;
   createSession(sessionType? : MediaKeySessionType) : ICustomMediaKeySession;
   setServerCertificate(setServerCertificate : BufferSource) : Promise<void>;
 }

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

@@ -16,6 +16,8 @@
 
 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 {
@@ -41,8 +43,7 @@ export interface ICustomWebKitMediaKeys {
  * @returns {boolean}
  */
 function isFairplayKeyType(keyType: string): boolean {
-  return keyType === "com.apple.fps.1_0" ||
-         keyType === "com.apple.fps.2_0";
+  return startsWith(keyType, "com.apple.fps");
 }
 
 /**
@@ -50,16 +51,19 @@ function isFairplayKeyType(keyType: string): boolean {
  * setMediaKeys from WebKit.
  * @param {HTMLMediaElement} videoElement
  * @param {Object|null} mediaKeys
+ * @returns {Promise}
  */
 function setWebKitMediaKeys(
   videoElement: HTMLMediaElement,
-  mediaKeys: IWebKitMediaKeys|null
-): void {
+  mediaKeys: unknown
+): Promise<unknown> {
   const elt : ICompatHTMLMediaElement = videoElement;
-  if (elt.webkitSetMediaKeys === undefined) {
-    throw new Error("No webKitMediaKeys API.");
-  }
-  return elt.webkitSetMediaKeys(mediaKeys);
+  return wrapInPromise(() => {
+    if (elt.webkitSetMediaKeys === undefined) {
+      throw new Error("No webKitMediaKeys API.");
+    }
+    elt.webkitSetMediaKeys(mediaKeys);
+  });
 }
 
 /**
@@ -245,7 +249,7 @@ class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
     this._mediaKeys = new WebKitMediaKeysConstructor(keyType);
   }
 
-  _setVideo(videoElement: HTMLMediaElement): void {
+  _setVideo(videoElement: HTMLMediaElement): Promise<unknown> {
     this._videoElement = videoElement;
     if (this._videoElement === undefined) {
       throw new Error("Video not attached to the MediaKeys");
@@ -275,7 +279,7 @@ export default function getWebKitMediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   if (WebKitMediaKeysConstructor === undefined) {
     throw new Error("No WebKitMediaKeys API.");
@@ -286,7 +290,7 @@ export default function getWebKitMediaKeysCallbacks() : {
   const setMediaKeys = (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
+  ): Promise<unknown> => {
     if (mediaKeys === null) {
       return setWebKitMediaKeys(elt, mediaKeys);
     }

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

@@ -15,7 +15,7 @@
  */
 
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import isNode from "../../is_node";
+import globalScope from "../../global_scope";
 
 type IWebKitMediaKeys = unknown;
 
@@ -26,23 +26,21 @@ interface IWebKitMediaKeysConstructor {
 
 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;
-  });
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const { WebKitMediaKeys } = (globalScope as typeof globalThis & {
+  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 */
+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,