rx-player 4.2.0-dev.2024101500 → 4.2.0

package/src/main_thread/api/public_api.ts

@@ -411,7 +411,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024101500";
+    this.version = /* PLAYER_VERSION */ "4.2.0";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3330,7 +3330,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024101500";
+Player.version = /* PLAYER_VERSION */ "4.2.0";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/decrypt/create_or_load_session.ts

@@ -82,7 +82,12 @@ export default async function createOrLoadSession(
     }
   }
 
-  await cleanOldLoadedSessions(loadedSessionsStore, maxSessionCacheSize);
+  await cleanOldLoadedSessions(
+    loadedSessionsStore,
+    // Account for the next session we will be creating
+    // Note that `maxSessionCacheSize < 0 has special semantic (no limit)`
+    maxSessionCacheSize <= 0 ? maxSessionCacheSize : maxSessionCacheSize - 1,
+  );
   if (cancelSignal.cancellationError !== null) {
     throw cancelSignal.cancellationError; // stop here if cancelled since
   }

package/src/main_thread/decrypt/get_media_keys.ts

@@ -98,6 +98,7 @@ export default async function getMediaKeysInfos(
   const persistentSessionsStore = createPersistentSessionsStorage(options);
 
   if (
+    evt.value.options.reuseMediaKeys !== false &&
     canReuseMediaKeys() &&
     currentState !== null &&
     evt.type === "reuse-media-key-system-access"

package/src/main_thread/init/utils/initial_seek_and_play.ts

@@ -121,13 +121,9 @@ export default function performInitialSeekAndPlay(
               obs.readyState < HTMLMediaElement.HAVE_CURRENT_DATA
             ) {
               /**
-               * On browser, such as Safari, the HTMLMediaElement.duration
-               * and HTMLMediaElement.buffered may not be initialized at readyState 1, leading
-               * to cases where it can be equal to `Infinity`.
-               * If so, the range in which it is possible to seek is not yet known.
-               * To solve this, the seek should be done after readyState HAVE_CURRENT_DATA (2),
-               * at that time the previously mentioned attributes are correctly initialized and
-               * the range in which it is possible to seek is correctly known.
+               * The starting position may not be known yet.
+               * Postpone the seek to a moment where the starting position should be known,
+               * assumely it's when readyState is greater or equal to HAVE_CURRENT_DATA (2).
                * If the initiallySeekedTime is still `undefined` when the readyState is >= 2,
                * let assume that the initiallySeekedTime will never be known and continue
                * the logic without seeking.

package/src/public_types.ts

@@ -559,11 +559,62 @@ export interface IKeySystemOption {
    */
   distinctiveIdentifier?: MediaKeysRequirement | undefined;
   /**
-   * If true, all open MediaKeySession (used to decrypt the content) will be
-   * closed when the current playback stops.
+   * If true, all open `MediaKeySession` (JavaScript Objects linked to the keys
+   * used to decrypt the content) will be closed when the current playback
+   * stops.
+   *
+   * By default, we keep `MediaKeySession` from previous contents (up to
+   * `maxSessionCacheSize` `MediaKeySession`) to speed-up playback and avoid
+   * round-trips to the license server if the user ever decide to go back to
+   * those contents or to other contents relying to the same keys.
+   *
+   * However we found that some devices poorly handle that optimization.
+   *
+   * Note that if setting that property to `true` fixes your issue, it may be
+   * that it's just the `maxSessionCacheSize` which is for now too high.
+   *
+   * However if your problem doesn't disappear after setting
+   * `closeSessionsOnStop` to `true`, you may try `reuseMediaKeys` next.
    */
   closeSessionsOnStop?: boolean;
-
+  /**
+   * If set to `true` or if not set, we might rely on the previous `MediaKeys`
+   * if a compatible one is already set on the media element, allowing to
+   * potentially speed-up content playback.
+   *
+   * If set to `false`, we will create a new `MediaKeys` instance (a
+   * JavaScript object needed to decrypt contents) if needed for that content.
+   *
+   * We noticed that reusing a previous MediaKeys had led to errors on a few
+   * devices. For example some smart TVs had shown errors after playing several
+   * encrypted contents, errors which disappeared if we renewed the
+   * `MediaKeys` for each content.
+   *
+   * We should already be able to detect most of those cases in the RxPlayer
+   * logic. However, it is still possible that we don't know yet of a device
+   * which also has problem with that optimization.
+   *
+   * If you have issues appearing only after playing multiple encrypted
+   * contents:
+   *
+   *   - First, try setting the `closeSessionsOnStop` option which is less
+   *     destructive.
+   *
+   *     If it fixes your issue, it may be that it's just the number of
+   *     `MediaKeySession` cached by the RxPlayer that is here too high.
+   *
+   *     In that case you can instead update the `maxSessionCacheSize` option
+   *     to still profit from a `MediaKeySession` cache (which avoid making
+   *     license requests for already-played contents).
+   *
+   *     If that second option doesn't seem to have an effect, you can just set
+   *     `closeSessionsOnStop`.
+   *
+   *   - If none of the precedent work-arounds work however, you can try setting
+   *     `reuseMediaKeys` to `false`. If it fixes your problem, please open an
+   *     RxPlayer issue so we can add your device to our list.
+   */
+  reuseMediaKeys?: boolean | undefined;
   singleLicensePer?: "content" | "periods" | "init-data";
   /**
    * Maximum number of `MediaKeySession` that should be created on the same