rx-player 3.26.1 → 3.26.2

package/src/core/eme/session_events_listener.ts

@@ -15,27 +15,24 @@
  */
 
 import {
+  catchError,
   concat as observableConcat,
+  concatMap,
   defer as observableDefer,
   EMPTY,
   identity,
+  map,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
-  Subject,
-  TimeoutError,
-} from "rxjs";
-import {
-  catchError,
-  concatMap,
-  map,
-  mapTo,
-  mergeMap,
   startWith,
+  Subject,
   takeUntil,
   tap,
   timeout,
-} from "rxjs/operators";
+  TimeoutError,
+} from "rxjs";
 import {
   events,
   ICustomMediaKeySession,
@@ -109,7 +106,7 @@ export default function SessionEventsListener(
                IKeysUpdateEvent |
                ISessionUpdatedEvent>
 {
-  log.info("EME: Binding session events", session);
+  log.info("EME: Binding session events", session.sessionId);
   const sessionWarningSubject$ = new Subject<IEMEWarningEvent>();
   const { getLicenseConfig = {} } = keySystemOptions;
 
@@ -132,7 +129,9 @@ export default function SessionEventsListener(
         messageEvent.messageType :
         "license-request";
 
-      log.info(`EME: Received message event, type ${messageType}`, session, messageEvent);
+      log.info(`EME: Received message event, type ${messageType}`,
+               session.sessionId,
+               messageEvent);
       const getLicense$ = observableDefer(() => {
         const getLicense = keySystemOptions.getLicense(message, messageType);
         const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
@@ -289,8 +288,8 @@ function updateSessionWithMessage(
       throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason);
     }),
     tap(() => { log.info("EME: MediaKeySession update succeeded."); }),
-    mapTo({ type: "session-updated" as const,
-            value: { session, license: message, initializationData } })
+    map(() => ({ type: "session-updated" as const,
+                 value: { session, license: message, initializationData } }))
   );
 }
 
@@ -306,7 +305,7 @@ function handleKeyStatusesChangeEvent(
   keySystem : string,
   keyStatusesEvent : Event
 ) : Observable<IKeyStatusChangeHandledEvent | IKeysUpdateEvent | IEMEWarningEvent> {
-  log.info("EME: keystatuseschange event received", session, keyStatusesEvent);
+  log.info("EME: keystatuseschange event received", session.sessionId);
   const callback$ = observableDefer(() => {
     return tryCatch(() => {
       if (typeof keySystemOptions.onKeyStatusesChange !== "function") {

package/src/core/eme/set_server_certificate.ts

@@ -15,16 +15,14 @@
  */
 
 import {
+  catchError,
   defer as observableDefer,
   EMPTY,
+  ignoreElements,
+  tap,
   Observable,
   of as observableOf,
 } from "rxjs";
-import {
-  catchError,
-  ignoreElements,
-  tap,
-} from "rxjs/operators";
 import { ICustomMediaKeys } from "../../compat";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
@@ -96,6 +94,12 @@ export default function trySettingServerCertificate(
     ServerCertificateStore.prepare(mediaKeys);
     return setServerCertificate(mediaKeys, serverCertificate).pipe(
       tap(() => { ServerCertificateStore.set(mediaKeys, serverCertificate); }),
+
+      // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+      // first type parameter as `any` instead of the perfectly fine `unknown`,
+      // leading to linter issues, as it forbids the usage of `any`.
+      // This is why we're disabling the eslint rule.
+      /* eslint-disable @typescript-eslint/no-unsafe-argument */
       ignoreElements(),
       catchError(error => observableOf({
         type: "warning" as const,

package/src/core/eme/types.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-import { Subject } from "rxjs";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
   ICustomMediaKeySystemAccess,
 } from "../../compat";
 import { ICustomError } from "../../errors";
+import { ISharedReference } from "../../utils/reference";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 import PersistentSessionsStore from "./utils/persistent_sessions_store";
 
@@ -78,8 +78,10 @@ export interface IEncryptedEvent { type: "encrypted-event-received";
  * current content.
  * This is necessary before creating a MediaKeySession which will allow
  * encryption keys to be communicated.
- * It carries a subject (attachMediaKeys$) that will be used by the init to
- * ask the EME to attach the mediakeys.
+ *
+ * It carries a shared reference (`canAttachMediaKeys`) that should be setted to
+ * `true` to indicate that RxPlayer's EME logic can start to attach the
+ * `MediaKeys` instance to the HTMLMediaElement.
  */
 export interface ICreatedMediaKeysEvent {
   type: "created-media-keys";
@@ -115,9 +117,18 @@ export interface ICreatedMediaKeysEvent {
     /** The MediaKeys instance. */
     mediaKeys : MediaKeys |
                 ICustomMediaKeys;
+
+    /** Stores allowing to cache MediaKeySession instances. */
     stores : IMediaKeySessionStores;
+
+    /** key system options considered. */
     options : IKeySystemOption;
-    attachMediaKeys$: Subject<void>;
+
+    /**
+     * Shared reference that should be set to `true` once the `MediaKeys`
+     * instance can be attached to the HTMLMediaElement.
+     */
+    canAttachMediaKeys: ISharedReference<boolean>;
   };
 }
 

package/src/core/eme/utils/close_session.ts

@@ -15,17 +15,15 @@
  */
 
 import {
+  catchError,
+  mergeMap,
   Observable,
   of as observableOf,
+  take,
+  tap,
   timer,
   race as observableRace,
 } from "rxjs";
-import {
-  catchError,
-  mergeMap,
-  take,
-  tap,
-} from "rxjs/operators";
 import {
   closeSession,
   ICustomMediaKeySession,
@@ -62,7 +60,9 @@ export default function safelyCloseMediaKeySession(
   function recursivelyTryToCloseMediaKeySession(
     retryNb : number
   ) : Observable<unknown> {
-    log.debug("EME: Trying to close a MediaKeySession", mediaKeySession, retryNb);
+    log.debug("EME: Trying to close a MediaKeySession",
+              mediaKeySession.sessionId,
+              retryNb);
     return closeSession(mediaKeySession).pipe(
       tap(() => { log.debug("EME: Succeeded to close MediaKeySession"); }),
       catchError((err : unknown) => {

package/src/core/eme/utils/is_session_usable.ts

@@ -41,7 +41,7 @@ export default function isSessionUsable(
 
   if (keyStatuses.length <= 0) {
     log.debug("EME: isSessionUsable: MediaKeySession given has an empty keyStatuses",
-              loadedSession);
+              loadedSession.sessionId);
     return false;
   }
 

package/src/core/eme/utils/loaded_sessions_store.ts

@@ -18,11 +18,11 @@ import {
   concat as observableConcat,
   defer as observableDefer,
   EMPTY,
+  ignoreElements,
   merge as observableMerge,
   Observable,
   of as observableOf,
 } from "rxjs";
-import { ignoreElements } from "rxjs/operators";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
@@ -167,7 +167,7 @@ export default class LoadedSessionsStore {
         });
     }
 
-    log.debug("EME-LSS: Add MediaKeySession", entry);
+    log.debug("EME-LSS: Add MediaKeySession", entry.sessionType);
     this._storage.store(initializationData, entry);
     return mediaKeySession;
   }

package/src/core/eme/utils/persistent_sessions_store.ts

@@ -183,7 +183,7 @@ export default class PersistentSessionsStore {
       this.delete(initData);
     }
 
-    log.info("EME-PSS: Add new session", sessionId, session);
+    log.info("EME-PSS: Add new session", sessionId);
 
     this._entries.push({ version: 3,
                          sessionId,
@@ -205,7 +205,7 @@ export default class PersistentSessionsStore {
       return;
     }
     const entry = this._entries[index];
-    log.warn("EME-PSS: Delete session from store", entry);
+    log.warn("EME-PSS: Delete session from store", entry.sessionId);
     this._entries.splice(index, 1);
     this._save();
   }

package/src/core/fetchers/index.ts

@@ -26,7 +26,7 @@ import SegmentFetcherCreator, {
   ISegmentFetcherChunkEvent,
   ISegmentFetcherCreatorBackoffOptions,
   ISegmentFetcherEvent,
-  ISegmentFetcherWarning,
+  ISegmentFetcherRetry,
 } from "./segment";
 
 export {
@@ -46,5 +46,5 @@ export {
 
   ISegmentFetcherChunkEvent,
   ISegmentFetcherChunkCompleteEvent,
-  ISegmentFetcherWarning,
+  ISegmentFetcherRetry,
 };

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -266,7 +266,7 @@ export default class ManifestFetcher {
                  IManifestFetcherParsedResult> {
     return this._parseLoadedManifest({ responseData: manifest,
                                        size: undefined,
-                                       duration: undefined },
+                                       requestDuration: undefined },
                                      parserOptions);
 
   }

package/src/core/fetchers/segment/__tests__/prioritizer.test.ts

@@ -16,21 +16,20 @@
 
 import {
   defer,
+  mapTo,
   merge,
   NEVER,
   of,
+  startWith,
   timer,
 } from "rxjs";
-import {
-  mapTo,
-  startWith,
-} from "rxjs/operators";
 import Prioritizer, {
   ITaskEvent,
 } from "../prioritizer";
 
 /* eslint-disable @typescript-eslint/no-floating-promises */
 /* eslint-disable @typescript-eslint/strict-boolean-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable no-restricted-properties */
 
 function assert(condition: boolean, msg?: string): asserts condition {

package/src/core/fetchers/segment/index.ts

@@ -22,7 +22,7 @@ import {
   ISegmentFetcherChunkCompleteEvent,
   ISegmentFetcherChunkEvent,
   ISegmentFetcherEvent,
-  ISegmentFetcherWarning,
+  ISegmentFetcherRetry,
 } from "./segment_fetcher";
 import SegmentFetcherCreator, {
   ISegmentFetcherCreatorBackoffOptions,
@@ -35,6 +35,6 @@ export {
   ISegmentFetcherChunkCompleteEvent,
   ISegmentFetcherChunkEvent,
   ISegmentFetcherEvent,
-  ISegmentFetcherWarning,
+  ISegmentFetcherRetry,
   ISegmentFetcherCreatorBackoffOptions,
 };

package/src/core/fetchers/segment/prioritized_segment_fetcher.ts

@@ -14,54 +14,27 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
-import { map } from "rxjs/operators";
+import {
+  map,
+  Observable,
+} from "rxjs";
 import log from "../../../log";
-import ObservablePrioritizer, { ITaskEvent } from "./prioritizer";
+import ObservablePrioritizer, {
+  IEndedTaskEvent,
+  IInterruptedTaskEvent,
+  ITaskEvent,
+} from "./prioritizer";
 import {
   ISegmentFetcher,
-  ISegmentFetcherEvent,
+  ISegmentFetcherChunkCompleteEvent,
+  ISegmentFetcherChunkEvent,
+  ISegmentFetcherRetry,
   ISegmentLoaderContent,
 } from "./segment_fetcher";
 
-/**
- * Event sent when a segment request has been temporarly interrupted due to
- * another request with a high priority.
- * The request for that segment will restart (from scratch) when requests with
- * more priority are finished.
- */
-export interface ISegmentFetcherInterruptedEvent { type : "interrupted" }
-
-/**
- * Event sent when a segment request just ended.
- * You can use this event to schedule another task you wanted to perform at best
- * immediately after that one (its priority will be checked).
- */
-export interface IEndedTaskEvent { type : "ended" }
-
-/** Event sent by a `IPrioritizedSegmentFetcher`. */
-export type IPrioritizedSegmentFetcherEvent<TSegmentDataType> =
-  ISegmentFetcherEvent<TSegmentDataType> |
-  ISegmentFetcherInterruptedEvent |
-  IEndedTaskEvent;
-
-/** Oject returned by `applyPrioritizerToSegmentFetcher`. */
-export interface IPrioritizedSegmentFetcher<TSegmentDataType> {
-  /** Create a new request for a segment with a given priority. */
-  createRequest : (content : ISegmentLoaderContent,
-                   priority? : number) =>
-    Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>;
-
-  /** Update priority of a request created through `createRequest`. */
-  updatePriority : (
-    observable : Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
-    priority : number
-  ) => void;
-}
-
 /**
  * This function basically put in relation:
- *   - a SegmentFetcher, which will be used to perform the segment request
+ *   - an `ISegmentFetcher`, which will be used to perform the segment requests
  *   - a prioritizer, which will handle the priority of a segment request
  *
  * and returns functions to fetch segments with a given priority.
@@ -73,15 +46,12 @@ export default function applyPrioritizerToSegmentFetcher<TSegmentDataType>(
   prioritizer : ObservablePrioritizer<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
   fetcher : ISegmentFetcher<TSegmentDataType>
 ) : IPrioritizedSegmentFetcher<TSegmentDataType> {
-  /**
-   * The Observables returned by `createRequest` are not exactly the same than
-   * the one created by the `ObservablePrioritizer`. Because we still have to
-   * keep a handle on that value.
-   */
+  /** Map returned task to the task as returned by the `ObservablePrioritizer`. */
   const taskHandlers = new WeakMap<
     Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
     Observable<ITaskEvent<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>>
   >();
+
   return {
     /**
      * Create a Segment request with a given priority.
@@ -124,3 +94,25 @@ export default function applyPrioritizerToSegmentFetcher<TSegmentDataType>(
     },
   };
 }
+
+/** Oject returned by `applyPrioritizerToSegmentFetcher`. */
+export interface IPrioritizedSegmentFetcher<TSegmentDataType> {
+  /** Create a new request for a segment with a given priority. */
+  createRequest : (content : ISegmentLoaderContent,
+                   priority? : number) =>
+    Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>;
+
+  /** Update priority of a request created through `createRequest`. */
+  updatePriority : (
+    observable : Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
+    priority : number
+  ) => void;
+}
+
+/** Event sent by a `IPrioritizedSegmentFetcher`. */
+export type IPrioritizedSegmentFetcherEvent<TSegmentDataType> =
+  ISegmentFetcherChunkEvent<TSegmentDataType> |
+  ISegmentFetcherChunkCompleteEvent |
+  ISegmentFetcherRetry |
+  IInterruptedTaskEvent |
+  IEndedTaskEvent;

package/src/core/fetchers/segment/prioritizer.ts

@@ -22,88 +22,6 @@ import {
 import log from "../../../log";
 import arrayFindIndex from "../../../utils/array_find_index";
 
-/**
- * Event sent when the corresponding task is a low-priority task that has just
- * been temporarly interrupted due to another task with a high priority.
- * The task will restart (from scratch) when tasks with more priority are
- * finished.
- */
-export interface IInterruptedTaskEvent { type : "interrupted" }
-
-/** Event sent when the corresponding task emit an event. */
-export interface ITaskDataEvent<T> { type : "data";
-                                     value : T; }
-
-/**
- * Event sent when the corresponding task has ended (it will then complete).
- * You can use this event to schedule another task you wanted to perform after
- * that one.
- */
-export interface IEndedTaskEvent { type : "ended" }
-
-/** Events sent when a task has been created through the `create` method. */
-export type ITaskEvent<T> = IInterruptedTaskEvent |
-                            ITaskDataEvent<T> |
-                            IEndedTaskEvent;
-
-/** Stored object representing a single task. */
-interface IPrioritizerTask<T> {
-  /**
-   * Observable created by the ObservablePrioritizer allowing to identify
-   * the task.
-   * This is another Observable wrapping the underlying Observable that the
-   * ObservablePrioritizer is asked to run.
-   */
-  observable : Observable<ITaskEvent<T>>;
-  /**
-   * Function used to start and interrupt a task:
-   *   - when `true` is emitted the task should be started. If it was already
-   *     started, it will be interrupted first.
-   *   - when `false` is emitted, the task should just be interrupted if running
-   */
-  trigger : (shouldRun : boolean) => void;
-  /**
-   * Subscription of the underlying, wrapped, Observable.
-   * Only defined when the task has been started, `null` otherwise.
-   */
-  subscription : Subscription | null;
-  /** Priority of the task. Lower that number is, higher is the priority. */
-  priority : number;
-  /** `true` if the underlying wrapped Observable either errored of completed. */
-  finished : boolean;
-}
-
-/** Options to give to the ObservablePrioritizer. */
-export interface IPrioritizerOptions {
-  /** @see IPrioritizerPrioritySteps */
-  prioritySteps : IPrioritizerPrioritySteps;
-}
-
-/**
- * Define both the `low` and `high` priority steps:
- *
- *   - Any Observable with a priority number that is lower or equal to the
- *     `high` value will be an Observable with high priority.
- *
- *     When Observables with high priorities are scheduled, they immediately
- *     abort pending Observables with low priorities (which will have then to
- *     wait until all higher-priority Observable have ended before re-starting).
- *
- *   - Any Observable with a priority number that is higher or equal to the
- *     `low` value will be an Observable with low priority.
- *
- *     Pending Observables with low priorities have the added particularity*
- *     of being aborted as soon as a high priority Observable is scheduled.
- *
- *     * Other pending Observables are not aborted when a higher-priority
- *     Observable is scheduled, as their priorities only affect them before
- *     they are started (to know when to start them).
- */
-export interface IPrioritizerPrioritySteps {
-  low : number;
-  high : number;
-}
-
 /**
  * Create Observables which can be priorized between one another.
  *
@@ -556,3 +474,85 @@ export default class ObservablePrioritizer<T> {
            this._minPendingPriority <= this._prioritySteps.high;
   }
 }
+
+/**
+ * Event sent when the corresponding task is a low-priority task that has just
+ * been temporarly interrupted due to another task with a high priority.
+ * The task will restart (from scratch) when tasks with more priority are
+ * finished.
+ */
+export interface IInterruptedTaskEvent { type : "interrupted" }
+
+/** Event sent when the corresponding task emit an event. */
+export interface ITaskDataEvent<T> { type : "data";
+                                     value : T; }
+
+/**
+ * Event sent when the corresponding task has ended (it will then complete).
+ * You can use this event to schedule another task you wanted to perform after
+ * that one.
+ */
+export interface IEndedTaskEvent { type : "ended" }
+
+/** Events sent when a task has been created through the `create` method. */
+export type ITaskEvent<T> = IInterruptedTaskEvent |
+                            ITaskDataEvent<T> |
+                            IEndedTaskEvent;
+
+/** Stored object representing a single task. */
+interface IPrioritizerTask<T> {
+  /**
+   * Observable created by the ObservablePrioritizer allowing to identify
+   * the task.
+   * This is another Observable wrapping the underlying Observable that the
+   * ObservablePrioritizer is asked to run.
+   */
+  observable : Observable<ITaskEvent<T>>;
+  /**
+   * Function used to start and interrupt a task:
+   *   - when `true` is emitted the task should be started. If it was already
+   *     started, it will be interrupted first.
+   *   - when `false` is emitted, the task should just be interrupted if running
+   */
+  trigger : (shouldRun : boolean) => void;
+  /**
+   * Subscription of the underlying, wrapped, Observable.
+   * Only defined when the task has been started, `null` otherwise.
+   */
+  subscription : Subscription | null;
+  /** Priority of the task. Lower that number is, higher is the priority. */
+  priority : number;
+  /** `true` if the underlying wrapped Observable either errored of completed. */
+  finished : boolean;
+}
+
+/** Options to give to the ObservablePrioritizer. */
+export interface IPrioritizerOptions {
+  /** @see IPrioritizerPrioritySteps */
+  prioritySteps : IPrioritizerPrioritySteps;
+}
+
+/**
+ * Define both the `low` and `high` priority steps:
+ *
+ *   - Any Observable with a priority number that is lower or equal to the
+ *     `high` value will be an Observable with high priority.
+ *
+ *     When Observables with high priorities are scheduled, they immediately
+ *     abort pending Observables with low priorities (which will have then to
+ *     wait until all higher-priority Observable have ended before re-starting).
+ *
+ *   - Any Observable with a priority number that is higher or equal to the
+ *     `low` value will be an Observable with low priority.
+ *
+ *     Pending Observables with low priorities have the added particularity*
+ *     of being aborted as soon as a high priority Observable is scheduled.
+ *
+ *     * Other pending Observables are not aborted when a higher-priority
+ *     Observable is scheduled, as their priorities only affect them before
+ *     they are started (to know when to start them).
+ */
+export interface IPrioritizerPrioritySteps {
+  low : number;
+  high : number;
+}