senza-sdk 4.5.8 → 4.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.5.8",
+    "version": "4.6.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -18,6 +18,8 @@
         "build:interface": "npx webpack --config interface.webpack.config.js",
         "prebuild:implementation": "npm run version:output",
         "build:implementation": "npx webpack --config implementation.webpack.config.js",
+        "build:dual-decode-sample": "npm run build && mkdir -p samples/dualDecode/sdk && cp dist/bundle.js dist/implementation.bundle.js samples/dualDecode/sdk/ && npm run build:dual-decode-sample:app",
+        "build:dual-decode-sample:app": "npx webpack --config samples/dualDecode/webpack.config.js --context samples/dualDecode",
         "test": "jest --maxWorkers=20% --coverage --verbose",
         "testall": "npm run test && npm run eslint --fix",
         "version:output": "echo 'export const version = \"'$npm_package_version'\";' > src/interface/version.js"

package/src/implementation/api.js

@@ -60,7 +60,7 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
 
     if (window.cefQuery) {
 
-        // First, check compatability with ui-streamer api version
+        // First, check compatibility with ui-streamer api version
         await new Promise((resolve, reject) => {
             window.cefQuery({
                 request: "apiVersion " + API_VERSION,
@@ -140,13 +140,15 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
             }
         }
 
-        // Initialize lifecycle first to make sure the state is updated.
-        await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
-        await remotePlayer._init(sessionInfoObj, triggerEvent);
+        await Promise.all([
+            lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent),
+            remotePlayer._init(sessionInfoObj, triggerEvent),
+            displayManager._init()
+        ]);
+
         alarmManager._init();
         messageManager._init();
         backgroundRenderControl._init();
-        await displayManager._init();
         sdkLogger.log("All submodules initialized");
 
 

package/src/implementation/displayManager.js

@@ -4,6 +4,7 @@ import { parseEdid } from "./edidParser";
 import { EventListenersManager } from "./eventListenersManager";
 import { bus, Events } from "./eventBus";
 import { lifecycle } from "./lifecycle";
+import { sessionInfo } from "./SessionInfo";
 
 
 export class DisplayManager extends DisplayManagerInterface {
@@ -38,6 +39,12 @@ export class DisplayManager extends DisplayManagerInterface {
     }
 
     async _init() {
+        const enableCec = sessionInfo?.sessionInfoObj?.settings?.client?.hdmi?.cec?.enable_cec;
+        if (enableCec === false) {
+            sdkLogger.log("CEC disabled via config (client.hdmi.cec.enable_cec=false), skipping DisplayManager init");
+            this._setDisplayProperties({ connection: this.DisplayConnectionStatus.UNKNOWN });
+            return;
+        }
         sdkLogger.log("Initializing DisplayManager");
         await this._updateDisplayInfo();
         if (!this._isInitialized) {

package/src/implementation/lifecycle.js

@@ -27,6 +27,12 @@ const DEFAULT_AUTO_SUSPEND_IDLE_DELAY = 60;
 // Session storage key for tracking timer-triggered background state
 const BACKGROUND_TIMER_KEY = "senzaSDK_backgroundTriggeredByTimer";
 
+/** @enum {string} */
+const UiTransition = Object.freeze({
+    START_UI: "startUi",
+    STOP_UI: "stopUi"
+});
+
 class Lifecycle extends LifecycleInterface {
     constructor() {
         super();
@@ -552,6 +558,58 @@ class Lifecycle extends LifecycleInterface {
         return Promise.resolve(true);
     }
 
+    /**
+     * @private Sends a simple message to the client and resolves/rejects based on the response.
+     * Used by the dual decode startUi/stopUi transitions.
+     * @param {UiTransition} type the message type to send
+     * @returns {Promise<boolean>}
+     */
+    _sendUiTransition(type) {
+        if (window.cefQuery) {
+            return new Promise((resolve, reject) => {
+                const FCID = getFCID();
+                const logger = sdkLogger.withFields({ FCID });
+                const message = { type, fcid: FCID };
+                // Mirror V2 remotePlayer lifecycle: ui-streamer resumes/pauses locally via internalAction
+                // while TC receives startUi/stopUi on the datachannel.
+                const internalAction = type === UiTransition.START_UI ? "uiActive" : "uiExit";
+                // TC confirms stopUi with isResponse; startUi is fire-and-forget until TC adds a response.
+                const waitForResponse = type !== UiTransition.START_UI;
+                const request = { target: "TC", waitForResponse, internalAction, message: JSON.stringify(message) };
+                window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: () => {
+                        logger.log(`${type} successfully sent`);
+                        resolve(true);
+                    },
+                    onFailure: (code, msg) => {
+                        logger.error(`${type} failed: ${code} ${msg}`);
+                        reject(new SenzaError(code, msg));
+                    }
+                });
+            });
+        }
+        sdkLogger.warn(`lifecycle ${type}: window.cefQuery is undefined`);
+        return Promise.resolve(true);
+    }
+
+    /**
+     * @private Starts the UI streaming.
+     * @returns {Promise<boolean>}
+     */
+    _startUi() {
+        return this._sendUiTransition(UiTransition.START_UI);
+    }
+
+    /**
+     * @private Stops the UI streaming.
+     * @returns {Promise<boolean>}
+     */
+    _stopUi() {
+        return this._sendUiTransition(UiTransition.STOP_UI);
+    }
+
     get state() {
         if (!this._isInitialized) {
             this._state = this.UiState.UNKNOWN;
@@ -725,6 +783,11 @@ class Lifecycle extends LifecycleInterface {
         this._isBackgroundTriggeredByTimer = false;
 
         if (window.cefQuery) {
+            if (remotePlayer._isDualDecodeActive()) {
+                // Cancel a pending dual-decode background transition that is waiting for the playing event.
+                this._inTransitionToBackground = false;
+            }
+
             const inTransition = this._isInTransition();
             if (inTransition || this._isForegroundOrTransitioning()) {
                 sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${inTransition}`);
@@ -746,11 +809,23 @@ class Lifecycle extends LifecycleInterface {
             this._inTransitionToForeground = true;
             bus.dispatchEvent(new Event(Events.LifecycleForeground));
             const FCID = getFCID();
+
             if (this._remotePlayerApiVersion >= 2) {
                 // Only update to playing UI if we started seeking in ABR. But, if we are seeking while already paused, keep the target seek state as is.
                 if (remotePlayer._isSeekingByApplication && remotePlayer._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
                     remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
                 }
+
+                if (remotePlayer._isDualDecodeActive()) {
+                    // In dual decode mode, returning to the UI only requires (re)showing the UI on top of the ABR video.
+                    // We must not stop the remote player playback, so skip the v2 uiActive/stop and legacy uiActiveRequest paths.
+                    try {
+                        return await this._startUi();
+                    } finally {
+                        this._inTransitionToForeground = false;
+                    }
+                }
+
                 return new Promise((resolve, reject) => {
                     const FCID = getFCID();
                     const logger = sdkLogger.withFields({ FCID });
@@ -817,6 +892,31 @@ class Lifecycle extends LifecycleInterface {
         return Promise.resolve(false);
     }
 
+    /**
+     * @private Handles the dual decode background transition: hide the UI via stopUi.
+     * Does not send any play/uiExit message. If the remote "playing" event has not arrived yet,
+     * stopUi is still called immediately and a warning is logged.
+     *
+     * @returns {Promise<boolean>} stopUi result
+     */
+    _moveToBackgroundDualDecode() {
+        if (remotePlayer._isPlayingEventPending) {
+            sdkLogger.warn("dual decode moveToBackground: moving to background before the playing event arrived; stopping the UI now");
+        } else {
+            sdkLogger.info("dual decode moveToBackground: playing event already arrived, stopping the UI");
+        }
+        this._inTransitionToBackground = true;
+        return this._stopUi()
+            .then((result) => {
+                this._inTransitionToBackground = false;
+                return result;
+            })
+            .catch((error) => {
+                this._inTransitionToBackground = false;
+                throw error;
+            });
+    }
+
     _moveToBackground(switchMode = SwitchMode.SEAMLESS) {
         /*const inTransition = this._isInTransition();
         if (inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
@@ -846,6 +946,11 @@ class Lifecycle extends LifecycleInterface {
                 return this._moveToUiStandby();
             }
             remotePlayer._changePlayMode(true);
+
+            if (remotePlayer._isDualDecodeActive()) {
+                return this._moveToBackgroundDualDecode();
+            }
+
             this._inTransitionToBackground = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();

package/src/implementation/remotePlayer.js

@@ -4,10 +4,13 @@ import {
     getFCID,
     generatePlaybackId,
     isAudioSyncConfigured,
+    isDualDecodeEnabled,
+    getDualDecodeAbrSurfaceSize,
     clearTimer,
     sdkLogger,
     StreamType,
     SwitchMode,
+    VideoLayer,
     delay,
     SeekState,
     TargetPlayingState,
@@ -26,6 +29,7 @@ const MULTI_SEEK_DELAY_MSEC = 250;
 const LOAD_START_SYNC_DIFF = 1;
 const INVALID_SET_PLAYABLE_URI_CODE = 99;
 export const ONE_DAY_SECONDS = 86400;
+export const VOD_INIT_SEEK_EPSILON_SEC = 1;
 const BACKGROUND_LOAD_MIN_SDK_VERSION = "4.5.0";
 
 // Default timeout for waiting for the remote player confirmation
@@ -68,6 +72,8 @@ function setPlaybackInfo(playbackInfo) {
 }
 
 class RemotePlayer extends RemotePlayerInterface {
+    VideoLayer = VideoLayer;
+
     constructor() {
         super();
         /**
@@ -140,6 +146,14 @@ class RemotePlayer extends RemotePlayerInterface {
          */
         this._isSeekingByPlatform = false;
 
+        /**
+         * Start position (seconds) from the most recent load(). Used to ignore the local player's
+         * first seeking event when VOD is loaded from a non-zero position (Shaka init seek).
+         * @type {number}
+         * @private
+         */
+        this._loadStartPosition = 0;
+
         /**
          * @type {boolean}
          * @description field indicating if the remote player is playing abr or not. Should be changed when starting/stoping playback
@@ -154,6 +168,13 @@ class RemotePlayer extends RemotePlayerInterface {
          */
         this._playbackId = "";
 
+        /**
+         * @type {boolean}
+         * @description True while a dual-decode play() is awaiting the remote "playing" event.
+         * @private
+         */
+        this._isPlayingEventPending = false;
+
         /**
          * Anchor position in seconds used by getPlaybackPosition().
          * @type {number}
@@ -213,14 +234,18 @@ class RemotePlayer extends RemotePlayerInterface {
         this._autoTune = false;
 
         this._isPlaying = window?.sessionStorage?.getItem("senzaSdk_isPlaying") === "true";
+        this._textTrackVisibility = window?.sessionStorage?.getItem("senzaSdk_textTrackVisibility") === "true";
         if (this._isPlaying) {
             this._playbackPositionAnchor = getPlaybackInfo()?.playbackPosition || 0;
             this._startPlaybackClock();
+
+            // UI release while playing: local player may load and seek; seed load start so that seek is treated as init.
+            this._loadStartPosition = this.currentTime;
         } else {
             this._stopPlaybackClock();
         }
 
-        sdkLogger.info(`RemotePlayer initialized with load mode: ${this._loadMode}, senzaSdk_isPlaying: ${this._isPlaying}`);
+        sdkLogger.info(`RemotePlayer initialized with load mode: ${this._loadMode}, senzaSdk_isPlaying: ${this._isPlaying}, senzaSdk_textTrackVisibility: ${this._textTrackVisibility}`);
         this._loadedUrl = playerState?.playbackUrl || "";
         // Make sure that the event listeners are registered only once
         if (!this._isInitialized) {
@@ -270,6 +295,9 @@ class RemotePlayer extends RemotePlayerInterface {
         typeof document !== "undefined" && document.addEventListener("hs/remotePlayerEvent", (e) => {
             if (this._hasPlaybackIdMismatch(e?.detail, "hs/remotePlayerEvent")) return;
             sdkLogger.info("Got hs/remotePlayerEvent event with detail", JSON.stringify(e?.detail));
+            if (e?.detail?.eventName === "playing") {
+                this._isPlayingEventPending = false;
+            }
             this.dispatchEvent(new Event(e?.detail?.eventName));
         });
 
@@ -585,6 +613,8 @@ class RemotePlayer extends RemotePlayerInterface {
         this._availabilityStartTime = undefined;
         this._isSeekingByPlatform = false;
         this._isSeekingByApplication = false;
+        this._isPlayingEventPending = false;
+        this._loadStartPosition = 0;
         this._stopPlaybackClock();
         this._playbackPositionAnchor = 0;
     }
@@ -685,6 +715,12 @@ class RemotePlayer extends RemotePlayerInterface {
             } else if (!this.textTrackVisibility) {
                 message.subtitlesLanguage = "";
             }
+            if (switchMode === SwitchMode.DUAL_DECODE) {
+                message.switchMode = SwitchMode.DUAL_DECODE;
+                message.streamType = streamType;
+                waitForResponse = true;
+                this._isPlayingEventPending = true;
+            }
             logger.log(`remotePlayer play: sending play action remotePlayer._isPlaying: ${this._isPlaying} audioLanguage=${message.audioLanguage} subtitlesLanguage=${message.subtitlesLanguage} textTrackVisibility=${this.textTrackVisibility}`);
             const request = { target: "TC", waitForResponse: waitForResponse, message: JSON.stringify(message) };
             return new Promise((resolve, reject) => {
@@ -703,6 +739,7 @@ class RemotePlayer extends RemotePlayerInterface {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
                         timerId = clearTimer(timerId);
+                        this._isPlayingEventPending = false;
                         reject(new RemotePlayerError(code, msg));
                     }
                 });
@@ -727,7 +764,7 @@ class RemotePlayer extends RemotePlayerInterface {
 
         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) {
+            if (this._remotePlayerApiVersion >= 2 && !this._isAudioSyncEnabled() && !this._isDualDecodeActive() && isForegroundState) {
                 sdkLogger.info("remotePlayer pause: application in foreground, remote player is not playing.");
                 return Promise.resolve();
             }
@@ -793,6 +830,12 @@ class RemotePlayer extends RemotePlayerInterface {
                 fcid: FCID,
                 playbackId: this._playbackId
             };
+            if (this._isDualDecodeActive()) {
+                message.switchMode = SwitchMode.DUAL_DECODE;
+                if (streamType & StreamType.VIDEO) {
+                    this._isPlayingEventPending = false;
+                }
+            }
             const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
             return new Promise((resolve, reject) => {
                 let timerId = 0;
@@ -920,6 +963,7 @@ class RemotePlayer extends RemotePlayerInterface {
             this._changePlayMode(false);
             return new Promise((resolve, reject) => {
                 const playbackPosition = position || 0;
+                this._loadStartPosition = playbackPosition;
                 if (reset) {
                     // first, zero playback position
                     setPlaybackInfo({ playbackPosition: 0 });
@@ -1026,6 +1070,7 @@ class RemotePlayer extends RemotePlayerInterface {
             this._abortSetAudioLanguage = true;
             this._abortSetSubtitleLanguage = true;
             this._abortSeeking = true;
+            this._isPlayingEventPending = false;
             const previousLoadMode = this._loadMode;
             this._changeLoadMode(this.LoadMode.UNLOADING);
             this._changePlayMode(false);
@@ -1113,6 +1158,17 @@ class RemotePlayer extends RemotePlayerInterface {
         this._changePlayMode(true);
         this._autoTune = autoTune;
 
+        if (this._isDualDecodeActive()) {
+            // In dual decode mode, ABR video is rendered over the UI video, so we always play audio + video
+            // (and subtitles when visible) using the DUAL_DECODE switch mode, bypassing the foreground/audio-sync
+            // early returns below. Start the waitForPlaying timer so callers (e.g. moveToBackground)
+            // can wait for the remote player to actually start playing.
+            const dualDecodeStreamType = this.textTrackVisibility
+                ? (StreamType.AUDIO | StreamType.VIDEO | StreamType.SUBTITLE)
+                : (StreamType.AUDIO | StreamType.VIDEO);
+            return this._play(dualDecodeStreamType, SwitchMode.DUAL_DECODE);
+        }
+
         if (this._isSetAudioInProgress) {
             sdkLogger.info("application requesting play during setAudioLanguage");
             this._targetSetAudioPlayingState = TargetPlayingState.PLAYING_UI;
@@ -1198,6 +1254,18 @@ class RemotePlayer extends RemotePlayerInterface {
         return this._pause();
     }
 
+    /** Stop playback of all streams (audio, video and subtitles).
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     *
+     * */
+    stop() {
+        if (!this._isInitialized) {
+            throw new RemotePlayerError(6500, "Cannot call stop() if remote player is not initialized");
+        }
+        return this._stop(StreamType.AUDIO | StreamType.VIDEO | StreamType.SUBTITLE);
+    }
+
     /** Get the currently loaded uri, or empty string is player is not loaded.
      * @returns {string} loaded uri
      * @throws {RemotePlayerError} error object contains code & msg
@@ -1588,14 +1656,33 @@ class RemotePlayer extends RemotePlayerInterface {
         // Convert to boolean in case apps pass 0/1 instead false/true.
         const newVisibility = !!visible;
 
+        this._textTrackVisibility = newVisibility;
+        window?.sessionStorage?.setItem("senzaSdk_textTrackVisibility", String(newVisibility));
+
         if (oldVisibility === newVisibility) {
             return;
         }
 
-        this._textTrackVisibility = newVisibility;
-        if (!this._textTrackVisibility) {
-            // Setting the visibility to false clears any previous selections user has done
-            this._selectedSubtitlesTrack = "";
+        if (this._remotePlayerApiVersion <= 2) {
+            if (!this._textTrackVisibility) {
+                // For older versions, we need to clear the selected subtitles track
+                this._selectedSubtitlesTrack = "";
+            }
+            return;
+        }
+
+        if (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND) {
+            if (!this._textTrackVisibility) {
+                this._stop(StreamType.SUBTITLE).catch((error) => {
+                    sdkLogger.warn(`remotePlayer setTextTrackVisibility: stop subtitles failed with error ${error.message}.`);
+                });
+            } else {
+                this._play(StreamType.SUBTITLE).catch((error) => {
+                    sdkLogger.warn(`remotePlayer setTextTrackVisibility: play subtitles failed with error ${error.message}.`);
+                });
+            }
+        } else {
+            sdkLogger.info("remotePlayer setTextTrackVisibility V3+: not updating remote subtitle stream outside background");
         }
     }
 
@@ -1654,6 +1741,109 @@ class RemotePlayer extends RemotePlayerInterface {
         return this._setScreenBlackout(0);
     }
 
+    /**
+     * @private
+     * Whether dual decode is active for this player (remote player API v2+ and session capability/settings enabled).
+     * @returns {boolean}
+     */
+    _isDualDecodeActive() {
+        return this._remotePlayerApiVersion >= 2 && isDualDecodeEnabled();
+    }
+
+    /** Set the position and size of the remote player (ABR) video on screen, or make it fullscreen.
+     * Only available when dual decode is enabled.
+     * The given rectangle is expressed in the UI coordinate space (window.innerWidth/window.innerHeight)
+     * and is validated and scaled to the client's ABR surface size before being sent to the client.
+     * @param {Object} rect
+     * @param {number} [rect.x] horizontal position in px (UI coordinate space)
+     * @param {number} [rect.y] vertical position in px (UI coordinate space)
+     * @param {number} [rect.width] width in px (UI coordinate space)
+     * @param {number} [rect.height] height in px (UI coordinate space)
+     * @param {boolean} [rect.fullScreen=false] when true, the video is rendered fullscreen and the rect is ignored
+     * @param {VideoLayer} [rect.layer=VideoLayer.FRONT] which layer the ABR video should be rendered on
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     */
+    setVideoRect({ x, y, width, height, fullScreen = false, layer } = {}) {
+        if (!this._isDualDecodeActive()) {
+            throw new RemotePlayerError(6506, "Cannot call setVideoRect() when dual decode is not enabled");
+        }
+
+        layer = layer ?? VideoLayer.FRONT;
+
+        const FCID = getFCID();
+        const message = {
+            type: "remotePlayer.setVideoRect",
+            class: "remotePlayer",
+            action: "setVideoRect",
+            fcid: FCID,
+            playbackId: this._playbackId,
+            layer
+        };
+
+        if (fullScreen) {
+            message.fullScreen = true;
+        } else {
+            const winW = window.innerWidth;
+            const winH = window.innerHeight;
+            const isValid = [x, y, width, height].every((value) => typeof value === "number" && Number.isFinite(value) && value >= 0)
+                && x + width <= winW && y + height <= winH;
+            if (!isValid) {
+                throw new RemotePlayerError(6505, `setVideoRect() received invalid rectangle {x:${x}, y:${y}, width:${width}, height:${height}} for window {width:${winW}, height:${winH}}`);
+            }
+            const { width: abrW, height: abrH } = getDualDecodeAbrSurfaceSize();
+            message.x = Math.round(x * abrW / winW);
+            message.y = Math.round(y * abrH / winH);
+            message.width = Math.round(width * abrW / winW);
+            message.height = Math.round(height * abrH / winH);
+        }
+
+        if (window.cefQuery) {
+            const logger = sdkLogger.withFields({ FCID });
+            logger.log(`remotePlayer setVideoRect: sending setVideoRect action fullScreen=${!!fullScreen} layer=${layer}`);
+            const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
+            return new Promise((resolve, reject) => {
+                let timerId = 0;
+                const timeBeforeSendingRequest = Date.now();
+                const queryId = window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: () => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`setVideoRect completed successfully after ${duration} ms`);
+                        timerId = clearTimer(timerId);
+                        resolve();
+                    },
+                    onFailure: (code, msg) => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`setVideoRect failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                        timerId = clearTimer(timerId);
+                        reject(new RemotePlayerError(code, msg));
+                    }
+                });
+                logger.log(`window.cefQuery for setVideoRect returned query id ${queryId}`);
+                const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                timerId = setTimeout(() => {
+                    logger.log(`setVideoRect reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new RemotePlayerError(6000, `setVideoRect reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+        sdkLogger.error("remotePlayer setVideoRect: window.cefQuery is undefined");
+        return Promise.resolve(undefined);
+    }
+
+    /** Make the remote player (ABR) video fullscreen on the given layer.
+     * Only available when dual decode is enabled.
+     * @param {VideoLayer} [layer=VideoLayer.FRONT] which layer the ABR video should be rendered on
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     */
+    setVideoFullscreen(layer) {
+        return this.setVideoRect({ fullScreen: true, layer: layer ?? VideoLayer.FRONT });
+    }
+
     /**
      * Getter/Setter for currentTime
      */
@@ -1763,16 +1953,24 @@ class RemotePlayer extends RemotePlayerInterface {
             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}`);
-                this._localPlayerLoadCurrentTime = this._videoElement.currentTime;
-                // if the difference between the remote player and the video element current time is greater than the load start sync diff (default 1 second), seek to the remote player current time
-                if (this._isPlaying && this.currentTime > 0 && Math.abs(this._videoElement.currentTime - this.currentTime) > this._loadStartSyncDiff) {
-                    sdkLogger.info(`Remote player is playing, seeking from ${this._videoElement.currentTime} to ${this.currentTime}`);
-                    this._isSeekingByPlatform = true;
-                    this._videoElement.currentTime = this.currentTime;
+            // Live: Shaka jumps from 0 to a UTC wall-clock time (> one day in seconds).
+            // VOD: load(url, startPosition) causes Shaka to seek near that start position (within epsilon).
+            if (this._videoElement) {
+                const currentTime = this._videoElement.currentTime;
+                const isLiveInitSeek = this._localPlayerLoadCurrentTime === 0 && currentTime > ONE_DAY_SECONDS;
+                const isVodInitSeek = this._localPlayerLoadCurrentTime === 0 && this._loadStartPosition > 0 && Math.abs(currentTime - this._loadStartPosition) <= VOD_INIT_SEEK_EPSILON_SEC;
+                sdkLogger.info(`Check for init seek: currentTime: ${currentTime}, loadStartPosition: ${this._loadStartPosition}, isLiveInitSeek: ${isLiveInitSeek}, isVodInitSeek: ${isVodInitSeek}`);
+                if (isLiveInitSeek || isVodInitSeek) {
+                    sdkLogger.info(`Seeking ignored for video currentTime init: currentTime: ${currentTime}, loadStartPosition: ${this._loadStartPosition}`);
+                    this._localPlayerLoadCurrentTime = currentTime;
+                    // if the difference between the remote player and the video element current time is greater than the load start sync diff (default 1 second), seek to the remote player current time
+                    if (isLiveInitSeek && this._isPlaying && this.currentTime > 0 && Math.abs(currentTime - this.currentTime) > this._loadStartSyncDiff) {
+                        sdkLogger.info(`Remote player is playing, seeking from ${currentTime} to ${this.currentTime}`);
+                        this._isSeekingByPlatform = true;
+                        this._videoElement.currentTime = this.currentTime;
+                    }
+                    return;
                 }
-                return;
             }
         }
         const backgroundSeekSupported = isAppVersionAboveOrEqual(this._deviceAppVersion, backgroundSeekMinClientAppVersion);
@@ -1787,6 +1985,31 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
+    /**
+     * Resolve the initial target playing state from current playback and lifecycle state.
+     *
+     * | _isPlaying | lifecycle.state             | _inTransitionToForeground | Result       |
+     * |------------|-----------------------------|---------------------------|--------------|
+     * | false      | any                         | any                       | PAUSED       |
+     * | true       | FOREGROUND                  | any                       | PLAYING_UI   |
+     * | true       | BACKGROUND                  | true                      | PLAYING_UI   |
+     * | true       | BACKGROUND                  | false                     | PLAYING_ABR  |
+     * | true       | IN_TRANSITION_TO_BACKGROUND | any                       | PLAYING_ABR  |
+     *
+     * @private
+     * @returns {string} TargetPlayingState value
+     */
+    _getInitialTargetPlayingState() {
+        if (!this._isPlaying) {
+            return TargetPlayingState.PAUSED;
+        }
+        if (!lifecycle._inTransitionToForeground
+            && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+            return TargetPlayingState.PLAYING_ABR;
+        }
+        return TargetPlayingState.PLAYING_UI;
+    }
+
     /** Performs the seek operation which comprises the following steps:
      *  1) Possible pause if playing
      *  2) Wait for any further changes in the currentTime
@@ -1799,16 +2022,7 @@ class RemotePlayer extends RemotePlayerInterface {
      * */
     async _atomicSeek() {
         sdkLogger.info("Seeking: local video element seeking start while isPlaying: ", this._isPlaying);
-        if (this._isPlaying) {
-            if (!(lifecycle._inTransitionToForeground || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND) && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
-                sdkLogger.info("seek in background", this._isPlaying);
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-            } else {
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-            }
-        } else {
-            this._targetSeekPlayingState = TargetPlayingState.PAUSED;
-        }
+        this._targetSeekPlayingState = this._getInitialTargetPlayingState();
 
         // The platform could be currently syncing audio/video using playback rate. Reset when performing seek.
         if (this._videoElement) {
@@ -1901,7 +2115,7 @@ class RemotePlayer extends RemotePlayerInterface {
             return Promise.resolve();
         }
 
-        this._targetSetAudioPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        this._targetSetAudioPlayingState = this._getInitialTargetPlayingState();
         sdkLogger.log(`remotePlayer _atomicSetAudioLanguage: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetAudioPlayingState}`);
 
         this._abortSetAudioLanguage = false;
@@ -1968,7 +2182,7 @@ class RemotePlayer extends RemotePlayerInterface {
             return Promise.resolve();
         }
 
-        this._targetSetSubtitlePlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        this._targetSetSubtitlePlayingState = this._getInitialTargetPlayingState();
         sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetSubtitlePlayingState}`);
 
         this._abortSetSubtitleLanguage = false;