senza-sdk 4.2.54-01d7afc.0 → 4.2.54-b92e464.0

package/package.json

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

package/src/lifecycle.js

@@ -102,9 +102,7 @@ class Lifecycle extends EventTarget {
          * @private
          */
         this._isInitialized = false;
-        this._inTransitionToForeground = false;
-        this._inTransitionToBackground = false;
-        this._inTransitionToStandby = false;
+        this._inTransition = false;
 
         /**
          * Event listeners manager for the userdisconnected event
@@ -351,7 +349,7 @@ class Lifecycle extends EventTarget {
     // This api is part of epic HSDEV-713
     _moveToUiStandby() {
         if (window.cefQuery) {
-            this._inTransitionToStandby = true;
+            this._inTransition = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const request = { target: "TC", waitForResponse: false, internalAction: "uiExit", message: JSON.stringify({ type: "uiStandbyRequest", fcid: FCID }) };
@@ -362,12 +360,12 @@ class Lifecycle extends EventTarget {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("[ moveToUiStandby ] moveToUiStandby successfully sent");
-                        this._inTransitionToStandby = false;
+                        this._inTransition = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
                         logger.error(`[ moveToUiStandby ] moveToUiStandby failed: ${code} ${msg}`);
-                        this._inTransitionToStandby = false;
+                        this._inTransition = false;
                         reject(`moveToUiStandby failed: ${code} ${msg}`);
                     }
                 });
@@ -503,14 +501,6 @@ class Lifecycle extends EventTarget {
         this._countdown = null;
     }
 
-    /**
-     * @private
-     */
-    _isInTransition() {
-        return this._inTransitionToForeground || this._inTransitionToBackground || this._inTransitionToStandby;
-    }
-
-
     /**
      * @deprecated use lifecycle.state instead.
      * Async function that returns the ui lifecycle state
@@ -553,19 +543,14 @@ class Lifecycle extends EventTarget {
      */
     moveToForeground() {
         if (window.cefQuery) {
-            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}`);
+            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}`);
                 return Promise.resolve(false);
             }
-            this._inTransitionToForeground = true;
+            this._inTransition = 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 });
@@ -585,14 +570,14 @@ class Lifecycle extends EventTarget {
                         onSuccess: () => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop completed successfully after ${duration} ms`);
-                            this._inTransitionToForeground = false;
+                            this._inTransition = 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._inTransitionToForeground = false;
+                            this._inTransition = false;
                             timerId = clearTimer(timerId);
                             reject(new SenzaError(code, msg));
                         }
@@ -601,7 +586,7 @@ class Lifecycle extends EventTarget {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -616,11 +601,11 @@ class Lifecycle extends EventTarget {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("uiActiveRequest successfully sent");
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         logger.error(`uiActiveRequest failed: ${code} ${msg}`);
                         reject(`uiActiveRequest failed: ${code} ${msg}`);
                     }
@@ -633,6 +618,10 @@ 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();
@@ -644,7 +633,7 @@ class Lifecycle extends EventTarget {
                 return this._moveToUiStandby();
             }
 
-            this._inTransitionToBackground = true;
+            this._inTransition = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const logger = sdkLogger.withFields({ FCID });
@@ -681,14 +670,14 @@ class Lifecycle extends EventTarget {
                     onSuccess: () => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play completed successfully after ${duration} ms`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = 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._inTransitionToBackground = false;
+                        this._inTransition = false;
                         timerId = clearTimer(timerId);
                         reject(new SenzaError(code, msg));
                     }
@@ -698,7 +687,7 @@ class Lifecycle extends EventTarget {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`play reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `play reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -721,13 +710,12 @@ class Lifecycle extends EventTarget {
      * Failure to process the moveToBackground command will result in the promise being rejected.
      */
     moveToBackground() {
-        if (window.cefQuery) {
-            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) {
+        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);
             }

package/src/remotePlayer.js

@@ -1428,16 +1428,18 @@ class RemotePlayer extends EventTarget {
 
             // If the local player is just initializing after loading the manifest, ignore the seeking event.
             if (this._localPlayerLoadCurrentTime === 0 && this._videoElement.currentTime - this._localPlayerLoadCurrentTime > ONE_DAY_SECONDS) {
-                sdkLogger.info(`Seeking ignored for video currentTime init: currentTime=${this._videoElement.currentTime} loadCurrentTime=${this._localPlayerLoadCurrentTime}`);
+                sdkLogger.info(`Seeking ignored for video currentTime init: currentTime: ${this._videoElement.currentTime}, loadCurrentTime: ${this._localPlayerLoadCurrentTime}`);
                 this._localPlayerLoadCurrentTime = this._videoElement.currentTime;
                 return;
             }
         }
 
-        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication) {
+        // 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)) {
             this._atomicSeek();
         } else {
-            sdkLogger.info(`Seeking: skipping seeking event to currentTime=${this._videoElement.currentTime} internalSeek=${this._isSeekingByPlatform} localPlayerSeek=${this._isSeekingByApplication}`);
+            sdkLogger.info(`Seeking: skipping seeking event to currentTime: ${playbackPosition}, internalSeek: ${this._isSeekingByPlatform}, localPlayerSeek: ${this._isSeekingByApplication}, state: ${lifecycle.state}`);
         }
     }
 
@@ -1452,17 +1454,17 @@ class RemotePlayer extends EventTarget {
      *  @private
      * */
     async _atomicSeek() {
-        sdkLogger.info("Seeking: local video element seeking start while isPLaying=", this._isPlaying);
-
-        if (this._isPlaying) {
-            if (!lifecycle._inTransitionToForeground && (lifecycle._inTransitionToBackground || 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;
-        }
+        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;
 
         // The platform could be currently syncing audio/video using playback rate. Reset when performing seek.
         if (this._videoElement) {
@@ -1529,13 +1531,11 @@ 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 (new load or unload called), we don't want to resume playback.
+        // In case where we aborted, 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();
             }
         }