senza-sdk 4.2.53 → 4.2.54-c5f8bb3.0

package/package.json

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

package/src/lifecycle.js

@@ -551,6 +551,10 @@ class Lifecycle extends EventTarget {
             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 });
@@ -618,10 +622,6 @@ class Lifecycle extends EventTarget {
 
     _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();
@@ -710,12 +710,12 @@ 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);
             }

package/src/remotePlayer.js

@@ -1454,15 +1454,15 @@ class RemotePlayer extends EventTarget {
     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.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                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) {
@@ -1529,11 +1529,13 @@ class RemotePlayer extends EventTarget {
 
         // 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) {
                 this._play();
             } else if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
+                // When moving back to background, we need to put the remote player back into play mode
+                this._changePlayMode(true);
                 lifecycle._moveToBackground();
             }
         }