senza-sdk 4.4.1-daf0312.0 → 4.4.2-efcb53d.0

package/dist/bundle.js.LICENSE.txt

@@ -12,9 +12,27 @@
 
 /*
  @license
- EME Encryption Scheme Polyfill
- Copyright 2019 Google LLC
- SPDX-License-Identifier: Apache-2.0
+ Copyright 2013 Ali Al Dallal
+
+ Licensed under the MIT license.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
 */
 
 /*
@@ -45,6 +63,13 @@
  SPDX-License-Identifier: Apache-2.0
 */
 
+/*
+ @license
+ Shaka Player
+ Copyright 2025 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
 /*
  @license
  tXml

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.4.1-daf0312.0",
+    "version": "4.4.2-efcb53d.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -53,15 +53,15 @@
                 "statements": 93.46
             },
             "src/interface": {
-                "branches": 68.42,
-                "functions": 39.63,
-                "lines": 64.94,
-                "statements": 65.32
+                "branches": 63.9,
+                "functions": 39.28,
+                "lines": 64.61,
+                "statements": 65
             }
         }
     },
     "dependencies": {
-        "shaka-player": "^4.12.5",
+        "shaka-player": "4.15.8",
         "moment": "^2.30.1"
     }
 }

package/src/api.js

@@ -308,6 +308,9 @@ let ShakaPlayerImplementation;
 let shakaImplementation;
 
 if (!isRunningE2E()) {
+    // ------------------------------------------------------------------------------------------------
+    // -- Do NOT change this log, as ui-streamer is checking this string to detect abnormal behavior --
+    // ------------------------------------------------------------------------------------------------
     sdkLogger.warn("Senza SDK is not running in E2E environment. Some features may not work as expected.");
 
     lifecycle = new Lifecycle();

package/src/implementation/api.js

@@ -130,7 +130,7 @@ 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?.settings?.["ui-streamer"], triggerEvent);
+        await remotePlayer._init(sessionInfoObj, triggerEvent);
         alarmManager._init();
         messageManager._init();
         sdkLogger.log("All submodules initialized");

package/src/implementation/lifecycle.js

@@ -29,7 +29,9 @@ class Lifecycle extends LifecycleInterface {
          * @private
          */
         this._isInitialized = false;
-        this._inTransition = false;
+        this._inTransitionToForeground = false;
+        this._inTransitionToBackground = false;
+        this._inTransitionToStandby = false;
 
         /**
          * Event listeners manager for the userdisconnected event
@@ -310,10 +312,10 @@ class Lifecycle extends LifecycleInterface {
     // This api is part of epic HSDEV-713
     _moveToUiStandby() {
         if (window.cefQuery) {
-            this._inTransition = true;
+            this._inTransitionToStandby = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
-                const request = { target: "TC", waitForResponse: false, internalAction: "uiExit", message: JSON.stringify({ type: "uiStandbyRequest", autoPlay: remotePlayer._autoPlay, fcid: FCID }) };
+                const request = { target: "TC", waitForResponse: false, internalAction: "uiExit", message: JSON.stringify({ type: "uiStandbyRequest", fcid: FCID }) };
                 const logger = sdkLogger.withFields({ FCID });
                 logger.log("lifecycle moveToUiStandby: sending uiStandbyRequest");
                 window.cefQuery({
@@ -321,12 +323,12 @@ class Lifecycle extends LifecycleInterface {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("[ moveToUiStandby ] moveToUiStandby successfully sent");
-                        this._inTransition = false;
+                        this._inTransitionToStandby = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
                         logger.error(`[ moveToUiStandby ] moveToUiStandby failed: ${code} ${msg}`);
-                        this._inTransition = false;
+                        this._inTransitionToStandby = false;
                         reject(`moveToUiStandby failed: ${code} ${msg}`);
                     }
                 });
@@ -423,6 +425,14 @@ class Lifecycle extends LifecycleInterface {
         this._countdown = null;
     }
 
+    /**
+     * @private
+     */
+    _isInTransition() {
+        return this._inTransitionToForeground || this._inTransitionToBackground || this._inTransitionToStandby;
+    }
+
+
     getState() {
         if (window.cefQuery) {
             return new Promise((resolve, reject) => {
@@ -445,14 +455,19 @@ class Lifecycle extends LifecycleInterface {
 
     moveToForeground() {
         if (window.cefQuery) {
-            if (this._inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
-                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${this._inTransition}`);
+            const inTransition = this._isInTransition();
+            if (inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
+                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${inTransition}`);
                 return Promise.resolve(false);
             }
-            this._inTransition = true;
+            this._inTransitionToForeground = true;
             alarmManager._moveToForegroundCalled();
             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;
+                }
                 return new Promise((resolve, reject) => {
                     const FCID = getFCID();
                     const logger = sdkLogger.withFields({ FCID });
@@ -472,14 +487,14 @@ class Lifecycle extends LifecycleInterface {
                         onSuccess: () => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop completed successfully after ${duration} ms`);
-                            this._inTransition = false;
+                            this._inTransitionToForeground = false;
                             timerId = clearTimer(timerId);
                             resolve(true);
                         },
                         onFailure: (code, msg) => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                            this._inTransition = false;
+                            this._inTransitionToForeground = false;
                             timerId = clearTimer(timerId);
                             reject(new SenzaError(code, msg));
                         }
@@ -488,7 +503,7 @@ class Lifecycle extends LifecycleInterface {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransition = false;
+                        this._inTransitionToForeground = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -503,11 +518,11 @@ class Lifecycle extends LifecycleInterface {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("uiActiveRequest successfully sent");
-                        this._inTransition = false;
+                        this._inTransitionToForeground = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
-                        this._inTransition = false;
+                        this._inTransitionToForeground = false;
                         logger.error(`uiActiveRequest failed: ${code} ${msg}`);
                         reject(`uiActiveRequest failed: ${code} ${msg}`);
                     }
@@ -520,10 +535,6 @@ class Lifecycle extends LifecycleInterface {
 
     _moveToBackground() {
         if (window.cefQuery) {
-            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
-                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
-                return Promise.resolve(false);
-            }
             // If audio sync is disabled, we only need to sync before remote player starts playing
             if (!isAudioSyncConfigured()) {
                 remotePlayer._syncRemotePlayerWithLocalPlayer();
@@ -534,8 +545,8 @@ class Lifecycle extends LifecycleInterface {
             if (!remotePlayer._isPlaying) {
                 return this._moveToUiStandby();
             }
-
-            this._inTransition = true;
+            remotePlayer._changePlayMode(true);
+            this._inTransitionToBackground = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const logger = sdkLogger.withFields({ FCID });
@@ -548,14 +559,15 @@ class Lifecycle extends LifecycleInterface {
                     action: "play",
                     fcid: FCID,
                     audioLanguage,
-                    subtitlesLanguage
+                    subtitlesLanguage,
+                    autoTune: remotePlayer._autoTune
                 };
                 if (this._remotePlayerApiVersion >= 2) {
                     message.type = "remotePlayer.play";
                     message.class = "remotePlayer";
-                    message.switchMode = remotePlayer._isAudioSyncEnabled() ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
+                    // in background, client expects to get NON_SEAMLESS switch mode.
+                    message.switchMode = remotePlayer._isAudioSyncEnabled() && this._state !== this.UiState.BACKGROUND ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
                     message.streamType = remotePlayer.textTrackVisibility ? (StreamType.AUDIO | StreamType.VIDEO | StreamType.SUBTITLE) : (StreamType.AUDIO | StreamType.VIDEO);
-                    message.autoPlay = remotePlayer._autoPlay;
                     request = {
                         target: "TC",
                         waitForResponse: true,
@@ -568,7 +580,7 @@ class Lifecycle extends LifecycleInterface {
                     }
                     request = message;
                 }
-                logger.log(`lifecycle moveToBackground: sending play action audioLanguage=${message.audioLanguage} subtitlesLanguage=${message.subtitlesLanguage} textTrackVisibility=${remotePlayer.textTrackVisibility}`);
+                logger.log(`lifecycle moveToBackground: sending play action audioLanguage=${message.audioLanguage} subtitlesLanguage=${message.subtitlesLanguage} textTrackVisibility=${remotePlayer.textTrackVisibility} autoTune=${remotePlayer._autoTune}`);
                 let timerId = 0;
                 const timeBeforeSendingRequest = Date.now();
                 const queryId = window.cefQuery({
@@ -577,14 +589,14 @@ class Lifecycle extends LifecycleInterface {
                     onSuccess: () => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play completed successfully after ${duration} ms`);
-                        this._inTransition = false;
+                        this._inTransitionToBackground = false;
                         timerId = clearTimer(timerId);
                         resolve();
                     },
                     onFailure: (code, msg) => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                        this._inTransition = false;
+                        this._inTransitionToBackground = false;
                         timerId = clearTimer(timerId);
                         reject(new SenzaError(code, msg));
                     }
@@ -594,7 +606,7 @@ class Lifecycle extends LifecycleInterface {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`play reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransition = false;
+                        this._inTransitionToBackground = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `play reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -607,11 +619,11 @@ class Lifecycle extends LifecycleInterface {
 
     moveToBackground() {
         if (window.cefQuery) {
-            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
-                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
+            const inTransition = this._isInTransition();
+            if (inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${inTransition}`);
                 return Promise.resolve(false);
             }
-
             if (remotePlayer._isSeekingByApplication) {
                 remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
                 return Promise.resolve(true);

package/src/implementation/remotePlayer.js

@@ -11,7 +11,8 @@ import {
     SeekState,
     TargetPlayingState,
     isSubtitlesTranslationAllowed,
-    isSubtitlesTranslationPattern
+    isSubtitlesTranslationPattern,
+    isAppVersionAboveOrEqual
 } from "./utils";
 import { lifecycle } from "./lifecycle";
 import { writeLicenseResponse } from "./api";
@@ -143,10 +144,12 @@ class RemotePlayer extends RemotePlayerInterface {
     }
 
     /** @private Initialize the remote player
-     * @param {Object} uiStreamerSettings ui-streamer portion of the settings taken from session info
+     * @param {Object} sessionObj session information object
+     * @param {Object} triggerEvent trigger event object
      * */
-    async _init(uiStreamerSettings, triggerEvent) {
+    async _init(sessionObj, triggerEvent) {
         sdkLogger.info("Initializing RemotePlayer");
+        const uiStreamerSettings = sessionObj?.settings?.["ui-streamer"];
         let playerState = {
             isLoaded: false,
             playbackUrl: ""
@@ -180,7 +183,7 @@ class RemotePlayer extends RemotePlayerInterface {
             }
         }
         this._loadMode = playerState?.isLoaded ? this.LoadMode.LOADED : this.LoadMode.NOT_LOADED;
-        this._autoPlay = false;
+        this._autoTune = false;
 
         this._isPlaying = window?.sessionStorage?.getItem("senzaSdk_isPlaying") === "true";
 
@@ -194,6 +197,9 @@ class RemotePlayer extends RemotePlayerInterface {
         this._remotePlayerConfirmationTimeout = uiStreamerSettings?.remotePlayerConfirmationTimeout ?? DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT;
         this._remotePlayerApiVersion = uiStreamerSettings?.remotePlayerApiVersion || 1;
         this._multiSeekDelay = uiStreamerSettings?.multiSeekDelay || MULTI_SEEK_DELAY_MSEC;
+        this._uiAvSyncIntervalMs = uiStreamerSettings?.uiAvSyncIntervalMs;
+        this._abrAvSyncIntervalMs = uiStreamerSettings?.abrAvSyncIntervalMs;
+        this._deviceAppVersion = sessionObj?.manifest?.["device-app"] || "";
 
         sdkLogger.info(`remotePLayer isPlaying=${this._isPlaying}`);
 
@@ -205,6 +211,7 @@ class RemotePlayer extends RemotePlayerInterface {
         }
         this._availabilityStartTime = playbackMetadata.availabilityStartTime;
         this._updateTracks(playbackMetadata);
+
     }
 
     /**
@@ -528,7 +535,8 @@ class RemotePlayer extends RemotePlayerInterface {
             };
             let waitForResponse = false;
             if (this._remotePlayerApiVersion >= 2) {
-                message.switchMode = this._isAudioSyncEnabled() ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
+                // in background, client expects to get NON_SEAMLESS switch mode.
+                message.switchMode = this._isAudioSyncEnabled() && lifecycle.state !== lifecycle.UiState.BACKGROUND ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
                 message.streamType = streamType;
                 waitForResponse = true;
 
@@ -781,6 +789,12 @@ class RemotePlayer extends RemotePlayerInterface {
                     playbackPosition,
                     fcid: FCID
                 };
+                if (this._uiAvSyncIntervalMs !== undefined) {
+                    message.uiAvSyncIntervalMs = this._uiAvSyncIntervalMs;
+                }
+                if (this._abrAvSyncIntervalMs !== undefined) {
+                    message.abrAvSyncIntervalMs = this._abrAvSyncIntervalMs;
+                }
                 if (this._remotePlayerApiVersion >= 2) {
                     message.type = "remotePlayer.load";
                     message.class = "remotePlayer";
@@ -920,10 +934,11 @@ class RemotePlayer extends RemotePlayerInterface {
      * remotePlayer.play();
      * lifecycle.moveToBackground();
      *
+     * @param {boolean} [autoTune=false] Should be true when the play was triggered automatically by the app and not by a user action.
      * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg
      */
-    play(autoPlay = false) {
+    play(autoTune = false) {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call play() if remote player is not initialized");
         }
@@ -934,7 +949,7 @@ class RemotePlayer extends RemotePlayerInterface {
         }
 
         this._changePlayMode(true);
-        this._autoPlay = autoPlay;
+        this._autoTune = autoTune;
 
         if (this._isSetAudioInProgress) {
             sdkLogger.info("application requesting play during setAudioLanguage");
@@ -950,8 +965,13 @@ class RemotePlayer extends RemotePlayerInterface {
 
         // If seeking in progress, wait for seek to complete before playing
         if (this._isSeekingByApplication) {
-            sdkLogger.info("application requesting play during seek");
-            this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
+            if (this._inTransitionToForeground || lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND) {
+                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_UI");
+                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
+            } else {
+                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_ABR");
+                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
+            }
             return Promise.resolve(true);
         }
         /*
@@ -1083,24 +1103,30 @@ class RemotePlayer extends RemotePlayerInterface {
      * @throws {RemotePlayerError} If the player is not initialized or not loaded.
      **/
     selectAudioTrack(audioTrackId) {
+        return this._selectAudioTrack(audioTrackId, false);
+    }
+
+    _selectAudioTrack(audioTrackId, force = false) {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call selectAudioTrack() if remote player is not initialized");
         }
         if (this._loadMode !== this.LoadMode.LOADED) {
             throw new RemotePlayerError(6001, "Cannot call selectAudioTrack() if remote player is not loaded");
         }
-        let found = false;
-        const prevSelectedAudioTrack = this._selectedAudioTrack;
-        for (const track of this.getAudioTracks()) {
-            if (track.id === audioTrackId) {
-                found = true;
-                break;
+        if (!force) {
+            let found = false;
+            for (const track of this.getAudioTracks()) {
+                if (track.id === audioTrackId) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                sdkLogger.warn(`Invalid audioTrackId ${audioTrackId}`);
+                return Promise.resolve();
             }
         }
-        if (!found) {
-            sdkLogger.warn(`Invalid audioTrackId ${audioTrackId}`);
-            return Promise.resolve();
-        }
+        const prevSelectedAudioTrack = this._selectedAudioTrack;
         if (this._selectedAudioTrack === audioTrackId) {
             return Promise.resolve(); // Audio language already selected
         }
@@ -1117,6 +1143,12 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
+    async selectAudioLanguage(language, role="", accessibilityPurposeCode=this.AccessibilityPurposeCode.NONE) {
+        const trackId = this._generateSenzaTrackId(language, role, accessibilityPurposeCode);
+        return this._selectAudioTrack(trackId, true);
+    }
+
+
     /**
      * Handles the asynchronous selection of an audio track.
      * If the player is playing, it pauses before changing the track and resumes playback if necessary.
@@ -1210,6 +1242,11 @@ class RemotePlayer extends RemotePlayerInterface {
         return Promise.resolve(undefined);
     }
 
+    async selectTextLanguage(language, role="", accessibilityPurposeCode=this.AccessibilityPurposeCode.NONE) {
+        const trackId = this._generateSenzaTrackId(language, role, accessibilityPurposeCode);
+        return this._selectTextTrack(trackId, true);
+    }
+
     /** Select a specific text (subtitle) track.
      * Track id should come from a call to getTextTracks.
      * If no tracks exist - this is a no-op.
@@ -1219,24 +1256,31 @@ class RemotePlayer extends RemotePlayerInterface {
      * @throws {RemotePlayerError} If the player is not initialized or not loaded.
      * */
     selectTextTrack(textTrackId) {
+        return this._selectTextTrack(textTrackId, false);
+    }
+
+    _selectTextTrack(textTrackId, force = false) {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call selectTextTrack() if remote player is not initialized");
         }
         if (this._loadMode !== this.LoadMode.LOADED) {
             throw new RemotePlayerError(6001, "Cannot call selectTextTrack() if remote player is not loaded");
         }
-        let found = false;
-        const prevSelectedTextTrack = this._selectedSubtitlesTrack;
-        for (const track of this.getTextTracks()) {
-            if (track.id === textTrackId) {
-                found = true;
-                break;
+        if (!force) {
+            let found = false;
+            for (const track of this.getTextTracks()) {
+                if (track.id === textTrackId) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                sdkLogger.warn(`Invalid textTrackId ${textTrackId}`);
+                return Promise.resolve();
             }
         }
-        if (!found) {
-            sdkLogger.warn(`Invalid textTrackId ${textTrackId}`);
-            return Promise.resolve();
-        }
+
+        const prevSelectedTextTrack = this._selectedSubtitlesTrack;
         if (this._selectedSubtitlesTrack === textTrackId) {
             return Promise.resolve(); // Subtitle language already selected
         }
@@ -1512,6 +1556,8 @@ class RemotePlayer extends RemotePlayerInterface {
      * @private
      */
     async _startSeeking(playbackPosition) {
+        const backgroundSeekMinClientAppVersion = "25.27.8";
+
         if (this._isSetAudioInProgress || this._isSetSubtitlesInProgress) {
             sdkLogger.info("Seeking not supported while setAudioLanguage or setSubtitleLanguage are in progress.");
             return;
@@ -1527,10 +1573,12 @@ class RemotePlayer extends RemotePlayerInterface {
                 return;
             }
         }
-
-        // Only allow seeking in foreground. Still ignore the initialized local player seeking event above
-        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication &&
-            (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND)) {
+        const backgroundSeekSupported = isAppVersionAboveOrEqual(this._deviceAppVersion, backgroundSeekMinClientAppVersion);
+        if (!backgroundSeekSupported && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+            sdkLogger.warn(`Seeking: background seek not supported for device app version: ${this._deviceAppVersion}`);
+        }
+        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication
+            && (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND || backgroundSeekSupported)) {
             this._atomicSeek();
         } else {
             sdkLogger.info(`Seeking: skipping seeking event to currentTime: ${playbackPosition}, internalSeek: ${this._isSeekingByPlatform}, localPlayerSeek: ${this._isSeekingByApplication}, state: ${lifecycle.state}`);
@@ -1549,16 +1597,16 @@ class RemotePlayer extends RemotePlayerInterface {
      * */
     async _atomicSeek() {
         sdkLogger.info("Seeking: local video element seeking start while isPlaying: ", this._isPlaying);
-
-        // Initialize the target playing state unless changed during the seek process
-        // In the future, we should allow for seeking in background. Currently, there's no
-        // way to know when the web application will call moveToForeground (i.e Before/After seek)
-        // Therefore, for now, we will assume the target is either paused or playing in ui unless
-        // specifically receiving a moveToBackground during the process.
-        // if (this._isPlaying && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
-        //     this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-        // }
-        this._targetSeekPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        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;
+        }
 
         // The platform could be currently syncing audio/video using playback rate. Reset when performing seek.
         if (this._videoElement) {
@@ -1625,14 +1673,13 @@ class RemotePlayer extends RemotePlayerInterface {
 
         // If in TargetPlayingState.PAUSE, no need to resume.
         // Resume without awaiting to avoid blocking the seek process anymore
-        // In case where we aborted, we don't want to resume playback.
+        // In case where we aborted (new load or unload called), we don't want to resume playback.
         if (!this._abortSeeking) {
             if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_UI) {
-                if (!this._isAudioSyncEnabled()) {
-                    return Promise.resolve(true);
+                // When in foreground back from ABR, we are considered playing. But, if AIU is not enabled, we shouldn't resume it.
+                if (this._isAudioSyncEnabled()) {
+                    this._play(StreamType.AUDIO);
                 }
-                // resume audio play only if _isAudioSyncEnabled
-                this._play(StreamType.AUDIO);
             } else if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
                 lifecycle._moveToBackground();
             }
@@ -1776,6 +1823,12 @@ class RemotePlayer extends RemotePlayerInterface {
         return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
     }
 
+    _generateSenzaTrackId(language, role, accessibilityPurpose) {
+        const l = language || "";
+        const r = role || "";
+        const ap = accessibilityPurpose || "";
+        return `${l}:${r}:${ap}`;
+    }
     _setScreenBlackout(blackoutTime) {
         if (window.cefQuery) {
             const FCID = getFCID();