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

package/src/core/decrypt/content_decryptor.ts

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-import {
-  events,
+import eme, {
   getInitData,
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
-} from "../../compat/";
+} from "../../compat/eme";
 import config from "../../config";
 import {
   EncryptedMediaError,
@@ -53,6 +52,8 @@ import {
   IMediaKeySessionStores,
   MediaKeySessionLoadingType,
   IProcessedProtectionData,
+  ContentDecryptorState,
+  IContentDecryptorEvent,
 } from "./types";
 import { DecommissionedSessionError } from "./utils/check_key_statuses";
 import cleanOldStoredPersistentInfo from "./utils/clean_old_stored_persistent_info";
@@ -60,14 +61,10 @@ import getDrmSystemId from "./utils/get_drm_system_id";
 import InitDataValuesContainer from "./utils/init_data_values_container";
 import {
   areAllKeyIdsContainedIn,
-  areKeyIdsEqual,
   areSomeKeyIdsContainedIn,
-  isKeyIdContainedIn,
 } from "./utils/key_id_comparison";
 import KeySessionRecord from "./utils/key_session_record";
 
-const { onEncrypted } = events;
-
 /**
  * Module communicating with the Content Decryption Module (or CDM) to be able
  * to decrypt contents.
@@ -126,12 +123,6 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    */
   private _canceller : TaskCanceller;
 
-  /**
-   * `true` once the `attach` method has been called`.
-   * Allows to avoid calling multiple times that function.
-   */
-  private _wasAttachCalled : boolean;
-
   /**
    * This queue stores initialization data which hasn't been processed yet,
    * probably because the "queue is locked" for now. (@see _stateData private
@@ -142,6 +133,16 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    */
   private _initDataQueue : IProtectionData[];
 
+  /**
+   * `true` if the EME API are available on the current platform according to
+   * the default EME implementation used.
+   * `false` otherwise.
+   * @returns {boolean}
+   */
+  public static hasEmeApis() : boolean {
+    return !isNullOrUndefined(eme.requestMediaKeySystemAccess);
+  }
+
   /**
    * Create a new `ContentDecryptor`, and initialize its decryption capabilities
    * right away.
@@ -156,7 +157,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * configurations. It will choose the appropriate one depending on user
    * settings and browser support.
    */
-  constructor(mediaElement : HTMLMediaElement, ksOptions: IKeySystemOption[]) {
+  constructor(mediaElement : HTMLMediaElement, ksOptions : IKeySystemOption[]) {
     super();
 
     log.debug("DRM: Starting ContentDecryptor logic.");
@@ -164,15 +165,14 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     const canceller = new TaskCanceller();
     this._currentSessions = [];
     this._canceller = canceller;
-    this._wasAttachCalled = false;
     this._initDataQueue = [];
     this._stateData = { state: ContentDecryptorState.Initializing,
-                        isMediaKeysAttached: false,
+                        isMediaKeysAttached: MediaKeyAttachmentStatus.NotAttached,
                         isInitDataQueueLocked: true,
                         data: null };
     this.error = null;
 
-    onEncrypted(mediaElement, evt => {
+    eme.onEncrypted(mediaElement, evt => {
       log.debug("DRM: Encrypted event received from media element.");
       const initData = getInitData(evt as MediaEncryptedEvent);
       if (initData !== null) {
@@ -204,7 +204,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
         if (this._stateData.state === ContentDecryptorState.Initializing) {
           this._stateData = { state: ContentDecryptorState.WaitingForAttachment,
                               isInitDataQueueLocked: true,
-                              isMediaKeysAttached: false,
+                              isMediaKeysAttached: MediaKeyAttachmentStatus.NotAttached,
                               data: { mediaKeysInfo,
                                       mediaElement } };
 
@@ -239,36 +239,43 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     if (this._stateData.state !== ContentDecryptorState.WaitingForAttachment) {
       throw new Error("`attach` should only be called when " +
                       "in the WaitingForAttachment state");
-    } else if (this._wasAttachCalled) {
+    } else if (
+      this._stateData.isMediaKeysAttached !== MediaKeyAttachmentStatus.NotAttached
+    ) {
       log.warn("DRM: ContentDecryptor's `attach` method called more than once.");
       return;
     }
-    this._wasAttachCalled = true;
 
     const { mediaElement, mediaKeysInfo } = this._stateData.data;
     const { options, mediaKeys, mediaKeySystemAccess, stores } = mediaKeysInfo;
-    const stateToAttatch = { loadedSessionsStore: stores.loadedSessionsStore,
-                             mediaKeySystemAccess,
-                             mediaKeys,
-                             keySystemOptions: options };
-
     const shouldDisableLock = options.disableMediaKeysAttachmentLock === true;
+
     if (shouldDisableLock) {
       this._stateData = { state: ContentDecryptorState.ReadyForContent,
                           isInitDataQueueLocked: true,
-                          isMediaKeysAttached: false,
-                          data: null };
+                          isMediaKeysAttached: MediaKeyAttachmentStatus.Pending,
+                          data: { mediaKeysInfo, mediaElement } };
       this.trigger("stateChange", this._stateData.state);
-      if (this._isStopped()) { // previous trigger might have lead to disposal
+
+      // previous trigger might have lead to disposal
+      if (this._isStopped()) {
         return ;
       }
     }
 
+    this._stateData.isMediaKeysAttached = MediaKeyAttachmentStatus.Pending;
+    const stateToAttach = { emeImplementation: eme,
+                            loadedSessionsStore: stores.loadedSessionsStore,
+                            mediaKeySystemAccess,
+                            mediaKeys,
+                            keySystemOptions: options };
+
     log.debug("DRM: Attaching current MediaKeys");
-    attachMediaKeys(mediaElement, stateToAttatch, this._canceller.signal)
+    attachMediaKeys(mediaElement, stateToAttach, this._canceller.signal)
       .then(async () => {
-        const { serverCertificate } = options;
+        this._stateData.isMediaKeysAttached = MediaKeyAttachmentStatus.Attached;
 
+        const { serverCertificate } = options;
         if (!isNullOrUndefined(serverCertificate)) {
           const resSsc = await setServerCertificate(mediaKeys, serverCertificate);
           if (resSsc.type === "error") {
@@ -282,7 +289,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
 
         const prevState = this._stateData.state;
         this._stateData = { state: ContentDecryptorState.ReadyForContent,
-                            isMediaKeysAttached: true,
+                            isMediaKeysAttached: MediaKeyAttachmentStatus.Attached,
                             isInitDataQueueLocked: false,
                             data: { mediaKeysData: mediaKeysInfo } };
         if (prevState !== ContentDecryptorState.ReadyForContent) {
@@ -413,9 +420,12 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
             // from `createdSess`'s `keyStatuses` and to update the content's
             // decipherability.
             for (const innerKid of periodKeysArr) {
-              if (!isKeyIdContainedIn(innerKid, createdSess.keyStatuses.whitelisted) &&
-                  !isKeyIdContainedIn(innerKid, createdSess.keyStatuses.blacklisted))
-              {
+              if (
+                !createdSess.keyStatuses.whitelisted
+                  .some(k => areArraysOfNumbersEqual(k, innerKid)) &&
+                !createdSess.keyStatuses.blacklisted
+                  .some(k => areArraysOfNumbersEqual(k, innerKid))
+              ) {
                 createdSess.keyStatuses.blacklisted.push(innerKid);
               }
             }
@@ -791,7 +801,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * Should have no effect if the `_initDataQueue` was not locked.
    */
   private _unlockInitDataQueue() : void {
-    if (this._stateData.isMediaKeysAttached !== true) {
+    if (this._stateData.isMediaKeysAttached !== MediaKeyAttachmentStatus.Attached) {
       log.error("DRM: Trying to unlock in the wrong state");
       return;
     }
@@ -846,17 +856,17 @@ function updateDecipherability(
     if (contentKIDs !== undefined) {
       for (const elt of contentKIDs) {
         for (const blacklistedKeyId of blacklistedKeyIds) {
-          if (areKeyIdsEqual(blacklistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(blacklistedKeyId, elt.keyId)) {
             return false;
           }
         }
         for (const whitelistedKeyId of whitelistedKeyIds) {
-          if (areKeyIdsEqual(whitelistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(whitelistedKeyId, elt.keyId)) {
             return true;
           }
         }
         for (const delistedKeyId of delistedKeyIds) {
-          if (areKeyIdsEqual(delistedKeyId, elt.keyId)) {
+          if (areArraysOfNumbersEqual(delistedKeyId, elt.keyId)) {
             return undefined;
           }
         }
@@ -903,226 +913,6 @@ function blackListProtectionData(
   });
 }
 
-/** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */
-export interface IContentDecryptorEvent {
-  /**
-   * Event emitted when a major error occured which made the ContentDecryptor
-   * stopped.
-   * When that event is sent, the `ContentDecryptor` is in the `Error` state and
-   * cannot be used anymore.
-   */
-  error : Error;
-
-  /**
-   * Event emitted when a minor error occured which the ContentDecryptor can
-   * recover from.
-   */
-  warning : IPlayerError;
-
-  /**
-   * Event emitted when the `ContentDecryptor`'s state changed.
-   * States are a central aspect of the `ContentDecryptor`, be sure to check the
-   * ContentDecryptorState type.
-   */
-  stateChange: ContentDecryptorState;
-}
-
-/** Enumeration of the various "state" the `ContentDecryptor` can be in. */
-export enum ContentDecryptorState {
-  /**
-   * The `ContentDecryptor` is not yet ready to create key sessions and request
-   * licenses.
-   * This is is the initial state of the ContentDecryptor.
-   */
-  Initializing,
-
-  /**
-   * The `ContentDecryptor` has been initialized.
-   * You should now called the `attach` method when you want to add decryption
-   * capabilities to the HTMLMediaElement. The ContentDecryptor won't go to the
-   * `ReadyForContent` state until `attach` is called.
-   *
-   * For compatibility reasons, this should be done after the HTMLMediaElement's
-   * src attribute is set.
-   *
-   * It is also from when this state is reached that the `ContentDecryptor`'s
-   * `systemId` property may be known.
-   *
-   * This state is always coming after the `Initializing` state.
-   */
-  WaitingForAttachment,
-
-  /**
-   * Content (encrypted or not) can begin to be pushed on the HTMLMediaElement
-   * (this state was needed because some browser quirks sometimes forces us to
-   * call EME API before this can be done).
-   *
-   * This state is always coming after the `WaitingForAttachment` state.
-   */
-  ReadyForContent,
-
-  /**
-   * The `ContentDecryptor` has encountered a fatal error and has been stopped.
-   * It is now unusable.
-   */
-  Error,
-
-  /** The `ContentDecryptor` has been disposed of and is now unusable. */
-  Disposed,
-}
-
-/** Possible states the ContentDecryptor is in and associated data for each one. */
-type IContentDecryptorStateData = IInitializingStateData |
-                                  IWaitingForAttachmentStateData |
-                                  IReadyForContentStateDataUnattached |
-                                  IReadyForContentStateDataAttached |
-                                  IDisposeStateData |
-                                  IErrorStateData;
-
-/** Skeleton that all variants of `IContentDecryptorStateData` use. */
-interface IContentDecryptorStateBase<
-  TStateName extends ContentDecryptorState,
-  TIsQueueLocked extends boolean | undefined,
-  TIsMediaKeyAttached extends boolean | undefined,
-  TData
-> {
-  /** Identify the ContentDecryptor's state. */
-  state: TStateName;
-  /**
-   * If `true`, the `ContentDecryptor` will wait before processing
-   * newly-received initialization data.
-   * If `false`, it will process them right away.
-   * Set to undefined when it won't ever process them like for example in a
-   * disposed or errored state.
-   */
-  isInitDataQueueLocked: TIsQueueLocked;
-  /**
-   * If `true`, the `MediaKeys` instance has been attached to the HTMLMediaElement.
-   * If `false`, it hasn't happened yet.
-   * If uncertain or unimportant (for example if the `ContentDecryptor` is an
-   * disposed/errored state, set to `undefined`).
-   */
-  isMediaKeysAttached: TIsMediaKeyAttached;
-  /** Data stored relative to that state. */
-  data: TData;
-}
-
-/** ContentDecryptor's internal data when in the `Initializing` state. */
-type IInitializingStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.Initializing,
-  true, // isInitDataQueueLocked
-  false, // isMediaKeysAttached
-  null // data
->;
-
-/** ContentDecryptor's internal data when in the `WaitingForAttachment` state. */
-type IWaitingForAttachmentStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.WaitingForAttachment,
-  true, // isInitDataQueueLocked
-  false, // isMediaKeysAttached
-  // data
-  { mediaKeysInfo : IMediaKeysInfos;
-    mediaElement : HTMLMediaElement; }
->;
-
-/**
- * ContentDecryptor's internal data when in the `ReadyForContent` state before
- * it has attached the `MediaKeys` to the media element.
- */
-type IReadyForContentStateDataUnattached = IContentDecryptorStateBase<
-  ContentDecryptorState.ReadyForContent,
-  true, // isInitDataQueueLocked
-  false, // isMediaKeysAttached
-  null // data
->;
-
-/**
- * ContentDecryptor's internal data when in the `ReadyForContent` state once
- * it has attached the `MediaKeys` to the media element.
- */
-type IReadyForContentStateDataAttached = IContentDecryptorStateBase<
-  ContentDecryptorState.ReadyForContent,
-  boolean, // isInitDataQueueLocked
-  true, // isMediaKeysAttached
-  {
-    /**
-     * MediaKeys-related information linked to this instance of the
-     * `ContentDecryptor`.
-     * Set to `null` until it is known.
-     * Should be always set when the `ContentDecryptor` has reached the
-     * Initialized state (@see ContentDecryptorState).
-     */
-    mediaKeysData : IAttachedMediaKeysData;
-  }
->;
-
-/** ContentDecryptor's internal data when in the `Disposed` state. */
-type IDisposeStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.Disposed,
-  undefined, // isInitDataQueueLocked
-  undefined, // isMediaKeysAttached
-  null // data
->;
-
-/** ContentDecryptor's internal data when in the `Error` state. */
-type IErrorStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.Error,
-  undefined, // isInitDataQueueLocked
-  undefined, // isMediaKeysAttached
-  null // data
->;
-
-/** Information linked to a session created by the `ContentDecryptor`. */
-interface IActiveSessionInfo {
-  /**
-   * Record associated to the session.
-   * Most notably, it allows both to identify the session as well as to
-   * anounce and find out which key ids are already handled.
-   */
-  record : KeySessionRecord;
-
-  /** Current keys' statuses linked that session. */
-  keyStatuses : {
-    /** Key ids linked to keys that are "usable". */
-    whitelisted : Uint8Array[];
-    /**
-     * Key ids linked to keys that are not considered "usable".
-     * Content linked to those keys are not decipherable and may thus be
-     * fallbacked from.
-     */
-    blacklisted : Uint8Array[];
-  };
-
-  /** Source of the MediaKeySession linked to that record. */
-  source : MediaKeySessionLoadingType;
-
-  /**
-   * If different than `null`, all initialization data compatible with this
-   * processed initialization data has been blacklisted with this corresponding
-   * error.
-   */
-  blacklistedSessionError : BlacklistedSessionError | null;
-}
-
-/**
- * Sent when the created (or already created) MediaKeys is attached to the
- * current HTMLMediaElement element.
- * On some peculiar devices, we have to wait for that step before the first
- * media segments are to be pushed to avoid issues.
- * Because this event is sent after a MediaKeys is created, you will always have
- * a "created-media-keys" event before an "attached-media-keys" event.
- */
-interface IAttachedMediaKeysData {
-  /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-  mediaKeySystemAccess: MediaKeySystemAccess |
-                        ICustomMediaKeySystemAccess;
-  /** The MediaKeys instance. */
-  mediaKeys : MediaKeys |
-              ICustomMediaKeys;
-  stores : IMediaKeySessionStores;
-  options : IKeySystemOption;
-}
-
 /**
  * Returns set of all usable and unusable keys - explicit or implicit - that are
  * linked to a `MediaKeySession`.
@@ -1180,7 +970,7 @@ function getKeyIdsLinkedToSession(
   // `usableKeyIds` nor in `unusableKeyIds`
   const allKnownKeyIds = keySessionRecord.getAssociatedKeyIds();
   for (const kid of allKnownKeyIds) {
-    if (!associatedKeyIds.some(ak => areKeyIdsEqual(ak, kid))) {
+    if (!associatedKeyIds.some(ak => areArraysOfNumbersEqual(ak, kid))) {
       if (log.hasLevel("DEBUG")) {
         log.debug("DRM: KeySessionRecord's key missing in the license, blacklisting it",
                   bytesToHex(kid));
@@ -1207,7 +997,7 @@ function getKeyIdsLinkedToSession(
             content } = initializationData;
     if (expectedKeyIds !== undefined) {
       const missingKeyIds = expectedKeyIds.filter(expected => {
-        return !associatedKeyIds.some(k => areKeyIdsEqual(k, expected));
+        return !associatedKeyIds.some(k => areArraysOfNumbersEqual(k, expected));
       });
       if (missingKeyIds.length > 0) {
         if (log.hasLevel("DEBUG")) {
@@ -1237,7 +1027,7 @@ function getKeyIdsLinkedToSession(
           } else {
             const periodKeysArr = Array.from(periodKeys);
             for (const kid of periodKeysArr) {
-              const isFound = associatedKeyIds.some(k => areKeyIdsEqual(k, kid));
+              const isFound = associatedKeyIds.some(k => areArraysOfNumbersEqual(k, kid));
               if (isFound) {
                 mergeKeyIdSetIntoArray(periodKeys, associatedKeyIds);
                 break;
@@ -1265,7 +1055,7 @@ function mergeKeyIdSetIntoArray(
 ) {
   const setArr = Array.from(set.values());
   for (const kid of setArr) {
-    const isFound = arr.some(k => areKeyIdsEqual(k, kid));
+    const isFound = arr.some(k => areArraysOfNumbersEqual(k, kid));
     if (!isFound) {
       arr.push(kid);
     }
@@ -1293,3 +1083,164 @@ function addKeyIdsFromPeriod(
     }
   }
 }
+
+/** Possible states the ContentDecryptor is in and associated data for each one. */
+type IContentDecryptorStateData = IInitializingStateData |
+                                  IWaitingForAttachmentStateData |
+                                  IReadyForContentStateDataUnattached |
+                                  IReadyForContentStateDataAttached |
+                                  IDisposeStateData |
+                                  IErrorStateData;
+
+/** Skeleton that all variants of `IContentDecryptorStateData` use. */
+interface IContentDecryptorStateBase<
+  TStateName extends ContentDecryptorState,
+  TIsQueueLocked extends boolean | undefined,
+  TIsMediaKeyAttached extends MediaKeyAttachmentStatus | undefined,
+  TData
+> {
+  /** Identify the ContentDecryptor's state. */
+  state: TStateName;
+  /**
+   * If `true`, the `ContentDecryptor` will wait before processing
+   * newly-received initialization data.
+   * If `false`, it will process them right away.
+   * Set to undefined when it won't ever process them like for example in a
+   * disposed or errored state.
+   */
+  isInitDataQueueLocked: TIsQueueLocked;
+  /**
+   * If `true`, the `MediaKeys` instance has been attached to the HTMLMediaElement.
+   * If `false`, it hasn't happened yet.
+   * If uncertain or unimportant (for example if the `ContentDecryptor` is an
+   * disposed/errored state, set to `undefined`).
+   */
+  isMediaKeysAttached: TIsMediaKeyAttached;
+  /** Data stored relative to that state. */
+  data: TData;
+}
+
+const enum MediaKeyAttachmentStatus {
+  NotAttached,
+  Pending,
+  Attached,
+}
+
+/** ContentDecryptor's internal data when in the `Initializing` state. */
+type IInitializingStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.Initializing,
+  true, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.NotAttached, // isMediaKeysAttached
+  null // data
+>;
+
+/** ContentDecryptor's internal data when in the `WaitingForAttachment` state. */
+type IWaitingForAttachmentStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.WaitingForAttachment,
+  true, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.NotAttached, // isMediaKeysAttached
+  // data
+  { mediaKeysInfo : IMediaKeysInfos;
+    mediaElement : HTMLMediaElement; }
+>;
+
+/**
+ * ContentDecryptor's internal data when in the `ReadyForContent` state before
+ * it has attached the `MediaKeys` to the media element.
+ */
+type IReadyForContentStateDataUnattached = IContentDecryptorStateBase<
+  ContentDecryptorState.ReadyForContent,
+  true, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.NotAttached |
+  MediaKeyAttachmentStatus.Pending, // isMediaKeysAttached
+  { mediaKeysInfo : IMediaKeysInfos;
+    mediaElement : HTMLMediaElement; } // data
+>;
+
+/**
+ * ContentDecryptor's internal data when in the `ReadyForContent` state once
+ * it has attached the `MediaKeys` to the media element.
+ */
+type IReadyForContentStateDataAttached = IContentDecryptorStateBase<
+  ContentDecryptorState.ReadyForContent,
+  boolean, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.Attached, // isMediaKeysAttached
+  {
+    /**
+     * MediaKeys-related information linked to this instance of the
+     * `ContentDecryptor`.
+     * Set to `null` until it is known.
+     * Should be always set when the `ContentDecryptor` has reached the
+     * Initialized state (@see ContentDecryptorState).
+     */
+    mediaKeysData : IAttachedMediaKeysData;
+  }
+>;
+
+/** ContentDecryptor's internal data when in the `Disposed` state. */
+type IDisposeStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.Disposed,
+  undefined, // isInitDataQueueLocked
+  undefined, // isMediaKeysAttached
+  null // data
+>;
+
+/** ContentDecryptor's internal data when in the `Error` state. */
+type IErrorStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.Error,
+  undefined, // isInitDataQueueLocked
+  undefined, // isMediaKeysAttached
+  null // data
+>;
+
+/** Information linked to a session created by the `ContentDecryptor`. */
+interface IActiveSessionInfo {
+  /**
+   * Record associated to the session.
+   * Most notably, it allows both to identify the session as well as to
+   * anounce and find out which key ids are already handled.
+   */
+  record : KeySessionRecord;
+
+  /** Current keys' statuses linked that session. */
+  keyStatuses : {
+    /** Key ids linked to keys that are "usable". */
+    whitelisted : Uint8Array[];
+    /**
+     * Key ids linked to keys that are not considered "usable".
+     * Content linked to those keys are not decipherable and may thus be
+     * fallbacked from.
+     */
+    blacklisted : Uint8Array[];
+  };
+
+  /** Source of the MediaKeySession linked to that record. */
+  source : MediaKeySessionLoadingType;
+
+  /**
+   * If different than `null`, all initialization data compatible with this
+   * processed initialization data has been blacklisted with this corresponding
+   * error.
+   */
+  blacklistedSessionError : BlacklistedSessionError | null;
+}
+
+/**
+ * Sent when the created (or already created) MediaKeys is attached to the
+ * current HTMLMediaElement element.
+ * On some peculiar devices, we have to wait for that step before the first
+ * media segments are to be pushed to avoid issues.
+ * Because this event is sent after a MediaKeys is created, you will always have
+ * a "created-media-keys" event before an "attached-media-keys" event.
+ */
+interface IAttachedMediaKeysData {
+  /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
+  mediaKeySystemAccess: MediaKeySystemAccess |
+                        ICustomMediaKeySystemAccess;
+  /** The MediaKeys instance. */
+  mediaKeys : MediaKeys |
+              ICustomMediaKeys;
+  stores : IMediaKeySessionStores;
+  options : IKeySystemOption;
+}
+

package/src/core/decrypt/create_or_load_session.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../compat";
+import { ICustomMediaKeySession } from "../../compat/eme";
 import log from "../../log";
 import { CancellationSignal } from "../../utils/task_canceller";
 import createSession from "./create_session";

package/src/core/decrypt/create_session.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../compat";
+import { ICustomMediaKeySession } from "../../compat/eme";
 import log from "../../log";
 import { CancellationSignal } from "../../utils/task_canceller";
 import {