rx-player 3.26.1 → 3.26.2

package/src/core/init/duration_updater.ts

@@ -15,28 +15,25 @@
  */
 
 import {
+  catchError,
   combineLatest as observableCombineLatest,
   defer as observableDefer,
+  distinctUntilChanged,
   EMPTY,
+  filter,
   fromEvent as observableFromEvent,
+  ignoreElements,
   interval as observableInterval,
+  map,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
-} from "rxjs";
-import {
-  catchError,
-  distinctUntilChanged,
-  filter,
-  ignoreElements,
-  map,
-  mapTo,
-  mergeMap,
   startWith,
   switchMap,
   take,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   onSourceOpen$,
   onSourceClose$,
@@ -83,6 +80,11 @@ export default function DurationUpdater(
           })
         );
       }),
+      // 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-next-line @typescript-eslint/no-unsafe-argument */
       ignoreElements()
     );
   });
@@ -170,9 +172,9 @@ function whenSourceBuffersEndedUpdates$(
     const sourceBuffer = sourceBuffers[i];
     sourceBufferUpdatingStatuses.push(
       observableMerge(
-        observableFromEvent(sourceBuffer, "updatestart").pipe(mapTo(true)),
-        observableFromEvent(sourceBuffer, "update").pipe(mapTo(false)),
-        observableInterval(500).pipe(mapTo(sourceBuffer.updating))
+        observableFromEvent(sourceBuffer, "updatestart").pipe(map(() => true)),
+        observableFromEvent(sourceBuffer, "update").pipe(map(() => false)),
+        observableInterval(500).pipe(map(() => sourceBuffer.updating))
       ).pipe(
         startWith(sourceBuffer.updating),
         distinctUntilChanged()
@@ -183,7 +185,7 @@ function whenSourceBuffersEndedUpdates$(
     filter((areUpdating) => {
       return areUpdating.every((isUpdating) => !isUpdating);
     }),
-    mapTo(undefined)
+    map(() => undefined)
   );
 }
 
@@ -193,11 +195,12 @@ function whenSourceBuffersEndedUpdates$(
  * @returns {Object}
  */
 function isMediaSourceOpened$(mediaSource: MediaSource): Observable<boolean> {
-  return observableMerge(onSourceOpen$(mediaSource).pipe(mapTo(true)),
-                         onSourceEnded$(mediaSource).pipe(mapTo(false)),
-                         onSourceClose$(mediaSource).pipe(mapTo(false))
+  return observableMerge(onSourceOpen$(mediaSource).pipe(map(() => true)),
+                         onSourceEnded$(mediaSource).pipe(map(() => false)),
+                         onSourceClose$(mediaSource).pipe(map(() => false))
   ).pipe(
     startWith(mediaSource.readyState === "open"),
     distinctUntilChanged()
   );
 }
+/* eslint-enable @typescript-eslint/no-unsafe-argument */

package/src/core/init/emit_loaded_event.ts

@@ -17,41 +17,37 @@
 
 import {
   Observable,
-} from "rxjs";
-import {
   take,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   shouldValidateMetadata,
   shouldWaitForDataBeforeLoaded,
 } from "../../compat";
 import filterMap from "../../utils/filter_map";
+import { IPlaybackObservation } from "../api";
 import SegmentBuffersStore from "../segment_buffers";
 import EVENTS from "./events_generators";
-import {
-  IInitClockTick,
-  ILoadedEvent,
-} from "./types";
+import { ILoadedEvent } from "./types";
 
 /**
  * Emit a `ILoadedEvent` once the content can be considered as loaded.
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @param {HTMLMediaElement} mediaElement
  * @param {Object|null} segmentBuffersStore
  * @param {boolean} isDirectfile - `true` if this is a directfile content
  * @returns {Observable}
  */
 export default function emitLoadedEvent(
-  clock$ : Observable<IInitClockTick>,
+  observation$ : Observable<IPlaybackObservation>,
   mediaElement : HTMLMediaElement,
   segmentBuffersStore : SegmentBuffersStore | null,
   isDirectfile : boolean
 ) : Observable<ILoadedEvent> {
-  return clock$.pipe(
-    filterMap<IInitClockTick, ILoadedEvent, null>((tick) => {
-      if (tick.rebuffering !== null ||
-          tick.freezing !== null ||
-          tick.readyState === 0)
+  return observation$.pipe(
+    filterMap<IPlaybackObservation, ILoadedEvent, null>((observation) => {
+      if (observation.rebuffering !== null ||
+          observation.freezing !== null ||
+          observation.readyState === 0)
       {
         return null;
       }
@@ -63,7 +59,7 @@ export default function emitLoadedEvent(
                                            null;
       }
 
-      if (tick.readyState >= 3 && tick.currentRange !== null) {
+      if (observation.readyState >= 3 && observation.currentRange !== null) {
         if (!shouldValidateMetadata() || mediaElement.duration > 0) {
           return EVENTS.loaded(segmentBuffersStore);
         }

package/src/core/init/end_of_stream.ts

@@ -17,17 +17,15 @@
 import {
   defer as observableDefer,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
   race as observableRace,
-} from "rxjs";
-import {
-  mergeMap,
   startWith,
   switchMap,
   take,
   takeLast,
-} from "rxjs/operators";
+} from "rxjs";
 import { events } from "../../compat";
 import log from "../../log";
 

package/src/core/init/get_initial_time.ts

@@ -44,7 +44,6 @@ export default function getInitialTime(
   lowLatencyMode : boolean,
   startAt? : IInitialTimeOptions
 ) : number {
-  log.debug("Init: calculating initial time");
   if (startAt != null) {
     const min = manifest.getMinimumPosition();
     const max = manifest.getMaximumPosition();

package/src/core/init/initial_seek_and_play.ts

@@ -14,21 +14,19 @@
  * limitations under the License.
  */
 
-import {
-  concat as observableConcat,
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import {
   catchError,
+  concat as observableConcat,
   filter,
-  mapTo,
+  map,
   mergeMap,
+  Observable,
+  of as observableOf,
   shareReplay,
   startWith,
   take,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   play,
   shouldValidateMetadata,
@@ -36,11 +34,16 @@ import {
 } from "../../compat";
 import { MediaError } from "../../errors";
 import log from "../../log";
-import EVENTS from "./events_generators";
 import {
-  IInitClockTick,
-  IWarningEvent,
-} from "./types";
+  createSharedReference,
+  IReadOnlySharedReference,
+} from "../../utils/reference";
+import {
+  IPlaybackObservation,
+  PlaybackObserver,
+} from "../api";
+import EVENTS from "./events_generators";
+import { IWarningEvent } from "./types";
 
 /** Event emitted when trying to perform the initial `play`. */
 export type IInitialPlayEvent =
@@ -57,24 +60,24 @@ export type IInitialPlayEvent =
   IWarningEvent;
 
 /**
- * Emit once as soon as the clock$ announce that the content can begin to be
- * played by calling the `play` method.
+ * Emit once as soon as the playback observation announces that the content can
+ * begin to be played by calling the `play` method.
  *
  * This depends on browser-defined criteria (e.g. the readyState status) as well
  * as RxPlayer-defined ones (e.g.) not rebuffering.
  *
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Observable.<undefined>}
  */
 export function waitUntilPlayable(
-  clock$ : Observable<IInitClockTick>
+  observation$ : Observable<IPlaybackObservation>
 ) : Observable<undefined> {
-  return clock$.pipe(
+  return observation$.pipe(
     filter(({ seeking, rebuffering, readyState }) => !seeking &&
                                                      rebuffering === null &&
                                                      readyState >= 1),
     take(1),
-    mapTo(undefined)
+    map(() => undefined)
   );
 }
 
@@ -87,7 +90,7 @@ function autoPlay(
   mediaElement: HTMLMediaElement
 ): Observable<"autoplay"|"autoplay-blocked"> {
   return play(mediaElement).pipe(
-    mapTo("autoplay" as const),
+    map(() => "autoplay" as const),
     catchError((error : unknown) => {
       if (error instanceof Error && error.name === "NotAllowedError") {
         // auto-play was probably prevented.
@@ -101,60 +104,69 @@ function autoPlay(
   );
 }
 
+/** Object returned by `initialSeekAndPlay`. */
+export interface IInitialSeekAndPlayObject {
+  /**
+   * Observable which, when subscribed, will try to seek at the initial position
+   * then play if needed as soon as the HTMLMediaElement's properties are right.
+   *
+   * Emits various events relative to the status of this operation.
+   */
+  seekAndPlay$ : Observable<IInitialPlayEvent>;
+
+  /**
+   * Shared reference whose value becomes `true` once the initial seek has
+   * been considered / has been done by `seekAndPlay$`.
+   */
+  initialSeekPerformed : IReadOnlySharedReference<boolean>;
+
+  /**
+   * Shared reference whose value becomes `true` once the initial play has
+   * been considered / has been done by `seekAndPlay$`.
+   */
+  initialPlayPerformed: IReadOnlySharedReference<boolean>;
+}
+
 /**
- * Returns two Observables:
- *
- *   - seek$: when subscribed, will seek to the wanted started time as soon as
- *     it can. Emit and complete when done.
- *
- *   - play$: when subscribed, will autoplay if and only if the `mustAutoPlay`
- *     option is set as soon as it can.
- *     Emit and complete when done.
- *     Might also emit some warning events if issues related to the initial
- *     playback arised
- *
- * Both Observables are `shareReplay`, meaning that they re-emit everything on
- * subscription.
- *
- * /!\ `play$` has a dependency on `seek$`, as such, the player will try to seek
- * as soon as either Observable is subscribed to.
- *
+ * Creates an Observable allowing to seek at the initially wanted position and
+ * to play if autoPlay is wanted.
  * @param {Object} args
  * @returns {Object}
  */
 export default function initialSeekAndPlay(
-  { clock$,
-    mediaElement,
+  { mediaElement,
+    playbackObserver,
     startTime,
-    mustAutoPlay,
-    setCurrentTime } : { clock$ : Observable<IInitClockTick>;
-                         isDirectfile : boolean;
-                         mediaElement : HTMLMediaElement;
-                         mustAutoPlay : boolean;
-                         /** Perform an internal seek. */
-                         setCurrentTime: (nb: number) => void;
-                         startTime : number|(() => number); }
-) : { seek$ : Observable<unknown>; play$ : Observable<IInitialPlayEvent> } {
+    mustAutoPlay } : { playbackObserver : PlaybackObserver;
+                       mediaElement : HTMLMediaElement;
+                       mustAutoPlay : boolean;
+                       startTime : number|(() => number); }
+) : IInitialSeekAndPlayObject {
+  const initialSeekPerformed = createSharedReference(false);
+  const initialPlayPerformed = createSharedReference(false);
+
   const seek$ = whenLoadedMetadata$(mediaElement).pipe(
     take(1),
     tap(() => {
       log.info("Init: Set initial time", startTime);
       const initialTime = typeof startTime === "function" ? startTime() :
                                                             startTime;
-      setCurrentTime(initialTime);
+      playbackObserver.setCurrentTime(initialTime);
+      initialSeekPerformed.setValue(true);
+      initialSeekPerformed.finish();
     }),
     shareReplay({ refCount: true })
   );
 
-  const play$ = seek$.pipe(
+  const seekAndPlay$ = seek$.pipe(
     mergeMap(() : Observable<IWarningEvent | undefined> => {
       if (!shouldValidateMetadata() || mediaElement.duration > 0) {
-        return waitUntilPlayable(clock$);
+        return waitUntilPlayable(playbackObserver.observe(true));
       } else {
         const error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA",
                                      "Cannot load automatically: your browser " +
                                      "falsely announced having loaded the content.");
-        return waitUntilPlayable(clock$)
+        return waitUntilPlayable(playbackObserver.observe(true))
           .pipe(startWith(EVENTS.warning(error)));
       }
     }),
@@ -169,9 +181,13 @@ export default function initialSeekAndPlay(
           log.warn("Init: autoplay is enabled on HTML media element. " +
                    "Media will play as soon as possible.");
         }
+        initialPlayPerformed.setValue(true);
+        initialPlayPerformed.finish();
         return observableOf({ type: "skipped" as const });
       }
       return autoPlay(mediaElement).pipe(mergeMap((autoplayEvt) => {
+        initialPlayPerformed.setValue(true);
+        initialPlayPerformed.finish();
         if (autoplayEvt === "autoplay") {
           return observableOf({ type: "autoplay" as const });
         } else {
@@ -188,5 +204,5 @@ export default function initialSeekAndPlay(
     shareReplay({ refCount: true })
   );
 
-  return { seek$, play$ };
+  return { seekAndPlay$, initialPlayPerformed, initialSeekPerformed };
 }

package/src/core/init/initialize_directfile.ts

@@ -21,25 +21,24 @@
 
 import {
   EMPTY,
-  merge as observableMerge,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
   filter,
   ignoreElements,
+  merge as observableMerge,
   mergeMap,
-  mergeMapTo,
   switchMap,
+  Observable,
+  of as observableOf,
   share,
   take,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   clearElementSrc,
   setElementSrc$,
 } from "../../compat";
 import log from "../../log";
 import deferSubscriptions from "../../utils/defer_subscriptions";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { PlaybackObserver } from "../api";
 import { IKeySystemOption } from "../eme";
 import createEMEManager from "./create_eme_manager";
 import emitLoadedEvent from "./emit_loaded_event";
@@ -47,10 +46,7 @@ import { IInitialTimeOptions } from "./get_initial_time";
 import initialSeekAndPlay from "./initial_seek_and_play";
 import StallAvoider from "./stall_avoider";
 import throwOnMediaError from "./throw_on_media_error";
-import {
-  IDirectfileEvent,
-  IInitClockTick,
-} from "./types";
+import { IDirectfileEvent } from "./types";
 import updatePlaybackRate from "./update_playback_rate";
 
 /**
@@ -100,11 +96,10 @@ function getDirectFileInitialTime(
 
 // Argument used by `initializeDirectfileContent`
 export interface IDirectFileOptions { autoPlay : boolean;
-                                      clock$ : Observable<IInitClockTick>;
                                       keySystems : IKeySystemOption[];
                                       mediaElement : HTMLMediaElement;
-                                      speed$ : Observable<number>;
-                                      setCurrentTime: (nb: number) => void;
+                                      playbackObserver : PlaybackObserver;
+                                      speed : IReadOnlySharedReference<number>;
                                       startAt? : IInitialTimeOptions;
                                       url? : string; }
 
@@ -115,11 +110,10 @@ export interface IDirectFileOptions { autoPlay : boolean;
  */
 export default function initializeDirectfileContent({
   autoPlay,
-  clock$,
   keySystems,
   mediaElement,
-  speed$,
-  setCurrentTime,
+  playbackObserver,
+  speed,
   startAt,
   url,
 } : IDirectFileOptions) : Observable<IDirectfileEvent> {
@@ -137,12 +131,10 @@ export default function initializeDirectfileContent({
   const initialTime = () => getDirectFileInitialTime(mediaElement, startAt);
   log.debug("Init: Initial time calculated:", initialTime);
 
-  const { seek$, play$ } = initialSeekAndPlay({ clock$,
-                                                mediaElement,
+  const { seekAndPlay$ } = initialSeekAndPlay({ mediaElement,
+                                                playbackObserver,
                                                 startTime: initialTime,
-                                                mustAutoPlay: autoPlay,
-                                                setCurrentTime,
-                                                isDirectfile: true });
+                                                mustAutoPlay: autoPlay });
 
   // Create EME Manager, an observable which will manage every EME-related
   // issue.
@@ -156,22 +148,24 @@ export default function initializeDirectfileContent({
   // through a throwing Observable.
   const mediaError$ = throwOnMediaError(mediaElement);
 
+  const observation$ = playbackObserver.observe(true);
+
   // Set the speed set by the user on the media element while pausing a
   // little longer while the buffer is empty.
   const playbackRate$ =
-    updatePlaybackRate(mediaElement, speed$, clock$)
+    updatePlaybackRate(mediaElement, speed, observation$)
+      // 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-next-line @typescript-eslint/no-unsafe-argument */
       .pipe(ignoreElements());
 
   /**
    * Observable trying to avoid various stalling situations, emitting "stalled"
    * events when it cannot, as well as "unstalled" events when it get out of one.
    */
-  const stallAvoider$ = StallAvoider(clock$,
-                                     mediaElement,
-                                     null,
-                                     EMPTY,
-                                     EMPTY,
-                                     setCurrentTime);
+  const stallAvoider$ = StallAvoider(playbackObserver, null, EMPTY, EMPTY);
 
   /**
    * Emit a "loaded" events once the initial play has been performed and the
@@ -181,24 +175,21 @@ export default function initializeDirectfileContent({
   const loadingEvts$ = emeManager$.pipe(
     filter(function isEMEReady(evt) {
       if (evt.type === "created-media-keys") {
-        evt.value.attachMediaKeys$.next();
+        evt.value.canAttachMediaKeys.setValue(true);
         return true;
       }
       return evt.type === "eme-disabled" || evt.type === "attached-media-keys";
     }),
     take(1),
-    mergeMapTo(play$),
+    mergeMap(() => seekAndPlay$),
     switchMap((evt) => {
       if (evt.type === "warning") {
         return observableOf(evt);
       }
-      return emitLoadedEvent(clock$, mediaElement, null, true);
+      return emitLoadedEvent(observation$, mediaElement, null, true);
     }));
 
-  const initialSeek$ = seek$.pipe(ignoreElements());
-
   return observableMerge(loadingEvts$,
-                         initialSeek$,
                          emeManager$,
                          mediaError$,
                          playbackRate$,