senza-sdk 4.2.55-e39d067.0 → 4.2.55

package/package.json

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

package/src/lifecycle.js

@@ -710,24 +710,15 @@ class Lifecycle extends EventTarget {
      * Failure to process the moveToBackground command will result in the promise being rejected.
      */
     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 (remotePlayer._isSeekingByApplication) {
+        if (remotePlayer._isSeekingByApplication) {
+            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);
+                }
                 remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
                 return Promise.resolve(true);
             }
-            if (remotePlayer._isSetSubtitlesInProgress) {
-                remotePlayer._targetSetSubtitlePlayingState = TargetPlayingState.PLAYING_ABR;
-                return Promise.resolve(true);
-            }
-            if (remotePlayer._isSetAudioInProgress) {
-                remotePlayer._targetSetAudioPlayingState = TargetPlayingState.PLAYING_ABR;
-                return Promise.resolve(true);
-            }
         }
         return this._moveToBackground();
     }

package/src/remotePlayer.js

@@ -694,7 +694,7 @@ class RemotePlayer extends EventTarget {
         return Promise.resolve(undefined);
     }
 
-    _play(streamType) {
+    _play() {
         if (window.cefQuery) {
             const FCID = getFCID();
             const logger = sdkLogger.withFields({ FCID });
@@ -714,10 +714,16 @@ class RemotePlayer extends EventTarget {
                 playbackPosition: this.currentTime
             };
             let waitForResponse = false;
+            this._changePlayMode(true);
             if (this._remotePlayerApiVersion >= 2) {
-                message.switchMode = this._isAudioSyncEnabled() ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
-                message.streamType = streamType;
-                waitForResponse = true;
+                if (this._isAudioSyncEnabled()) {
+                    message.switchMode = SwitchMode.SEAMLESS;
+                    message.streamType = StreamType.AUDIO;
+                    waitForResponse = true;
+                } else {
+                    logger.log("remotePlayer play request ignored and will be sent with the lifecycle.moveToBackground()");
+                    return Promise.resolve();
+                }
             }
             const request = { target: "TC", waitForResponse: waitForResponse, message: JSON.stringify(message) };
             return new Promise((resolve, reject) => {
@@ -756,6 +762,7 @@ class RemotePlayer extends EventTarget {
 
     _pause() {
         if (window.cefQuery) {
+            this._changePlayMode(false);
             const isForegroundState = lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND;
             if (this._remotePlayerApiVersion >= 2 && !this._isAudioSyncEnabled() && isForegroundState) {
                 sdkLogger.info("remotePlayer pause: application in foreground, remote player is not playing.");
@@ -809,51 +816,6 @@ class RemotePlayer extends EventTarget {
         return Promise.resolve(undefined);
     }
 
-    _stop(streamType) {
-        if (window.cefQuery) {
-            const FCID = getFCID();
-            const logger = sdkLogger.withFields({ FCID });
-            logger.log(`remotePlayer stop: sending stop action for streamType ${streamType}`);
-            const message = {
-                type: "remotePlayer.stop",
-                class: "remotePlayer",
-                action: "stop",
-                streamType: streamType,
-                fcid: FCID
-            };
-            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(`stop completed successfully after ${duration} ms`);
-                        timerId = clearTimer(timerId);
-                        resolve();
-                    },
-                    onFailure: (code, msg) => {
-                        const duration = Date.now() - timeBeforeSendingRequest;
-                        logger.withFields({ duration }).log(`stop failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                        timerId = clearTimer(timerId);
-                        reject(new RemotePlayerError(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 RemotePlayerError(6000, `stop reached timeout of ${timeout} ms`));
-                }, timeout, queryId);
-            });
-        }
-        sdkLogger.error("remotePlayer stop: window.cefQuery is undefined");
-        return Promise.resolve(undefined);
-    }
-
     /** In order to support a seamless switch between the video in the UI and ABR, the web application must
      * register the video element being used for the currently played video before calling the load and play apis.
      * @param {object} video The video element currently playing video in the web application
@@ -929,8 +891,6 @@ 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();
@@ -1104,20 +1064,6 @@ class RemotePlayer extends EventTarget {
             }
         }
 
-        this._changePlayMode(true);
-
-        if (this._isSetAudioInProgress) {
-            sdkLogger.info("application requesting play during setAudioLanguage");
-            this._targetSetAudioPlayingState = TargetPlayingState.PLAYING_UI;
-            return Promise.resolve(true);
-        }
-
-        if (this._isSetSubtitlesInProgress) {
-            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");
@@ -1132,13 +1078,7 @@ class RemotePlayer extends EventTarget {
                 this._seek(this._videoElement.currentTime, false);
             }
         }*/
-
-        if (this._remotePlayerApiVersion >= 2 && !this._isAudioSyncEnabled()) {
-            sdkLogger.info("play was called but _isAudioSyncEnabled is disabled, ignoring.");
-            return Promise.resolve(true);
-        }
-
-        return this._play(StreamType.AUDIO);
+        return this._play();
     }
 
     /** Pauses the currently playing audio or video
@@ -1158,24 +1098,11 @@ class RemotePlayer extends EventTarget {
                 throw new RemotePlayerError(6001, "Cannot call pause() if player is not loaded");
             }
         }
-
-        this._changePlayMode(false);
-
         if (this._isSeekingByApplication) {
             sdkLogger.info("application requesting pause during seek");
             this._targetSeekPlayingState = TargetPlayingState.PAUSED;
             return Promise.resolve(true);
         }
-        if (this._isSetAudioInProgress) {
-            sdkLogger.info("application requesting pause during setAudioLanguage");
-            this._targetSetAudioPlayingState = TargetPlayingState.PAUSED;
-            return Promise.resolve(true);
-        }
-        if (this._isSetSubtitlesInProgress) {
-            sdkLogger.info("application requesting pause during setSubtitleLanguage");
-            this._targetSetSubtitlePlayingState = TargetPlayingState.PAUSED;
-            return Promise.resolve(true);
-        }
         return this._pause();
     }
 
@@ -1263,6 +1190,7 @@ class RemotePlayer extends EventTarget {
         const prevSelectedAudioTrack = this._selectedAudioTrack;
         for (const track of this.getAudioTracks()) {
             if (track.id === audioTrackId) {
+                this._selectedAudioTrack = audioTrackId;
                 found = true;
                 break;
             }
@@ -1271,33 +1199,19 @@ class RemotePlayer extends EventTarget {
             sdkLogger.warn(`Invalid audioTrackId ${audioTrackId}`);
             return Promise.resolve();
         }
-        if (this._selectedAudioTrack === audioTrackId) {
+        if (this._remotePlayerApiVersion < 2) {
+            return Promise.resolve(); // Resolve immediately for older versions
+        }
+        if (prevSelectedAudioTrack === this._selectedAudioTrack) {
             return Promise.resolve(); // Audio language already selected
         }
 
-        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:
-            return this._atomicSetAudioLanguage(audioTrackId, prevSelectedAudioTrack);
-        }
+        return this._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) {
+    async _selectAudioTrack(audioTrackId, prevSelectedAudioTrack) {
         const prevIsPlaying = this._isPlaying;
-        sdkLogger.log(`remotePlayer _selectAudioTrackV2: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying}`);
+        sdkLogger.log(`remotePlayer _selectAudioTrack: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying}`);
         try {
             if (this._isPlaying) await this.pause();
             let position = this.currentTime;
@@ -1305,9 +1219,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
+            // Do NOT reject - just log and revert selection
+            this._selectedAudioTrack = prevSelectedAudioTrack;
             sdkLogger.warn(`Failed to select audio track ${audioTrackId}: ${e.message}`);
             return;
         }
@@ -1324,62 +1238,6 @@ class RemotePlayer extends EventTarget {
         }
     }
 
-    /**
-     * Handles the asynchronous selection of an audio track.
-     * If the player is playing, it stops audio streamType before changing the track and resumes audio streamType playback if necessary.
-     * Available only from v3 and on
-     *
-     * @param {string} audioTrackId - The ID of the audio track to select.
-     * @returns {Promise<void>} Resolves when the operation is complete.
-     * */
-    async _selectAudioTrackV3(audioTrackId) {
-        sdkLogger.log(`remotePlayer _selectAudioTrackV3: 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.
@@ -1399,6 +1257,7 @@ class RemotePlayer extends EventTarget {
         const prevSelectedTextTrack = this._selectedSubtitlesTrack;
         for (const track of this.getTextTracks()) {
             if (track.id === textTrackId) {
+                this._selectedSubtitlesTrack = textTrackId;
                 found = true;
                 break;
             }
@@ -1407,20 +1266,14 @@ class RemotePlayer extends EventTarget {
             sdkLogger.warn(`Invalid textTrackId ${textTrackId}`);
             return Promise.resolve();
         }
-        if (this._selectedSubtitlesTrack === textTrackId) {
+        if (this._remotePlayerApiVersion < 2) {
+            return Promise.resolve(); // Resolve immediately for older versions
+        }
+        if (prevSelectedTextTrack === this._selectedSubtitlesTrack) {
             return Promise.resolve(); // Subtitle language already selected
         }
 
-        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:
-            return this._atomicSetSubtitleLanguage(textTrackId, prevSelectedTextTrack);
-        }
+        return this._selectTextTrack(textTrackId, prevSelectedTextTrack);
     }
 
     /**
@@ -1431,9 +1284,9 @@ class RemotePlayer extends EventTarget {
      * @param {string} prevSelectedTextTrack - The previously selected text track ID.
      * @returns {Promise<void>} Resolves when the operation is complete.
      * */
-    async _selectTextTrackV2(textTrackId, prevSelectedTextTrack) {
+    async _selectTextTrack(textTrackId, prevSelectedTextTrack) {
         const prevIsPlaying = this._isPlaying;
-        sdkLogger.log(`remotePlayer _selectTextTrackV2: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying}`);
+        sdkLogger.log(`remotePlayer _selectTextTrack: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying}`);
         try {
             if (this._isPlaying) await this.pause();
             let position = this.currentTime;
@@ -1441,9 +1294,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
+            // Do NOT reject - just log and revert selection
+            this._selectedSubtitlesTrack = prevSelectedTextTrack;
             sdkLogger.warn(`Failed to select text track ${textTrackId}: ${e.message}`);
             return;
         }
@@ -1460,60 +1313,6 @@ 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.
-     * @returns {Promise<void>} Resolves when the operation is complete.
-     * */
-    async _selectTextTrackV3(textTrackId) {
-        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 _selectTextTrackV3: 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.
@@ -1624,11 +1423,6 @@ class RemotePlayer extends EventTarget {
      * @private
      */
     async _startSeeking(playbackPosition) {
-        if (this._isSetAudioInProgress || this._isSetSubtitlesInProgress) {
-            sdkLogger.info(`Seeking not supported while setAudioLanguage or setSubtitleLanguage are in progress.`);
-            return;
-        }
-
         if (!this._isSeekingByPlatform) {
             this._pendingSeekPosition = playbackPosition;
 
@@ -1740,11 +1534,7 @@ class RemotePlayer extends EventTarget {
         // In case where we aborted, we don't want to resume playback.
         if (!this._abortSeeking) {
             if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_UI) {
-                if (!this._isAudioSyncEnabled()) {
-                    return Promise.resolve(true);
-                }
-                // resume audio play only if _isAudioSyncEnabled
-                this._play(StreamType.AUDIO);
+                this._play();
             } else if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
                 lifecycle._moveToBackground();
             }
@@ -1753,139 +1543,6 @@ class RemotePlayer extends EventTarget {
         this._isSeekingByApplication = false;
         sdkLogger.info("Seeking: local video element seeking end");
     }
-
-    async _atomicSetAudioLanguage(audioTrackId, prevSelectedAudioTrack) {
-        if (this._isSetAudioInProgress) {
-            sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} already in progress, ignoring.`);
-            return Promise.resolve();
-        }
-        if (this._isSeekingByApplication) {
-            sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} ignored. seeking is already in progress.`);
-            return Promise.resolve();
-        }
-
-        this._targetSetAudioPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
-        sdkLogger.log(`remotePlayer _atomicSetAudioLanguage: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetAudioPlayingState}`);
-
-        this._abortSetAudioLanguage = false;
-        this._isSetAudioInProgress = true;
-
-        try {
-            await this._stop(StreamType.AUDIO);
-            if (this._abortSetAudioLanguage) {
-                this._isSetAudioInProgress = false;
-                sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} aborted.`);
-                return Promise.resolve();
-            }
-        } catch (error) {
-            this._isSetAudioInProgress = false;
-            sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} failed on stop. aborting.`);
-            return Promise.reject(error);
-        }
-
-        let setLanguageError;
-        try {
-            await this._selectAudioTrackV3(audioTrackId);
-        } catch (error) {
-            sdkLogger.error(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} failed with error ${error.message}.`);
-            if (!this._abortSetAudioLanguage) {
-                setLanguageError = error;
-            }
-        }
-
-        // check if load/unload were called
-        if (this._abortSetAudioLanguage) {
-            this._isSetAudioInProgress = false;
-            sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} aborted.`);
-            return Promise.resolve();
-        }
-
-        try {
-            if (this._targetSetAudioPlayingState === TargetPlayingState.PLAYING_UI) {
-                if (!this._isAudioSyncEnabled()) {
-                    this._isSetAudioInProgress = false;
-                    return Promise.resolve(true);
-                }
-                // resume audio play only if _isAudioSyncEnabled
-                await this._play(StreamType.AUDIO);
-            } else if (this._targetSetAudioPlayingState === TargetPlayingState.PLAYING_ABR) {
-                await lifecycle._moveToBackground();
-            }
-        } catch(error) {
-            sdkLogger.error(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} play failed with error ${error.message}.`);
-        }
-
-        this._isSetAudioInProgress = false;
-        sdkLogger.log(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} ended.`);
-        return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
-    }
-
-    async _atomicSetSubtitleLanguage(textTrackId, prevSelectedTextTrack) {
-        if (this._isSetSubtitlesInProgress) {
-            sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} already in progress., ignoring.`);
-            return Promise.resolve();
-        }
-        if (this._isSeekingByApplication) {
-            sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} ignored. seeking is already in progress.`);
-            return Promise.resolve();
-        }
-
-        this._targetSetSubtitlePlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
-        sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetSubtitlePlayingState}`);
-
-        this._abortSetSubtitleLanguage = false;
-        this._isSetSubtitlesInProgress = true;
-
-        try {
-            await this._stop(StreamType.SUBTITLE);
-            if (this._abortSetSubtitleLanguage) {
-                this._isSetSubtitlesInProgress = false;
-                sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} aborted.`);
-                return Promise.resolve();
-            }
-        } catch (error) {
-            this._isSetSubtitlesInProgress = false;
-            sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} failed on stop. aborting.`);
-            return Promise.reject(error);
-        }
-
-        let setLanguageError;
-        try {
-            await this._selectTextTrackV3(textTrackId);
-        } catch (error) {
-            sdkLogger.error(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} failed with error ${error.message}.`);
-            if (!this._abortSetSubtitleLanguage) {
-                setLanguageError = error;
-            }
-        }
-
-        // check if load/unload were called
-        if (this._abortSetSubtitleLanguage) {
-            this._isSetSubtitlesInProgress = false;
-            sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} aborted.`);
-            return Promise.resolve();
-        }
-
-        try {
-            if (this._targetSetSubtitlePlayingState === TargetPlayingState.PLAYING_UI) {
-                if (!this._isAudioSyncEnabled()) {
-                    this._isSetSubtitlesInProgress = false;
-                    return Promise.resolve(true);
-                }
-                // resume audio play only if _isAudioSyncEnabled
-                await this._play(StreamType.AUDIO);
-            } else if (this._targetSetSubtitlePlayingState === TargetPlayingState.PLAYING_ABR) {
-                await lifecycle._moveToBackground();
-            }
-        } catch (error) {
-            sdkLogger.error(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} play failed with error ${error.message}.`);
-        }
-
-        this._isSetSubtitlesInProgress = false;
-        sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} ended.`);
-        return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
-    }
-
 }
 /**
  *