rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023022200

package/src/core/api/utils.ts

@@ -48,14 +48,14 @@ export function emitSeekEvents(
   onSeeked: () => void,
   cancelSignal : CancellationSignal
 ) : void {
-  if (cancelSignal.isCancelled || mediaElement === null) {
+  if (cancelSignal.isCancelled() || mediaElement === null) {
     return ;
   }
 
   let wasSeeking = playbackObserver.getReference().getValue().seeking;
   if (wasSeeking) {
     onSeeking();
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
   }
@@ -94,7 +94,7 @@ export function constructPlayerStateReference(
   initializer.addEventListener("loaded", () => {
     if (playerStateRef.getValue() === PLAYER_STATES.LOADING) {
       playerStateRef.setValue(PLAYER_STATES.LOADED);
-      if (!cancelSignal.isCancelled) {
+      if (!cancelSignal.isCancelled()) {
         const newState = getLoadedContentState(mediaElement, null);
         if (newState !== PLAYER_STATES.PAUSED) {
           playerStateRef.setValue(newState);

package/src/core/decrypt/attach_media_keys.ts

@@ -62,7 +62,7 @@ export default async function attachMediaKeys(
 
   // If this task has been cancelled while we were closing previous sessions,
   // stop now (and thus avoid setting the new media keys);
-  if (cancelSignal.isCancelled) {
+  if (cancelSignal.isCancelled()) {
     throw cancelSignal.cancellationError;
   }
 

package/src/core/decrypt/content_decryptor.ts

@@ -727,7 +727,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * formatted and sent in an "error" event.
    */
   private _onFatalError(err : unknown) : void {
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     const formattedErr = err instanceof Error ?

package/src/core/decrypt/session_events_listener.ts

@@ -58,13 +58,14 @@ export default function SessionEventsListener(
   const { getLicenseConfig = {} } = keySystemOptions;
 
   /** Allows to manually cancel everything the `SessionEventsListener` is doing. */
-  const manualCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const manualCanceller = new TaskCanceller();
+  manualCanceller.linkToSignal(cancelSignal);
 
   if (!isNullOrUndefined(session.closed)) {
     session.closed
       .then(() => manualCanceller.cancel())
       .catch((err) => { // Should never happen
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return;
         }
         manualCanceller.cancel();
@@ -79,8 +80,8 @@ export default function SessionEventsListener(
 
   onKeyStatusesChange(session, (keyStatusesEvent) => {
     handleKeyStatusesChangeEvent(keyStatusesEvent as Event).catch(error => {
-      if (cancelSignal.isCancelled ||
-          (manualCanceller.isUsed && error instanceof CancellationSignal))
+      if (cancelSignal.isCancelled() ||
+          (manualCanceller.isUsed() && error instanceof CancellationSignal))
       {
         return;
       }
@@ -104,7 +105,7 @@ export default function SessionEventsListener(
                             backoffOptions,
                             manualCanceller.signal)
       .then((licenseObject) => {
-        if (manualCanceller.isUsed) {
+        if (manualCanceller.isUsed()) {
           return Promise.resolve();
         }
         if (isNullOrUndefined(licenseObject)) {
@@ -114,7 +115,7 @@ export default function SessionEventsListener(
         }
       })
       .catch((err : unknown) => {
-        if (manualCanceller.isUsed) {
+        if (manualCanceller.isUsed()) {
           return;
         }
         manualCanceller.cancel();
@@ -133,6 +134,8 @@ export default function SessionEventsListener(
       });
   }, manualCanceller.signal);
 
+  checkAndHandleCurrentKeyStatuses();
+  return;
   /**
    * @param {Event} keyStatusesEvent
    * @returns {Promise}
@@ -144,22 +147,22 @@ export default function SessionEventsListener(
 
     await Promise.all([
       runOnKeyStatusesChangeCallback(),
-      Promise.resolve(handleKeyStatusEvent()),
+      Promise.resolve(checkAndHandleCurrentKeyStatuses()),
     ]);
 
     async function runOnKeyStatusesChangeCallback() {
-      if (manualCanceller.isUsed) {
+      if (manualCanceller.isUsed()) {
         return;
       }
       if (typeof keySystemOptions.onKeyStatusesChange === "function") {
         let ret;
         try {
           ret = await keySystemOptions.onKeyStatusesChange(keyStatusesEvent, session);
-          if (manualCanceller.isUsed) {
+          if (manualCanceller.isUsed()) {
             return;
           }
         } catch (error) {
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return;
           }
           const err = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR",
@@ -178,41 +181,41 @@ export default function SessionEventsListener(
         }
       }
     }
+  }
 
-    /**
-     * Check current MediaKeyStatus for each key in the given MediaKeySession and:
-     *   - throw if at least one status is a non-recoverable error
-     *   - call warning callback for recoverable errors
-     *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
-     */
-    function handleKeyStatusEvent() : void {
-      if (manualCanceller.isUsed || session.keyStatuses.size === 0) {
-        return ;
-      }
-      const { warning, blacklistedKeyIds, whitelistedKeyIds } =
-        checkKeyStatuses(session, keySystemOptions, keySystem);
-      if (warning !== undefined) {
-        callbacks.onWarning(warning);
-        if (manualCanceller.isUsed) {
-          return;
-        }
+  /**
+   * Check current MediaKeyStatus for each key in the given MediaKeySession and:
+   *   - throw if at least one status is a non-recoverable error
+   *   - call warning callback for recoverable errors
+   *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
+   */
+  function checkAndHandleCurrentKeyStatuses() : void {
+    if (manualCanceller.isUsed() || session.keyStatuses.size === 0) {
+      return ;
+    }
+    const { warning, blacklistedKeyIds, whitelistedKeyIds } =
+      checkKeyStatuses(session, keySystemOptions, keySystem);
+    if (warning !== undefined) {
+      callbacks.onWarning(warning);
+      if (manualCanceller.isUsed()) {
+        return;
       }
-      callbacks.onKeyUpdate({ whitelistedKeyIds, blacklistedKeyIds });
     }
+    callbacks.onKeyUpdate({ whitelistedKeyIds, blacklistedKeyIds });
   }
 
   function runGetLicense(
     message : Uint8Array,
     messageType : MediaKeyMessageType
   ) : Promise<BufferSource | null> {
-    return new Promise((res, rej) => {
+    let timeoutId : number | undefined;
+    return new Promise<BufferSource | null>((res, rej) => {
       log.debug("DRM: Calling `getLicense`", messageType);
       const getLicense = keySystemOptions.getLicense(message, messageType);
       const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
         10 * 1000 :
         getLicenseConfig.timeout;
 
-      let timeoutId : number | undefined;
       if (getLicenseTimeout >= 0) {
         timeoutId = setTimeout(() => {
           rej(new GetLicenseTimeoutError(
@@ -220,25 +223,10 @@ export default function SessionEventsListener(
           ));
         }, getLicenseTimeout) as unknown as number;
       }
-
-      try {
-        Promise.resolve(getLicense).then(
-          (val) => {
-            clearTimeoutIfOne();
-            res(val);
-          },
-          (err) => {
-            clearTimeoutIfOne();
-            rej(err);
-          });
-      } catch (err) {
-        clearTimeoutIfOne();
-        rej(err);
-      }
-      function clearTimeoutIfOne() {
-        if (timeoutId !== undefined) {
-          clearTimeout(timeoutId);
-        }
+      Promise.resolve(getLicense).then(res, rej);
+    }).finally(() => {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
       }
     });
   }

package/src/core/decrypt/utils/check_key_statuses.ts

@@ -18,6 +18,7 @@ import { ICustomMediaKeySession } from "../../../compat";
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
 import {
   IEncryptedMediaErrorKeyStatusObject,
   IKeySystemOption,
@@ -109,6 +110,11 @@ export default function checkKeyStatuses(
                                              new Uint8Array(keyStatusKeyId));
 
     const keyStatusObj = { keyId: keyId.buffer, keyStatus };
+
+    if (log.hasLevel("DEBUG")) {
+      log.debug(`DRM: key status update (${bytesToHex(keyId)}): ${keyStatus}`);
+    }
+
     switch (keyStatus) {
       case KEY_STATUSES.EXPIRED: {
         const error = new EncryptedMediaError(

package/src/core/fetchers/cdn_prioritizer.ts

@@ -16,19 +16,22 @@
 
 import config from "../../config";
 import { ICdnMetadata } from "../../parsers/manifest";
-import { IPlayerError } from "../../public_types";
 import arrayFindIndex from "../../utils/array_find_index";
 import EventEmitter from "../../utils/event_emitter";
 import { CancellationSignal } from "../../utils/task_canceller";
 
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */
@@ -41,7 +44,7 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
   private _downgradedCdnList : {
     /**
      * Metadata of downgraded CDN, sorted by the time at which they have
-     * been downgraded.
+     * been downgraded ascending.
      */
     metadata : ICdnMetadata[];
     /**
@@ -174,8 +177,14 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
   }
 }
 
+/** Events sent by a `CdnPrioritizer` */
 export interface ICdnPrioritizerEvents {
-  warnings : IPlayerError[];
+  /**
+   * The priority of one or several CDN changed.
+   *
+   * You might want to re-check if a CDN should still be used when this event
+   * is triggered.
+   */
   priorityChange : null;
 }
 

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

@@ -155,7 +155,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     manifestProm
       .then((val : IManifestFetcherParsedResult) => {
         this.trigger("manifestReady", val.manifest);
-        if (!this._canceller.isUsed) {
+        if (!this._canceller.isUsed()) {
           this._recursivelyRefreshManifest(val.manifest, val);
         }
       })
@@ -362,7 +362,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
      */
     function onWarnings(warnings : Error[]) : void {
       for (const warning of warnings) {
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return;
         }
         const formattedError = formatError(warning, {
@@ -470,7 +470,8 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
      * be effectively considered.
      * `nextRefreshCanceller` will allow to cancel every other when one is triggered.
      */
-    const nextRefreshCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+    const nextRefreshCanceller = new TaskCanceller();
+    nextRefreshCanceller.linkToSignal(this._canceller.signal);
 
     /* Function to manually schedule a Manifest refresh */
     this.scheduleManualRefresh = (settings : IManifestRefreshSettings) => {
@@ -669,7 +670,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
   }
 
   private _onFatalError(err : unknown) : void {
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     this.trigger("error", err);

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

@@ -64,10 +64,22 @@ const generateRequestID = idGenerator();
  * An `ISegmentFetcher` also implements a retry mechanism, based on the given
  * `options` argument, which may retry a segment request when it fails.
  *
- * @param {string} bufferType
- * @param {Object} pipeline
- * @param {Object} lifecycleCallbacks
- * @param {Object} options
+ * @param {string} bufferType - Type of  buffer concerned (e.g. `"audio"`,
+ * `"video"`, `"text" etc.)
+ * @param {Object} pipeline - The transport-specific logic allowing to load
+ * segments of the given buffer type and transport protocol (e.g. DASH).
+ * @param {Object|null} cdnPrioritizer - Abstraction allowing to synchronize,
+ * update and keep track of the priorization of the CDN to use to load any given
+ * segment, in cases where multiple ones are available.
+ *
+ * Can be set to `null` in which case a minimal priorization logic will be used
+ * instead.
+ * @param {Object} lifecycleCallbacks - Callbacks that can be registered to be
+ * informed when new requests are made, ended, new metrics are available etc.
+ * This should be mainly useful to implement an adaptive logic relying on those
+ * metrics and events.
+ * @param {Object} options - Various tweaking options allowing to configure the
+ * behavior of the returned `ISegmentFetcher`.
  * @returns {Function}
  */
 export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
@@ -184,14 +196,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
                                           id: requestId,
                                           content });
 
-    cancellationSignal.register(() => {
-      if (requestInfo !== undefined) {
-        return; // Request already terminated
-      }
-      log.debug("SF: Segment request cancelled", segmentIdString);
-      requestInfo = null;
-      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
-    });
+    cancellationSignal.register(onCancellation);
 
     try {
       const res = await scheduleRequestWithCdns(content.representation.cdnMetadata,
@@ -220,22 +225,34 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
         requestInfo = null;
       }
 
-      if (!cancellationSignal.isCancelled) {
+      if (!cancellationSignal.isCancelled()) {
         // The current task could have been canceled as a result of one
         // of the previous callbacks call. In that case, we don't want to send
         // a "requestEnd" again as it has already been sent on cancellation.
         lifecycleCallbacks.onRequestEnd?.({ id: requestId });
       }
+      cancellationSignal.deregister(onCancellation);
     } catch (err) {
+      cancellationSignal.deregister(onCancellation);
       requestInfo = null;
       if (err instanceof CancellationError) {
         log.debug("SF: Segment request aborted", segmentIdString);
         throw err;
       }
       log.debug("SF: Segment request failed", segmentIdString);
+      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
       throw errorSelector(err);
     }
 
+    function onCancellation() {
+      if (requestInfo !== undefined) {
+        return; // Request already terminated
+      }
+      log.debug("SF: Segment request cancelled", segmentIdString);
+      requestInfo = null;
+      lifecycleCallbacks.onRequestEnd?.({ id: requestId });
+    }
+
     /**
      * Call a segment loader for the given URL with the right arguments.
      * @param {Object|null} cdnMetadata
@@ -360,11 +377,16 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
   /**
    * Callback called when all decodable chunks of the loaded segment have been
    * communicated through the `onChunk` callback.
+   *
+   * This callback is called before the corresponding `ISegmentFetcher`'s
+   * returned Promise is resolved.
    */
   onAllChunksReceived() : void;
 
   /**
-   * Callback called when the segment request has to restart from scratch. */
+   * Callback called when the segment request has to restart from scratch, e.g.
+   * due to a request error.
+   */
   onRetry(error : IPlayerError) : void;
 }
 

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

@@ -1,5 +1,6 @@
 import log from "../../../log";
 import arrayFindIndex from "../../../utils/array_find_index";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import TaskCanceller, {
   CancellationError,
   CancellationSignal,
@@ -64,19 +65,34 @@ export default class TaskPrioritizer<T> {
     cancelSignal: CancellationSignal
   ): Promise<T> {
     let newTask: IPrioritizerTask<T>;
-
-    return new Promise<T>((resolve, reject) => {
+    return createCancellablePromise<T>(cancelSignal, (resolve, reject) => {
       /** Function allowing to start the underlying Promise. */
       const trigger = () => {
         if (newTask.hasEnded) {
-          unregisterCancelSignal();
           return;
         }
-        const interrupter =  new TaskCanceller({ cancelOn: cancelSignal });
+        const finishTask = () => {
+          unlinkInterrupter();
+          this._endTask(newTask);
+        };
+
+        const onResolve = (value: T) => {
+          callbacks.beforeEnded();
+          finishTask();
+          resolve(value);
+        };
+
+        const onReject = (err: unknown) => {
+          finishTask();
+          reject(err);
+        };
+
+        const interrupter =  new TaskCanceller();
+        const unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
         newTask.interrupter = interrupter;
         interrupter.signal.register(() => {
           newTask.interrupter = null;
-          if (!cancelSignal.isCancelled) {
+          if (!cancelSignal.isCancelled()) {
             callbacks.beforeInterrupted();
           }
         });
@@ -89,8 +105,8 @@ export default class TaskPrioritizer<T> {
         newTask.taskFn(interrupter.signal)
           .then(onResolve)
           .catch((err) => {
-            if (!cancelSignal.isCancelled &&
-                interrupter.isUsed &&
+            if (!cancelSignal.isCancelled() &&
+                interrupter.isUsed() &&
                 err instanceof CancellationError)
             {
               return;
@@ -99,29 +115,6 @@ export default class TaskPrioritizer<T> {
           });
       };
 
-      const unregisterCancelSignal = cancelSignal.register(
-        (cancellationError: CancellationError) => {
-          this._endTask(newTask);
-          reject(cancellationError);
-        }
-      );
-
-      const finishTask = () => {
-        unregisterCancelSignal();
-        this._endTask(newTask);
-      };
-
-      const onResolve = (value: T) => {
-        callbacks.beforeEnded();
-        finishTask();
-        resolve(value);
-      };
-
-      const onReject = (err: unknown) => {
-        finishTask();
-        reject(err);
-      };
-
       newTask = {
         hasEnded: false,
         priority,
@@ -146,6 +139,8 @@ export default class TaskPrioritizer<T> {
           this._interruptCancellableTasks();
         }
       }
+
+      return () => this._endTask(newTask);
     });
   }
 

package/src/core/fetchers/utils/schedule_request.ts

@@ -315,7 +315,7 @@ export async function scheduleRequestWithCdns<T>(
   async function retryWithNextCdn(prevRequestError : unknown) : Promise<T> {
     const nextCdn = getCdnToRequest();
 
-    if (cancellationSignal.isCancelled) {
+    if (cancellationSignal.isCancelled()) {
       throw cancellationSignal.cancellationError;
     }
 
@@ -324,7 +324,7 @@ export async function scheduleRequestWithCdns<T>(
     }
 
     onRetry(prevRequestError);
-    if (cancellationSignal.isCancelled) {
+    if (cancellationSignal.isCancelled()) {
       throw cancellationSignal.cancellationError;
     }
 
@@ -358,12 +358,13 @@ export async function scheduleRequestWithCdns<T>(
       return requestCdn(nextWantedCdn);
     }
 
-    const canceller = new TaskCanceller({ cancelOn: cancellationSignal });
+    const canceller = new TaskCanceller();
+    const unlinkCanceller = canceller.linkToSignal(cancellationSignal);
     return new Promise<T>((res, rej) => {
       /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
       cdnPrioritizer?.addEventListener("priorityChange", () => {
         const updatedPrioritaryCdn = getCdnToRequest();
-        if (cancellationSignal.isCancelled) {
+        if (cancellationSignal.isCancelled()) {
           throw cancellationSignal.cancellationError;
         }
         if (updatedPrioritaryCdn === undefined) {
@@ -378,7 +379,7 @@ export async function scheduleRequestWithCdns<T>(
 
       cancellableSleep(blockedFor, canceller.signal)
         .then(() => requestCdn(nextWantedCdn).then(res, rej), noop);
-    });
+    }).finally(unlinkCanceller);
   }
 
   /**

package/src/core/init/directfile_content_initializer.ts

@@ -167,7 +167,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
             }
           }, { emitCurrentValue: true, clearSignal: cancelSignal }))
       .catch((err) => {
-        if (!cancelSignal.isCancelled) {
+        if (!cancelSignal.isCancelled()) {
           this._onFatalError(err);
         }
       });