senza-sdk 4.2.55-3686561.0 → 4.2.55-5e1095e.0

package/package.json

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

package/src/lifecycle.js

@@ -710,15 +710,24 @@ class Lifecycle extends EventTarget {
      * Failure to process the moveToBackground command will result in the promise being rejected.
      */
     moveToBackground() {
-        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);
-                }
+        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) {
                 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

@@ -715,10 +715,8 @@ class RemotePlayer extends EventTarget {
             };
             let waitForResponse = false;
             if (this._remotePlayerApiVersion >= 2) {
-                if (this._isAudioSyncEnabled()) {
-                    message.switchMode = SwitchMode.SEAMLESS;
-                    message.streamType = streamType;
-                }
+                message.switchMode = this._isAudioSyncEnabled() ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
+                message.streamType = streamType;
                 waitForResponse = true;
             }
             const request = { target: "TC", waitForResponse: waitForResponse, message: JSON.stringify(message) };
@@ -1626,6 +1624,11 @@ 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;
 
@@ -1756,6 +1759,10 @@ class RemotePlayer extends EventTarget {
             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}`);
@@ -1763,48 +1770,54 @@ class RemotePlayer extends EventTarget {
         this._abortSetAudioLanguage = false;
         this._isSetAudioInProgress = true;
 
-        let res;
-        let isStopped = false; // flag to call play if selectAudioV3 fails
-
         try {
             await this._stop(StreamType.AUDIO);
             if (this._abortSetAudioLanguage) {
                 this._isSetAudioInProgress = false;
                 sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} aborted.`);
-                return res;
+                return Promise.resolve();
             }
-            isStopped = true;
         } catch (error) {
             this._isSetAudioInProgress = false;
             sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} failed on stop. aborting.`);
             return Promise.reject(error);
         }
 
+        let setLanguageError;
         try {
-            res = await this._selectAudioTrackV3(audioTrackId);
-            if (this._abortSetAudioLanguage) {
-                this._isSetAudioInProgress = false;
-                sdkLogger.warn(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} aborted.`);
-                return res;
-            }
+            await this._selectAudioTrackV3(audioTrackId);
         } catch (error) {
             sdkLogger.error(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} failed with error ${error.message}.`);
-            res = Promise.reject(error);
+            if (!this._abortSetAudioLanguage) {
+                setLanguageError = error;
+            }
         }
 
-        if (this._targetSetAudioPlayingState !== TargetPlayingState.PAUSED && isStopped) {
-            try {
+        // 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);
-            } catch (error) {
-                this._isSetAudioInProgress = false;
-                sdkLogger.error(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} failed to play with error ${error.message}.`);
-                return Promise.reject(error);
+            } 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 res;
+        return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
     }
 
     async _atomicSetSubtitleLanguage(textTrackId, prevSelectedTextTrack) {
@@ -1812,6 +1825,10 @@ class RemotePlayer extends EventTarget {
             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}`);
@@ -1819,47 +1836,54 @@ class RemotePlayer extends EventTarget {
         this._abortSetSubtitleLanguage = false;
         this._isSetSubtitlesInProgress = true;
 
-        let res;
-        let isStopped = false;
         try {
             await this._stop(StreamType.SUBTITLE);
             if (this._abortSetSubtitleLanguage) {
                 this._isSetSubtitlesInProgress = false;
                 sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} aborted.`);
-                return res;
+                return Promise.resolve();
             }
-            isStopped = true;
         } catch (error) {
             this._isSetSubtitlesInProgress = false;
             sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} failed on stop. aborting.`);
             return Promise.reject(error);
         }
 
+        let setLanguageError;
         try {
-            res = await this._selectTextTrackV3(textTrackId);
-            if (this._abortSetSubtitleLanguage) {
-                this._isSetSubtitlesInProgress = false;
-                sdkLogger.warn(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} aborted.`);
-                return res;
-            }
+            await this._selectTextTrackV3(textTrackId);
         } catch (error) {
             sdkLogger.error(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} failed with error ${error.message}.`);
-            res = Promise.reject(error);
+            if (!this._abortSetSubtitleLanguage) {
+                setLanguageError = error;
+            }
         }
 
-        if (this._targetSetSubtitlePlayingState !== TargetPlayingState.PAUSED && isStopped) {
-            try {
-                await this._play(StreamType.SUBTITLE | StreamType.AUDIO);
-            } catch (error) {
-                this._isSetSubtitlesInProgress = false;
-                sdkLogger.error(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} failed to play with error ${error.message}.`);
-                return Promise.reject(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 res;
+        return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
     }
 
 }