senza-sdk 4.5.6 → 4.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.5.6",
+    "version": "4.5.8",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",

package/src/implementation/lifecycle.js

@@ -228,6 +228,9 @@ class Lifecycle extends LifecycleInterface {
                 } else if (triggerEvent.type === "hdmiStatusChanged") {
                     sdkLogger.info("The hdmiStatusChanged data is sent in the callback after uiReady is called");
                 }
+            } else if (this._connectReason === "tc_reconnect") {
+                this._triggerEvent.type = "restoreApplication";
+                this._connectReason = this.ConnectReason.APPLICATION_RECONNECT;
             }
             if (triggerEvent.fcid) {
                 this._triggerEventFcid = triggerEvent.fcid;

package/src/implementation/remotePlayer.js

@@ -3,7 +3,6 @@ import { RemotePlayer as RemotePlayerInterface, RemotePlayerError as RemotePlaye
 import {
     getFCID,
     generatePlaybackId,
-    getRestResponse,
     isAudioSyncConfigured,
     clearTimer,
     sdkLogger,
@@ -154,6 +153,21 @@ class RemotePlayer extends RemotePlayerInterface {
          * @private
          */
         this._playbackId = "";
+
+        /**
+         * Anchor position in seconds used by getPlaybackPosition().
+         * @type {number}
+         * @private
+         */
+        this._playbackPositionAnchor = getPlaybackInfo()?.playbackPosition || 0;
+
+        /**
+         * Timestamp in msec from which elapsed play time is accumulated.
+         * Undefined means playback clock is currently paused.
+         * @type {number | undefined}
+         * @private
+         */
+        this._playbackClockStartTimestampMs = undefined;
     }
 
     /** @private Initialize the remote player
@@ -199,6 +213,12 @@ class RemotePlayer extends RemotePlayerInterface {
         this._autoTune = false;
 
         this._isPlaying = window?.sessionStorage?.getItem("senzaSdk_isPlaying") === "true";
+        if (this._isPlaying) {
+            this._playbackPositionAnchor = getPlaybackInfo()?.playbackPosition || 0;
+            this._startPlaybackClock();
+        } else {
+            this._stopPlaybackClock();
+        }
 
         sdkLogger.info(`RemotePlayer initialized with load mode: ${this._loadMode}, senzaSdk_isPlaying: ${this._isPlaying}`);
         this._loadedUrl = playerState?.playbackUrl || "";
@@ -267,6 +287,16 @@ class RemotePlayer extends RemotePlayerInterface {
             }
         });
 
+        typeof document !== "undefined" && document.addEventListener("hs/playbackPosition", (e) => {
+            if (this._hasPlaybackIdMismatch(e?.detail, "hs/playbackPosition")) return;
+            // while seeking we do not want to update the playback position anchor, as it will cause the playback position to jump back to the previous position
+            if (!this._isSeekingByApplication) {
+                const detail = e?.detail;
+                const playbackPosition = typeof detail === "number" ? detail : detail?.data?.UiExpectedPts;
+                this._setPlaybackPositionAnchor(playbackPosition);
+            }
+        });
+
         typeof document !== "undefined" && document.addEventListener("hs/playback", (e) => {
             if (this._hasPlaybackIdMismatch(e?.detail, "hs/playback")) return;
             sdkLogger.info("Got hs/playback event with detail", JSON.stringify(e?.detail));
@@ -422,17 +452,74 @@ class RemotePlayer extends RemotePlayerInterface {
 
     /** @private change the internal load mode and store the new mode in session storage */
     _changePlayMode(newPlayMode) {
-        if (this._isPlaying !== newPlayMode) {
+        const didPlayModeChange = this._isPlaying !== newPlayMode;
+        if (didPlayModeChange) {
             // Create event with play mode detail
             const event = new CustomEvent("playModeChange", {
                 detail: { isPlaying: newPlayMode }
             });
             this.dispatchEvent(event);
+            if (newPlayMode) {
+                this._startPlaybackClock();
+            }
         }
         this._isPlaying = newPlayMode;
+
+        if (!newPlayMode) {
+            this._stopPlaybackClock();
+        }
         window?.sessionStorage?.setItem("senzaSdk_isPlaying", String(newPlayMode));
     }
 
+    /**
+     * @private
+     * @param {number} playbackPosition
+     */
+    _setPlaybackPositionAnchor(playbackPosition) {
+        if (typeof playbackPosition !== "number" || !Number.isFinite(playbackPosition)) {
+            return;
+        }
+
+        this._playbackPositionAnchor = playbackPosition;
+        if (this._playbackClockStartTimestampMs !== undefined) {
+            this._playbackClockStartTimestampMs = Date.now();
+        }
+    }
+
+    /**
+     * @private
+     */
+    _startPlaybackClock() {
+        if (this._playbackClockStartTimestampMs === undefined) {
+            this._playbackClockStartTimestampMs = Date.now();
+        }
+    }
+
+    /**
+     * @private
+     */
+    _stopPlaybackClock() {
+        if (this._playbackClockStartTimestampMs === undefined) {
+            return;
+        }
+
+        const elapsedSec = (Date.now() - this._playbackClockStartTimestampMs) / 1000;
+        this._playbackPositionAnchor += Math.max(0, elapsedSec);
+        this._playbackClockStartTimestampMs = undefined;
+    }
+
+    /**
+     * @private
+     * @returns {number}
+     */
+    _getSyncedPlaybackPosition() {
+        if (this._playbackClockStartTimestampMs === undefined) {
+            return this._playbackPositionAnchor;
+        }
+        const elapsedSec = (Date.now() - this._playbackClockStartTimestampMs) / 1000;
+        return this._playbackPositionAnchor + Math.max(0, elapsedSec);
+    }
+
 
     /** @private manage getting the local player current video frame media time and sending to the client
      * */
@@ -498,12 +585,15 @@ class RemotePlayer extends RemotePlayerInterface {
         this._availabilityStartTime = undefined;
         this._isSeekingByPlatform = false;
         this._isSeekingByApplication = false;
+        this._stopPlaybackClock();
+        this._playbackPositionAnchor = 0;
     }
 
     _seek(playbackPosition, waitForResponse = true) {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call seek() if remote player is not initialized");
         }
+        this._setPlaybackPositionAnchor(playbackPosition);
         setPlaybackInfo({ playbackPosition });
         if (window.cefQuery) {
             if (this._loadMode !== this.LoadMode.LOADED) {
@@ -632,6 +722,9 @@ class RemotePlayer extends RemotePlayerInterface {
     }
 
     _pause() {
+        // Stop the playback clock whenever we pause, including during internal seek operations
+        this._stopPlaybackClock();
+
         if (window.cefQuery) {
             const isForegroundState = lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND;
             if (this._remotePlayerApiVersion >= 2 && !this._isAudioSyncEnabled() && isForegroundState) {
@@ -826,12 +919,12 @@ class RemotePlayer extends RemotePlayerInterface {
             this._changeLoadMode(this.LoadMode.LOADING);
             this._changePlayMode(false);
             return new Promise((resolve, reject) => {
+                const playbackPosition = position || 0;
                 if (reset) {
                     // first, zero playback position
                     setPlaybackInfo({ playbackPosition: 0 });
                 }
                 const FCID = getFCID();
-                const playbackPosition = position ?? 0;
                 const logger = sdkLogger.withFields({ FCID, loadUrl: url, playbackPosition });
                 const audioLanguage = audioTrackId || this._selectedAudioTrack || this._config.preferredAudioLanguage || "";
                 const subtitlesLanguage = textTrackId || this._selectedSubtitlesTrack || this._config.preferredSubtitlesLanguage || "";
@@ -876,8 +969,9 @@ class RemotePlayer extends RemotePlayerInterface {
                     onSuccess: () => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`${message.type} completed successfully after ${duration} ms`);
-                        if (position > 0) {
-                            setPlaybackInfo({ playbackPosition: position });
+                        if (playbackPosition > 0) {
+                            this._setPlaybackPositionAnchor(playbackPosition);
+                            setPlaybackInfo({ playbackPosition });
                         }
                         timerId = clearTimer(timerId);
                         this._changeLoadMode(this.LoadMode.LOADED);
@@ -1138,7 +1232,7 @@ class RemotePlayer extends RemotePlayerInterface {
      * @returns {Promise<number|undefined>} current playback position
      * @throws {RemotePlayerError} error object contains code & msg
      */
-    async getPlaybackPosition() {
+    getPlaybackPosition() {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call getPlaybackPosition() if remote player is not initialized");
         }
@@ -1146,15 +1240,7 @@ class RemotePlayer extends RemotePlayerInterface {
             throw new RemotePlayerError(6001, "Cannot call getPlaybackPosition() if player is not loaded");
         }
 
-        try {
-            const response = await getRestResponse("playback-position");
-            const { currentVideoPosition } = JSON.parse(response || "{}");
-            return currentVideoPosition;
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            sdkLogger.error(`remotePlayer getPlaybackPosition failed: ${message}`);
-            throw new RemotePlayerError(6504, `getPlaybackPosition() failed: ${message}`);
-        }
+        return this._getSyncedPlaybackPosition();
     }
 
     /**
@@ -1572,6 +1658,7 @@ class RemotePlayer extends RemotePlayerInterface {
      * Getter/Setter for currentTime
      */
     get currentTime() {
+        // Todo - this can be replaced with the getPlaybackPosition, but it might cause a regression so we can leave it for now.
         return getPlaybackInfo()?.playbackPosition;
     }
     set currentTime(playbackPosition) {
@@ -1674,7 +1761,7 @@ class RemotePlayer extends RemotePlayerInterface {
 
         if (!this._isSeekingByPlatform) {
             this._pendingSeekPosition = playbackPosition;
-
+            this._setPlaybackPositionAnchor(playbackPosition);
             // If the local player is just initializing after loading the manifest, ignore the seeking event.
             if (this._localPlayerLoadCurrentTime === 0 && this._videoElement.currentTime > ONE_DAY_SECONDS) {
                 sdkLogger.info(`Seeking ignored for video currentTime init: currentTime: ${this._videoElement.currentTime}`);

package/src/interface/lifecycle.js

@@ -83,6 +83,7 @@ class Lifecycle extends EventTarget {
      * @property {string} UI_TERMINATION - Indicates that ui app has been reloaded due to ui termination
      * @property {string} WEBRTC_ERROR - Indicates that ui app has been reloaded due to webrtc error
      * @property {string} UI_WATCHDOG - Indicates that ui app has been reloaded due to ui watchdog not receiving ui frames
+     * @property {string} APPLICATION_RECONNECT - Indicates that ui app has been reloaded due to connector reconnect (e.g. after connector reconnect) and should be restored
      */
     ConnectReason = Object.freeze({
         UNKNOWN: "unknown",
@@ -91,7 +92,8 @@ class Lifecycle extends EventTarget {
         UI_RELEASE: "ui_release",
         UI_TERMINATION: "ui_termination",
         WEBRTC_ERROR: "webrtc_error",
-        UI_WATCHDOG: "ui_watchdog"
+        UI_WATCHDOG: "ui_watchdog",
+        APPLICATION_RECONNECT: "reconnect_app"
     });
 
     /**

package/src/interface/remotePlayer.js

@@ -357,11 +357,11 @@ class RemotePlayer extends EventTarget {
         return this.LoadMode.NOT_LOADED;
     }
 
-    /** Get the playback position directly from the connector. Note that this function can load the system. It is recommended to use it when accurate time is needed and currentTime can not be used.
-     * @returns {Promise<number|undefined>} current playback position
+    /** Get the current playback position.
+     * @returns {number|undefined} current playback position
      * @throws {RemotePlayerError} error object contains code & msg
      */
-    async getPlaybackPosition() {
+    getPlaybackPosition() {
         return 0;
     }
 

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.5.6";
+export const version = "4.5.8";