senza-sdk 4.2.49 → 4.2.51-00bf04a.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.2.49",
+    "version": "4.2.51-00bf04a.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",

package/src/remotePlayer.js

@@ -9,7 +9,9 @@ import {
     SeekState,
     TargetPlayingState,
     isSubtitlesTranslationAllowed,
-    isSubtitlesTranslationPattern
+    isSubtitlesTranslationPattern,
+    SetAudioLanguageState,
+    SetSubtitleLanguageState
 } from "./utils";
 import { lifecycle } from "./lifecycle";
 import { writeLicenseResponse } from "./api";
@@ -586,7 +588,7 @@ class RemotePlayer extends EventTarget {
                     currentFramePTS: metadata.mediaTime.toString(),
                     ptsSessionId: this._ptsSessionId
                 };
-                const request = {target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message)};
+                const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
                 window.cefQuery({
                     request: JSON.stringify(request),
                     persistent: false
@@ -890,6 +892,8 @@ class RemotePlayer extends EventTarget {
             if (this._loadMode === this.LoadMode.LOADING || this._loadMode === this.LoadMode.UNLOADING) {
                 throw new RemotePlayerError(6501, "Cannot call load() while previous load/unload is still in progress");
             }
+            this._abortSetAudioLanguage = true;
+            this._abortSetSubtitleLanguage = true;
             this._abortSeeking = true;
             if (reset) {
                 this._reset();
@@ -1063,6 +1067,18 @@ class RemotePlayer extends EventTarget {
             }
         }
 
+        if (this._isSetAudioByApplication) {
+            sdkLogger.info("application requesting play during setAudioLanguage");
+            this._targetSetAudioPlayingState = TargetPlayingState.PLAYING_UI;
+            return Promise.resolve(true);
+        }
+
+        if (this._isSetSubtitleByApplication) {
+            sdkLogger.info("application requesting play during setSubtitleLanguage");
+            this._targetSetSubtitlePlayingState = TargetPlayingState.PLAYING_UI;
+            return Promise.resolve(true);
+        }
+
         // If seeking in progress, wait for seek to complete before playing
         if (this._isSeekingByApplication) {
             sdkLogger.info("application requesting play during seek");
@@ -1102,6 +1118,16 @@ class RemotePlayer extends EventTarget {
             this._targetSeekPlayingState = TargetPlayingState.PAUSED;
             return Promise.resolve(true);
         }
+        if (this._isSetAudioByApplication) {
+            sdkLogger.info("application requesting pause during setAudioLanguage");
+            this._targetSetAudioPlayingState = TargetPlayingState.PAUSED;
+            return Promise.resolve(true);
+        }
+        if (this._isSetSubtitleByApplication) {
+            sdkLogger.info("application requesting pause during setSubtitleLanguage");
+            this._targetSetSubtitlePlayingState = TargetPlayingState.PAUSED;
+            return Promise.resolve(true);
+        }
         return this._pause();
     }
 
@@ -1189,7 +1215,6 @@ class RemotePlayer extends EventTarget {
         const prevSelectedAudioTrack = this._selectedAudioTrack;
         for (const track of this.getAudioTracks()) {
             if (track.id === audioTrackId) {
-                this._selectedAudioTrack = audioTrackId;
                 found = true;
                 break;
             }
@@ -1198,19 +1223,34 @@ class RemotePlayer extends EventTarget {
             sdkLogger.warn(`Invalid audioTrackId ${audioTrackId}`);
             return Promise.resolve();
         }
-        if (this._remotePlayerApiVersion < 2) {
-            return Promise.resolve(); // Resolve immediately for older versions
-        }
-        if (prevSelectedAudioTrack === this._selectedAudioTrack) {
+        if (this._selectedAudioTrack === audioTrackId) {
             return Promise.resolve(); // Audio language already selected
         }
 
-        return this._selectAudioTrack(audioTrackId, prevSelectedAudioTrack);
+        switch (this._remotePlayerApiVersion) {
+        case 0:
+        case 1:
+            this._selectedAudioTrack = audioTrackId;
+            return Promise.resolve(); // Resolve immediately for older versions
+        case 2:
+            return this._selectAudioTrackV2(audioTrackId, prevSelectedAudioTrack);
+        default:
+            this._pendingAudioLanguage = audioTrackId;
+            return this._atomicSetAudioLanguage();
+        }
     }
 
-    async _selectAudioTrack(audioTrackId, prevSelectedAudioTrack) {
+    /**
+     * Handles the asynchronous selection of an audio track.
+     * If the player is playing, it pauses before changing the track and resumes playback if necessary.
+     *
+     * @param {string} audioTrackId - The ID of the audio track to select.
+     * @param {string} prevSelectedAudioTrack - The previously selected audio track ID.
+     * @returns {Promise<void>} Resolves when the operation is complete.
+     * */
+    async _selectAudioTrackV2(audioTrackId, prevSelectedAudioTrack) {
         const prevIsPlaying = this._isPlaying;
-        sdkLogger.log(`remotePlayer _selectAudioTrack: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying}`);
+        sdkLogger.log(`remotePlayer _selectAudioTrackV2: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying}`);
         try {
             if (this._isPlaying) await this.pause();
             let position = this.currentTime;
@@ -1218,9 +1258,9 @@ class RemotePlayer extends EventTarget {
                 position = this._videoElement.currentTime;
             }
             await this._load(this._loadedUrl, position, audioTrackId, undefined, false);
+            this._selectedAudioTrack = audioTrackId;
         } catch (e) {
-            // Do NOT reject - just log and revert selection
-            this._selectedAudioTrack = prevSelectedAudioTrack;
+            // Do NOT reject - just log
             sdkLogger.warn(`Failed to select audio track ${audioTrackId}: ${e.message}`);
             return;
         }
@@ -1237,6 +1277,63 @@ class RemotePlayer extends EventTarget {
         }
     }
 
+    /**
+     * Handles the asynchronous selection of an audio track.
+     * If the player is playing, it stops subtitle streamType before changing the track and resumes subtitle streamType playback if necessary.
+     * Available only from v3 and on
+     *
+     * @param {string} audioTrackId - The ID of the audio track to select.
+     * @param {string} prevSelectedAudioTrack - The previously selected audio track ID.
+     * @returns {Promise<void>} Resolves when the operation is complete.
+     * */
+    async _selectAudioTrackV3(audioTrackId, prevSelectedAudioTrack) {
+        sdkLogger.log(`remotePlayer _selectAudioTrackV3: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying}`);
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            logger.log("remotePlayer _selectAudioTrackV3: sending setAudioLanguage action");
+            const message = {
+                type: "remotePlayer.setAudioLanguage",
+                class: "remotePlayer",
+                action: "setAudioLanguage",
+                fcid: FCID,
+                language: audioTrackId,
+            };
+            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: () => {
+                        this._selectedAudioTrack = audioTrackId;
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`setAudioLanguage completed successfully after ${duration} ms`);
+                        timerId = clearTimer(timerId);
+                        resolve();
+                    },
+                    onFailure: (code, msg) => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`setAudioLanguage failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                        timerId = clearTimer(timerId);
+                        reject(new RemotePlayerError(code, msg));
+                    }
+                });
+                logger.log(`window.cefQuery for setAudioLanguage returned query id ${queryId}`);
+                const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                timerId = setTimeout(() => {
+                    logger.log(`setAudioLanguage reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new RemotePlayerError(6000, `setAudioLanguage reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+
+        sdkLogger.error("remotePlayer _selectAudioTrackV3: window.cefQuery is undefined");
+        return Promise.resolve(undefined);
+    }
+
     /** Select a specific text (subtitle) track.
      * Track id should come from a call to getTextTracks.
      * If no tracks exist - this is a no-op.
@@ -1256,7 +1353,6 @@ class RemotePlayer extends EventTarget {
         const prevSelectedTextTrack = this._selectedSubtitlesTrack;
         for (const track of this.getTextTracks()) {
             if (track.id === textTrackId) {
-                this._selectedSubtitlesTrack = textTrackId;
                 found = true;
                 break;
             }
@@ -1265,14 +1361,21 @@ class RemotePlayer extends EventTarget {
             sdkLogger.warn(`Invalid textTrackId ${textTrackId}`);
             return Promise.resolve();
         }
-        if (this._remotePlayerApiVersion < 2) {
-            return Promise.resolve(); // Resolve immediately for older versions
-        }
-        if (prevSelectedTextTrack === this._selectedSubtitlesTrack) {
+        if (this._selectedSubtitlesTrack === textTrackId) {
             return Promise.resolve(); // Subtitle language already selected
         }
 
-        return this._selectTextTrack(textTrackId, prevSelectedTextTrack);
+        switch (this._remotePlayerApiVersion) {
+        case 0:
+        case 1:
+            this._selectedSubtitlesTrack = textTrackId;
+            return Promise.resolve(); // Resolve immediately for older versions
+        case 2:
+            return this._selectTextTrackV2(textTrackId, prevSelectedTextTrack);
+        default:
+            this._pendingSubtitleLanguage = textTrackId;
+            return this._atomicSetSubtitleLanguage();
+        }
     }
 
     /**
@@ -1283,9 +1386,9 @@ class RemotePlayer extends EventTarget {
      * @param {string} prevSelectedTextTrack - The previously selected text track ID.
      * @returns {Promise<void>} Resolves when the operation is complete.
      * */
-    async _selectTextTrack(textTrackId, prevSelectedTextTrack) {
+    async _selectTextTrackV2(textTrackId, prevSelectedTextTrack) {
         const prevIsPlaying = this._isPlaying;
-        sdkLogger.log(`remotePlayer _selectTextTrack: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying}`);
+        sdkLogger.log(`remotePlayer _selectTextTrackV2: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying}`);
         try {
             if (this._isPlaying) await this.pause();
             let position = this.currentTime;
@@ -1293,9 +1396,9 @@ class RemotePlayer extends EventTarget {
                 position = this._videoElement.currentTime;
             }
             await this._load(this._loadedUrl, position, undefined, textTrackId, false);
+            this._selectedSubtitlesTrack = textTrackId;
         } catch (e) {
-            // Do NOT reject - just log and revert selection
-            this._selectedSubtitlesTrack = prevSelectedTextTrack;
+            // Do NOT reject - just log
             sdkLogger.warn(`Failed to select text track ${textTrackId}: ${e.message}`);
             return;
         }
@@ -1312,6 +1415,65 @@ class RemotePlayer extends EventTarget {
         }
     }
 
+    /**
+     * Handles the asynchronous selection of a text track.
+     * If the player is playing, it stops subtitle streamType before changing the track and resumes subtitle streamType playback if necessary.
+     * Available only from v3 and on
+     *
+     * @param {string} textTrackId - The ID of the text track to select.
+     * @param {string} prevSelectedTextTrack - The previously selected text track ID.
+     * @returns {Promise<void>} Resolves when the operation is complete.
+     * */
+    async _selectTextTrackV3(textTrackId, prevSelectedTextTrack) {
+        sdkLogger.log(`remotePlayer _selectTextTrackV3: prevAudioTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying}`);
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            logger.log("remotePlayer _selectTextTrackV3: sending setSubtitleLanguage action");
+            const message = {
+                type: "remotePlayer.setSubtitleLanguage",
+                class: "remotePlayer",
+                action: "setSubtitleLanguage",
+                fcid: FCID,
+                language: textTrackId,
+            };
+            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: () => {
+                        this._selectedSubtitlesTrack = textTrackId;
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`setSubtitleLanguage completed successfully after ${duration} ms`);
+                        timerId = clearTimer(timerId);
+                        resolve();
+                    },
+                    onFailure: (code, msg) => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`setSubtitleLanguage failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                        timerId = clearTimer(timerId);
+                        reject(new RemotePlayerError(code, msg));
+                    }
+                });
+                logger.log(`window.cefQuery for setSubtitleLanguage returned query id ${queryId}`);
+                const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                timerId = setTimeout(() => {
+                    logger.log(`setSubtitleLanguage reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new RemotePlayerError(6000, `setSubtitleLanguage reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+        sdkLogger.error("remotePlayer _selectAudioTrackV3: window.cefQuery is undefined");
+        return Promise.resolve(undefined);
+
+
+    }
+
+
     /**
      * Enable or disable the subtitles.
      * If the player is in an unloaded state, the request will be applied next time content is played.
@@ -1538,6 +1700,274 @@ class RemotePlayer extends EventTarget {
         this._isSeekingByApplication = false;
         sdkLogger.info("Seeking: local video element seeking end");
     }
+
+    async _stopAudio() {
+        if (window.cefQuery) {
+            if (this._remotePlayerApiVersion >= 2) {
+                return new Promise((resolve, reject) => {
+                    const FCID = getFCID();
+                    const logger = sdkLogger.withFields({ FCID });
+                    logger.log(`remotePlayer _stopAudio: sending stop action remotePlayer._isPlaying=${remotePlayer._isPlaying}`);
+                    const message = {
+                        type: "remotePlayer.stop",
+                        class: "remotePlayer",
+                        action: "stop",
+                        streamType: StreamType.AUDIO,
+                        fcid: FCID
+                    };
+                    let timerId = 0;
+                    const timeBeforeSendingRequest = Date.now();
+                    const queryId = window.cefQuery({
+                        request: JSON.stringify({ target: "TC", waitForResponse: true, internalAction: "uiActive", message: JSON.stringify(message) }),
+                        persistent: false,
+                        onSuccess: () => {
+                            const duration = Date.now() - timeBeforeSendingRequest;
+                            logger.withFields({ duration }).log(`stop audio completed successfully after ${duration} ms`);
+                            this._inTransition = false;
+                            timerId = clearTimer(timerId);
+                            resolve(true);
+                        },
+                        onFailure: (code, msg) => {
+                            const duration = Date.now() - timeBeforeSendingRequest;
+                            logger.withFields({ duration }).log(`stop audio failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                            this._inTransition = false;
+                            timerId = clearTimer(timerId);
+                            reject(new SenzaError(code, msg));
+                        }
+                    });
+                    logger.log(`window.cefQuery for stop audio returned query id ${queryId}`);
+                    const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                    timerId = setTimeout(() => {
+                        logger.log(`stop audio reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                        this._inTransition = false;
+                        window.cefQueryCancel(queryId);
+                        reject(new SenzaError(6000, `stop audio reached timeout of ${timeout} ms`));
+                    }, timeout, queryId);
+                });
+            }
+        }
+
+    }
+
+    async _stopSubtitle() {
+        if (window.cefQuery) {
+            if (this._remotePlayerApiVersion >= 2) {
+                return new Promise((resolve, reject) => {
+                    const FCID = getFCID();
+                    const logger = sdkLogger.withFields({ FCID });
+                    logger.log(`remotePlayer _stopSubtitle: sending stop action remotePlayer._isPlaying=${remotePlayer._isPlaying}`);
+                    const message = {
+                        type: "remotePlayer.stop",
+                        class: "remotePlayer",
+                        action: "stop",
+                        streamType: StreamType.SUBTITLE,
+                        fcid: FCID
+                    };
+                    let timerId = 0;
+                    const timeBeforeSendingRequest = Date.now();
+                    const queryId = window.cefQuery({
+                        request: JSON.stringify({ target: "TC", waitForResponse: true, internalAction: "uiActive", message: JSON.stringify(message) }),
+                        persistent: false,
+                        onSuccess: () => {
+                            const duration = Date.now() - timeBeforeSendingRequest;
+                            logger.withFields({ duration }).log(`stop subtitle completed successfully after ${duration} ms`);
+                            this._inTransition = false;
+                            timerId = clearTimer(timerId);
+                            resolve(true);
+                        },
+                        onFailure: (code, msg) => {
+                            const duration = Date.now() - timeBeforeSendingRequest;
+                            logger.withFields({ duration }).log(`stop subtitle failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                            this._inTransition = false;
+                            timerId = clearTimer(timerId);
+                            reject(new SenzaError(code, msg));
+                        }
+                    });
+                    logger.log(`window.cefQuery for stop returned query id ${queryId}`);
+                    const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                    timerId = setTimeout(() => {
+                        logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                        window.cefQueryCancel(queryId);
+                        reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
+                    }, timeout, queryId);
+                });
+            }
+        }
+        
+    }
+
+    async _playSubtitle() {
+        if (window.cefQuery) {
+            if (this._remotePlayerApiVersion >= 2) {
+                return new Promise((resolve, reject) => {
+                    const FCID = getFCID();
+                    const logger = sdkLogger.withFields({ FCID });
+                    logger.log("remotePlayer play subtitle: sending play action");
+                    const configuration = remotePlayer.getConfiguration();
+                    const subtitlesLanguage = remotePlayer.textTrackVisibility && (remotePlayer._selectedSubtitlesTrack || configuration.preferredSubtitlesLanguage) || "";
+                    let request;
+                    const message = {
+                        action: "play",
+                        fcid: FCID,
+                        subtitlesLanguage
+                    };
+                    if (this._remotePlayerApiVersion >= 2) {
+                        message.type = "remotePlayer.play";
+                        message.class = "remotePlayer";
+                        message.streamType = StreamType.SUBTITLE;
+                        request = {
+                            target: "TC",
+                            waitForResponse: true,
+                            internalAction: "uiExit",
+                            message: JSON.stringify(message)
+                        };
+                    } else {
+                        request = message;
+                    }
+                    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(`play subtitle completed successfully after ${duration} ms`);
+                            this._inTransition = false;
+                            timerId = clearTimer(timerId);
+                            resolve();
+                        },
+                        onFailure: (code, msg) => {
+                            const duration = Date.now() - timeBeforeSendingRequest;
+                            logger.withFields({ duration }).log(`play subtitle failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                            this._inTransition = false;
+                            timerId = clearTimer(timerId);
+                            reject(new SenzaError(code, msg));
+                        }
+                    });
+                    if (this._remotePlayerApiVersion >= 2) {
+                        logger.log(`window.cefQuery for play subtitle returned query id ${queryId}`);
+                        const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                        timerId = setTimeout(() => {
+                            logger.log(`play subtitle reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                            this._inTransition = false;
+                            window.cefQueryCancel(queryId);
+                            reject(new SenzaError(6000, `play subtitle reached timeout of ${timeout} ms`));
+                        }, timeout, queryId);
+                    }
+                });
+            }
+
+        }
+        sdkLogger.error("remotePlayer play subtitle: window.cefQuery is undefined");
+        return Promise.resolve(undefined);
+    }
+
+    async _atomicSetSubtitleLanguage() {
+        sdkLogger.info("SetSubtitleLanguage: local video element set start while isPLaying=", this._isPlaying);
+
+        this._targetSetSubtitlePlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        this._abortSetSubtitleLanguage = false;
+        this._isSetSubtitleByApplication = true;
+
+        let state = SetSubtitleLanguageState.INIT;
+
+        let previousPendingSubtitleLanguage = this._pendingSubtitleLanguage;
+        let initialSubtitleLanguage = this._pendingSubtitleLanguage;
+        let res;
+
+        while (!this._abortSetSubtitleLanguage && state !== SetSubtitleLanguageState.DONE) {
+            try {
+                switch(state) {
+                case SetSubtitleLanguageState.INIT:
+                    sdkLogger.info("BEFORE STOP BEFORE SET SUBTITLE");
+                    await this._stopSubtitle();
+                    sdkLogger.info("AFTER STOP BEFORE SET SUBTITLE");
+                    state = SetSubtitleLanguageState.SET;
+                    break;
+                case SetSubtitleLanguageState.STOPPED:
+                    state = SetSubtitleLanguageState.SET;
+                    break;
+                case SetSubtitleLanguageState.SET:
+                    initialSubtitleLanguage = this._pendingSubtitleLanguage;
+                    previousPendingSubtitleLanguage = this._selectedSubtitleTrack;
+                    res = await this._selectTextTrackV3(initialSubtitleLanguage, previousPendingSubtitleLanguage);
+                    sdkLogger.info("BEFORE PLAY AFTER SET SUBTITLE 1");
+                    state = SetSubtitleLanguageState.DONE;
+                    break;
+                }
+            } catch (error) {
+                sdkLogger.info(`Error during set subtitle process: ${error.message}`);
+                state = SetSubtitleLanguageState.DONE;
+                res = Promise.reject(error);
+            }
+        }
+
+        if (!this._abortSetSubtitleLanguage) {
+            sdkLogger.info("TARGET PLAYING STATE", this._targetSetSubtitlePlayingState);
+            sdkLogger.info("TEXT TRACK VISIBILITY", this._textTrackVisibility);
+            if (this._targetSetSubtitlePlayingState === TargetPlayingState.PLAYING_UI) {
+                sdkLogger.info("BEFORE PLAY AFTER SET SUBTITLE 2");
+                this._playSubtitle();
+            }
+        }
+        this._isSetSubtitleByApplication = false;
+        sdkLogger.info("SetSubtitleLanguage: local video element set subtitle end");
+        return res
+    }
+
+    async _atomicSetAudioLanguage() {
+        sdkLogger.info("SetAudioLanguage: local video element set start while isPLaying=", this._isPlaying);
+
+        this._targetSetAudioPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        this._abortSetAudioLanguage = false;
+        this._isSetAudioByApplication = true;
+
+        let state = SetAudioLanguageState.INIT;
+
+        let previousPendingAudioLanguage = this._pendingAudioLanguage;
+        let initialAudioLanguage= this._pendingAudioLanguage;
+        let res;
+        
+        while (!this._abortSetAudioLanguage && state !== SetAudioLanguageState.DONE) {
+            try {
+
+                switch(state) {
+                case SetAudioLanguageState.INIT:
+                    sdkLogger.info("BEFORE STOP BEFORE SET AUDIO");
+                    await this._stopAudio();
+                    sdkLogger.info("AFTER STOP BEFORE SET AUDIO");
+                    state = SetAudioLanguageState.SET;
+                    break;
+                case SetAudioLanguageState.STOPPED:
+                    state = SetAudioLanguageState.SET;
+                    break;
+                case SetAudioLanguageState.SET:
+                    initialAudioLanguage = this._pendingAudioLanguage;
+                    previousPendingAudioLanguage = this._selectedAudioTrack;
+                    res = await this._selectAudioTrackV3(initialAudioLanguage, previousPendingAudioLanguage);
+                    sdkLogger.info("BEFORE PLAY AFTER SET AUDIO 1");
+                    state = SetAudioLanguageState.DONE;
+                    break;
+                }
+            } catch (error) {
+                sdkLogger.info(`Error during set audio process: ${error.message}`);
+                state = SetAudioLanguageState.DONE;
+                res = Promise.reject(error);
+            }
+        }
+
+        if (!this._abortSetAudioLanguage) {
+            sdkLogger.info("TARGET PLAYING STATE", this._targetSetAudioPlayingState);
+            if (this._targetSetAudioPlayingState === TargetPlayingState.PLAYING_UI) {
+                sdkLogger.info("BEFORE PLAY AFTER SET AUDIO 2");
+                this._play();
+            }
+        }
+
+        this._isSetAudioByApplication = false;
+        sdkLogger.info("SetAudioLanguage: local video element set audio end");
+        return res
+    }
 }
 /**
  *

package/src/senzaShakaPlayer.js

@@ -1,5 +1,5 @@
 import * as shaka from "shaka-player";
-import { remotePlayer, lifecycle } from "./api";
+import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
 import { sdkLogger, iso6393to1 } from "./utils";
 
 //  Define custom error category
@@ -386,6 +386,18 @@ export class SenzaShakaPlayer extends shaka.Player {
             ]);
         };
 
+        // For live streams, we can set a default offset from the live edge
+        // This allows for synchronizing the start position for both local and remote players
+        // Note: For VOD content, negative start times are treated as 0
+        const { defaultInitialLiveOffset, minInitialLiveOffset } = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"] || {};
+        if ((startTime === undefined || startTime === 0) && defaultInitialLiveOffset !== undefined) {
+            sdkLogger.debug(`load() was called with startTime=${startTime}, setting startTime to ${-defaultInitialLiveOffset}`);
+            startTime = -defaultInitialLiveOffset;
+        } else if (startTime <= 0 && minInitialLiveOffset !== undefined && startTime > -minInitialLiveOffset) {
+            sdkLogger.debug(`load() was called with startTime=${startTime}, setting startTime to ${-minInitialLiveOffset}`);
+            startTime = -minInitialLiveOffset;
+        }
+
         if (!this.isInRemotePlayback || remotePlayer.getAssetUri() !== url) {
             this._audioTracksMap = {};
             this._videoTracksMap = {};

package/src/utils.js

@@ -155,6 +155,24 @@ export const TargetPlayingState = Object.freeze({
     PLAYING_ABR: "playingAbr"
 });
 
+export const SetAudioLanguageState = Object.freeze({
+    INIT: "init",
+    STOPPED: "stopped",
+    SET: "set",
+    MULTI_SET: "multiSet",
+    WAITING: "waiting",
+    DONE: "done"
+});
+
+export const SetSubtitleLanguageState = Object.freeze({
+    INIT: "init",
+    STOPPED: "stopped",
+    SET: "set",
+    MULTI_SET: "multiSet",
+    WAITING: "waiting",
+    DONE: "done"
+});
+
 export const iso6393to1 = {
     "aar": "aa",
     "abk": "ab",