rx-player 3.31.0-dev.2023052200 → 3.31.0

package/CHANGELOG.md

@@ -1,9 +1,11 @@
 # Changelog
 
-## v3.31.0-dev.2023052200 (2023-05-22)
+## v3.31.0 (2023-06-14)
 
 ### Features
 
+  - Add `isContentLoaded`, `isBuffering`, `isPaused`, and `getLastStoredContentPosition` methods [#1248]
+  - Add `play` and `paused` events [#1253]
   - Add `trackInfo` property to some `MediaError` to expose information on the track that caused the error [#1241]
 
 ### Bug fixes
@@ -12,13 +14,11 @@
   - Return actual ending duration through the `getVideoDuration` method when playing dynamic contents whose future end is already known [#1235]
   - DASH/WASM: actually reject the `DASH_WASM.initialize`'s Promise if it fails [#1238]
   - On the PlayStation 5, set `Infinity` MediaSource duration for live contents to prevent playback issues [#1250]
-  - DASH/WASM: actually reject the DASH_WASM.initialize's Promise if it fails [#1238]
 
 ### Other improvements
 
   - adaptive: Perform various adaptive tweaks to avoid switching too much between qualities in some conditions [#1237]
   - Directfile: Detect "forced" subtitles on Safari when playing directfile contents (such as HLS) [#1239]
-  - DRM: Reload when playback is unexpectedly frozen with encrypted but only decipherable data in the buffer [#1236]
   - Improve `"direct"` `audioTrackSwitchingMode` compatibility by re-seeking [#1246]
   - The `DEBUG_ELEMENT` feature now uses the `monospace` fallback font as a default for a better rendering on apple devices
   - doc: externalize documentation-generator code

package/VERSION

@@ -1 +1 @@
-3.31.0-dev.2023052200
+3.31.0

package/dist/_esm5.processed/core/api/public_api.d.ts

@@ -105,6 +105,10 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * It should refer to the last content being played.
      */
     private _priv_reloadingMetadata;
+    /**
+     * Store last value of autoPlay, from the last load or reload.
+     */
+    private _priv_lastAutoPlay;
     /** All possible Error types emitted by the RxPlayer. */
     static get ErrorTypes(): Record<IErrorType, IErrorType>;
     /** All possible Error codes emitted by the RxPlayer. */
@@ -217,6 +221,26 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {string} - The current Player's state
      */
     getPlayerState(): string;
+    /**
+     * Returns true if a content is loaded.
+     * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
+     */
+    isContentLoaded(): boolean;
+    /**
+     * Returns true if the player is buffering.
+     * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
+     */
+    isBuffering(): boolean;
+    /**
+     * Returns the play/pause status of the player :
+     *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
+     *     for when loading is over,
+     *   - in other states, returns the `<video>` element .paused value,
+     *   - if the player is disposed, returns `true`.
+     * @returns {Boolean} - `true` if the player is paused or will be after loading,
+     * `false` otherwise.
+     */
+    isPaused(): boolean;
     /**
      * Returns true if both:
      *   - a content is loaded
@@ -303,6 +327,12 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {Number}
      */
     getPosition(): number;
+    /**
+     * Returns the last stored content position, in seconds.
+     *
+     * @returns {number|undefined}
+     */
+    getLastStoredContentPosition(): number | undefined;
     /**
      * Returns the current playback rate at which the video plays.
      * @returns {Number}
@@ -832,6 +862,8 @@ interface IPublicAPIEvent {
     availableTextTracksChange: IAvailableTextTrack[];
     availableVideoTracksChange: IAvailableVideoTrack[];
     decipherabilityUpdate: IDecipherabilityUpdateContent[];
+    play: null;
+    pause: null;
     seeking: null;
     seeked: null;
     streamEvent: IStreamEvent;

package/dist/_esm5.processed/core/api/public_api.js

@@ -51,6 +51,7 @@ import { ErrorCodes, ErrorTypes, formatError, MediaError, } from "../../errors";
 import features from "../../features";
 import log from "../../log";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
+import arrayIncludes from "../../utils/array_includes";
 import assert from "../../utils/assert";
 import EventEmitter from "../../utils/event_emitter";
 import idGenerator from "../../utils/id_generator";
@@ -65,7 +66,7 @@ import MediaSourceContentInitializer from "../init/media_source_content_initiali
 import { checkReloadOptions, parseConstructorOptions, parseLoadVideoOptions, } from "./option_utils";
 import PlaybackObserver from "./playback_observer";
 import TrackChoiceManager from "./tracks_management/track_choice_manager";
-import { constructPlayerStateReference, emitSeekEvents, isLoadedState, } from "./utils";
+import { constructPlayerStateReference, emitPlayPauseEvents, emitSeekEvents, isLoadedState, } from "./utils";
 /* eslint-disable @typescript-eslint/naming-convention */
 var generateContentId = idGenerator();
 var getPageActivityRef = events.getPageActivityRef, getPictureOnPictureStateRef = events.getPictureOnPictureStateRef, getVideoVisibilityRef = events.getVideoVisibilityRef, getVideoWidthRef = events.getVideoWidthRef, onFullscreenChange = events.onFullscreenChange, onTextTrackAdded = events.onTextTrackAdded, onTextTrackRemoved = events.onTextTrackRemoved;
@@ -89,7 +90,7 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "3.31.0-dev.2023052200";
+        _this.version = /* PLAYER_VERSION */ "3.31.0";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -172,6 +173,7 @@ var Player = /** @class */ (function (_super) {
         _this._priv_preferredTextTracks = preferredTextTracks;
         _this._priv_preferredVideoTracks = preferredVideoTracks;
         _this._priv_reloadingMetadata = {};
+        _this._priv_lastAutoPlay = false;
         return _this;
     }
     Object.defineProperty(Player, "ErrorTypes", {
@@ -269,6 +271,7 @@ var Player = /** @class */ (function (_super) {
         log.info("API: Calling loadvideo", options.url, options.transport);
         this._priv_reloadingMetadata = { options: options };
         this._priv_initializeContentPlayback(options);
+        this._priv_lastAutoPlay = options.autoPlay;
     };
     /**
      * Reload the last loaded content.
@@ -485,11 +488,12 @@ var Player = /** @class */ (function (_super) {
             log.warn("API: Sending warning:", formattedError);
             _this.trigger("warning", formattedError);
         });
-        initializer.addEventListener("reloadingMediaSource", function () {
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
             contentInfos.segmentBuffersStore = null;
             if (contentInfos.trackChoiceManager !== null) {
                 contentInfos.trackChoiceManager.resetPeriods();
             }
+            _this._priv_lastAutoPlay = payload.autoPlay;
         });
         initializer.addEventListener("inbandEvents", function (inbandEvents) {
             return _this.trigger("inbandEvents", inbandEvents);
@@ -591,6 +595,48 @@ var Player = /** @class */ (function (_super) {
                     break;
             }
         };
+        /**
+         * `TaskCanceller` allowing to stop emitting `"play"` and `"pause"`
+         * events.
+         * `null` when such events are not emitted currently.
+         */
+        var playPauseEventsCanceller = null;
+        /**
+         * Callback emitting `"play"` and `"pause`" events once the content is
+         * loaded, starting from the state indicated in argument.
+         * @param {boolean} willAutoPlay - If `false`, we're currently paused.
+         */
+        var triggerPlayPauseEventsWhenReady = function (willAutoPlay) {
+            if (playPauseEventsCanceller !== null) {
+                playPauseEventsCanceller.cancel(); // cancel previous logic
+                playPauseEventsCanceller = null;
+            }
+            playerStateRef.onUpdate(function (val, stopListeningToStateUpdates) {
+                if (!isLoadedState(val)) {
+                    return; // content not loaded yet: no event
+                }
+                stopListeningToStateUpdates();
+                if (playPauseEventsCanceller !== null) {
+                    playPauseEventsCanceller.cancel();
+                }
+                playPauseEventsCanceller = new TaskCanceller();
+                playPauseEventsCanceller.linkToSignal(currentContentCanceller.signal);
+                if (willAutoPlay !== !videoElement.paused) {
+                    // paused status is not at the expected value on load: emit event
+                    if (videoElement.paused) {
+                        _this.trigger("pause", null);
+                    }
+                    else {
+                        _this.trigger("play", null);
+                    }
+                }
+                emitPlayPauseEvents(videoElement, function () { return _this.trigger("play", null); }, function () { return _this.trigger("pause", null); }, currentContentCanceller.signal);
+            }, { emitCurrentValue: false, clearSignal: currentContentCanceller.signal });
+        };
+        triggerPlayPauseEventsWhenReady(autoPlay);
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
+            triggerPlayPauseEventsWhenReady(payload.autoPlay);
+        });
         /**
          * `TaskCanceller` allowing to stop emitting `"seeking"` and `"seeked"`
          * events.
@@ -732,6 +778,40 @@ var Player = /** @class */ (function (_super) {
     Player.prototype.getPlayerState = function () {
         return this.state;
     };
+    /**
+     * Returns true if a content is loaded.
+     * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
+     */
+    Player.prototype.isContentLoaded = function () {
+        return !arrayIncludes(["LOADING", "RELOADING", "STOPPED"], this.state);
+    };
+    /**
+     * Returns true if the player is buffering.
+     * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
+     */
+    Player.prototype.isBuffering = function () {
+        return arrayIncludes(["BUFFERING", "SEEKING", "LOADING", "RELOADING"], this.state);
+    };
+    /**
+     * Returns the play/pause status of the player :
+     *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
+     *     for when loading is over,
+     *   - in other states, returns the `<video>` element .paused value,
+     *   - if the player is disposed, returns `true`.
+     * @returns {Boolean} - `true` if the player is paused or will be after loading,
+     * `false` otherwise.
+     */
+    Player.prototype.isPaused = function () {
+        if (this.videoElement) {
+            if (arrayIncludes(["LOADING", "RELOADING"], this.state)) {
+                return !this._priv_lastAutoPlay;
+            }
+            else {
+                return this.videoElement.paused;
+            }
+        }
+        return true;
+    };
     /**
      * Returns true if both:
      *   - a content is loaded
@@ -897,6 +977,14 @@ var Player = /** @class */ (function (_super) {
         }
         return this.videoElement.currentTime;
     };
+    /**
+     * Returns the last stored content position, in seconds.
+     *
+     * @returns {number|undefined}
+     */
+    Player.prototype.getLastStoredContentPosition = function () {
+        return this._priv_reloadingMetadata.reloadPosition;
+    };
     /**
      * Returns the current playback rate at which the video plays.
      * @returns {Number}
@@ -2340,5 +2428,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.31.0-dev.2023052200";
+Player.version = /* PLAYER_VERSION */ "3.31.0";
 export default Player;

package/dist/_esm5.processed/core/api/utils.d.ts

@@ -30,6 +30,16 @@ import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "./playback_obse
  * remove all listeners this function has registered.
  */
 export declare function emitSeekEvents(mediaElement: HTMLMediaElement | null, playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>, onSeeking: () => void, onSeeked: () => void, cancelSignal: CancellationSignal): void;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {function} onPlay - Callback called when a play operation has started
+ * on `mediaElement`.
+ * @param {function} onPause - Callback called when a pause operation has
+ * started on `mediaElement`.
+ * @param {Object} cancelSignal - When triggered, stop calling callbacks and
+ * remove all listeners this function has registered.
+ */
+export declare function emitPlayPauseEvents(mediaElement: HTMLMediaElement | null, onPlay: () => void, onPause: () => void, cancelSignal: CancellationSignal): void;
 /** Player state dictionnary. */
 export declare const enum PLAYER_STATES {
     STOPPED = "STOPPED",

package/dist/_esm5.processed/core/api/utils.js

@@ -49,6 +49,26 @@ export function emitSeekEvents(mediaElement, playbackObserver, onSeeking, onSeek
         }
     }, { includeLastObservation: true, clearSignal: cancelSignal });
 }
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {function} onPlay - Callback called when a play operation has started
+ * on `mediaElement`.
+ * @param {function} onPause - Callback called when a pause operation has
+ * started on `mediaElement`.
+ * @param {Object} cancelSignal - When triggered, stop calling callbacks and
+ * remove all listeners this function has registered.
+ */
+export function emitPlayPauseEvents(mediaElement, onPlay, onPause, cancelSignal) {
+    if (cancelSignal.isCancelled() || mediaElement === null) {
+        return;
+    }
+    mediaElement.addEventListener("play", onPlay);
+    mediaElement.addEventListener("pause", onPause);
+    cancelSignal.register(function () {
+        mediaElement.removeEventListener("play", onPlay);
+        mediaElement.removeEventListener("pause", onPause);
+    });
+}
 export function constructPlayerStateReference(initializer, mediaElement, playbackObserver, cancelSignal) {
     var playerStateRef = createSharedReference("LOADING" /* PLAYER_STATES.LOADING */, cancelSignal);
     initializer.addEventListener("loaded", function () {

package/dist/_esm5.processed/core/decrypt/session_events_listener.js

@@ -130,7 +130,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                 log.info("DRM: No license given, skipping session.update");
             }
             else {
-                return updateSessionWithMessage(session, licenseObject);
+                try {
+                    return updateSessionWithMessage(session, licenseObject);
+                }
+                catch (err) {
+                    manualCanceller.cancel();
+                    callbacks.onError(err);
+                }
             }
         })
             .catch(function (err) {

package/dist/_esm5.processed/core/init/media_source_content_initializer.js

@@ -249,7 +249,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     if (initCanceller.isUsed()) {
                         return;
                     }
-                    triggerEvent("reloadingMediaSource", null);
+                    triggerEvent("reloadingMediaSource", reloadOrder);
                     if (initCanceller.isUsed()) {
                         return;
                     }

package/dist/_esm5.processed/core/init/types.d.ts

@@ -95,7 +95,15 @@ export interface IContentInitializerEvents {
      * Event sent when we're starting attach a new MediaSource to the media element
      * (after removing the previous one).
      */
-    reloadingMediaSource: null;
+    reloadingMediaSource: {
+        /** The position we're reloading at, in seconds. */
+        position: number;
+        /**
+         * If `true`, we'll play directly after finishing the reloading operation.
+         * If `false`, we'll be paused after it.
+         */
+        autoPlay: boolean;
+    };
     /** Event sent after the player stalled. */
     stalled: IStallingSituation;
     /** Event sent when the player goes out of a stalling situation. */