senza-sdk 4.4.4 → 4.4.6

package/src/implementation/lifecycle.js

@@ -17,9 +17,15 @@ import { DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT, remotePlayer } from "./remo
 import {bus, Events} from "./eventBus";
 
 // Default values for autoBackground settings. These values are used if the UIStreamer settings are not provided.
-const DEFAULT_AUTO_BACKGROUND_VIDEO_DELAY = 30;
-const DEFAULT_AUTO_BACKGROUND_UI_DELAY = -1;
-const DEFAULT_AUTO_BACKGROUND_ENABLED = false;
+const DEFAULT_AUTO_BACKGROUND_VIDEO_DELAY = 10*60;
+const DEFAULT_AUTO_BACKGROUND_UI_DELAY = 10*60;
+const DEFAULT_AUTO_BACKGROUND_ENABLED = true;
+// Default values for autoSuspend settings
+const DEFAULT_AUTO_SUSPEND_ENABLED = false;
+const DEFAULT_AUTO_SUSPEND_PLAYING_DELAY = 60;
+const DEFAULT_AUTO_SUSPEND_IDLE_DELAY = 60;
+// Session storage key for tracking timer-triggered background state
+const BACKGROUND_TIMER_KEY = "senzaSDK_backgroundTriggeredByTimer";
 
 class Lifecycle extends LifecycleInterface {
     constructor() {
@@ -60,8 +66,89 @@ class Lifecycle extends LifecycleInterface {
          * @private
          */
         this._autoBackgroundOnUIDelay = DEFAULT_AUTO_BACKGROUND_UI_DELAY;
+
+        /**
+         * Timestamp of the last user activity
+         * @type {number}
+         * @private
+         */
+        this._lastActivityTimestamp = Date.now();
+
+        /**
+         * Auto suspend configuration
+         * @type {Object}
+         * @private
+         */
+        this._autoSuspend = {
+            enabled: DEFAULT_AUTO_SUSPEND_ENABLED,
+            timeout: {
+                playing: DEFAULT_AUTO_SUSPEND_PLAYING_DELAY,
+                idle: DEFAULT_AUTO_SUSPEND_IDLE_DELAY
+            }
+        };
+
+        /**
+         * Timer for auto suspend functionality
+         * @type {number|null}
+         * @private
+         */
+        this._suspendCountdown = null;
+
+        /**
+         * Timestamp when the application entered background state
+         * @type {number}
+         * @private
+         */
+        this._backgroundTimestamp = Date.now();
+
+        /**
+         * Flag to track if suspend was triggered by timer
+         * @type {boolean}
+         * @private
+         */
+        this._isSuspendTriggeredByTimer = false;
+
+    }
+
+    /**
+     * @private Gets the background triggered by timer flag from sessionStorage
+     * @returns {boolean}
+     */
+    get _isBackgroundTriggeredByTimer() {
+        try {
+            const value = typeof window !== "undefined" && window.sessionStorage ?
+                window.sessionStorage.getItem(BACKGROUND_TIMER_KEY) : null;
+            return value === "true";
+        } catch (error) {
+            sdkLogger.warn("Failed to read _isBackgroundTriggeredByTimer from sessionStorage:", error);
+            return false;
+        }
     }
 
+    /**
+     * @private Sets the background triggered by timer flag in sessionStorage
+     * @param {boolean} value
+     */
+    set _isBackgroundTriggeredByTimer(value) {
+        try {
+            if (typeof window !== "undefined" && window.sessionStorage) {
+                if (value) {
+                    window.sessionStorage.setItem(BACKGROUND_TIMER_KEY, "true");
+                } else {
+                    window.sessionStorage.removeItem(BACKGROUND_TIMER_KEY);
+                }
+            }
+        } catch (error) {
+            sdkLogger.warn("Failed to write _backgroundTriggeredByTimer to sessionStorage:", error);
+        }
+    }
+
+    // List of event types that should use the _eventManager
+    static _waitForListenersEvents = [
+        "userdisconnected","beforestatechange"
+        // Add more event types here if needed in the future
+    ];
+
     /**
      * @private Initialize the lifecycle
      * @param {Object} uiStreamerSettings - UI-streamer portion of the settings taken from session info
@@ -70,6 +157,11 @@ class Lifecycle extends LifecycleInterface {
      * @param {Object} [uiStreamerSettings.autoBackground.timeout] - Timeout settings
      * @param {number|false} [uiStreamerSettings.autoBackground.timeout.playing=30] - Timeout in seconds when video is playing, false to disable
      * @param {number|false} [uiStreamerSettings.autoBackground.timeout.idle=false] - Timeout in seconds when in UI mode, false to disable
+     * @param {Object} [uiStreamerSettings.autoSuspend] - Auto suspend mode configuration
+     * @param {boolean} [uiStreamerSettings.autoSuspend.enabled=false] - Enable/disable auto suspend
+     * @param {Object} [uiStreamerSettings.autoSuspend.timeout] - Timeout settings
+     * @param {number} [uiStreamerSettings.autoSuspend.timeout.playing=60] - Timeout in seconds when video is playing
+     * @param {number} [uiStreamerSettings.autoSuspend.timeout.idle=60] - Timeout in seconds when in idle mode
      * @param {number} [uiStreamerSettings.remotePlayerConfirmationTimeout=5000] - Timeout in milliseconds for remote player operations
      * @param {number} [uiStreamerSettings.remotePlayerApiVersion=1] - Remote player API version
      */
@@ -165,6 +257,13 @@ class Lifecycle extends LifecycleInterface {
                     autoBackground: uiStreamerSettings.autoBackground
                 });
             }
+
+            // Apply autoSuspend settings if provided
+            if (uiStreamerSettings?.autoSuspend) {
+                this.configure({
+                    autoSuspend: uiStreamerSettings.autoSuspend
+                });
+            }
         }
     }
 
@@ -177,9 +276,20 @@ class Lifecycle extends LifecycleInterface {
             const event = new Event("onstatechange");
             event.state = e.detail;
             this._state = event.state;
-            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
+            if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
                 this._startCountdown();
             }
+            // Track timestamp when entering background state
+            if (this._state === this.UiState.BACKGROUND) {
+                this._backgroundTimestamp = Date.now();
+            }
+            // Start suspend countdown when entering background state
+            if (this._isAutoSuspendEnabled() && this._state === this.UiState.BACKGROUND) {
+                this._startSuspendCountdown();
+            } else {
+                // Stop suspend countdown when leaving background state
+                this._stopSuspendCountdown();
+            }
             this.dispatchEvent(event);
         });
 
@@ -201,9 +311,14 @@ class Lifecycle extends LifecycleInterface {
         });
 
         typeof document !== "undefined" && document.addEventListener("keydown", () => {
+            // Track the timestamp of the last user activity
+            this._lastActivityTimestamp = Date.now();
+
             if (this._isAutoBackgroundEnabled()) {
-                if (this.state === this.UiState.BACKGROUND ||
-                    this.state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+
+                if (this._isBackgroundTriggeredByTimer && (this.state === this.UiState.BACKGROUND ||
+                    this.state === this.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+                    sdkLogger.log("Moving to foreground due to user interaction after auto background");
                     this.moveToForeground();
                 } else {
                     this._startCountdown();
@@ -213,14 +328,27 @@ class Lifecycle extends LifecycleInterface {
 
         // Add playModeChange listener
         remotePlayer.addEventListener("playModeChange", (event) => {
-            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
+            if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
                 sdkLogger.log("Resetting auto background timer due to play mode change", event.detail.isPlaying);
                 this._startCountdown(event.detail.isPlaying);
             }
+            // Also restart suspend countdown if in background state
+            if (this._isAutoSuspendEnabled() && this._state === this.UiState.BACKGROUND) {
+                sdkLogger.log("Resetting auto suspend timer due to play mode change", event.detail.isPlaying);
+                this._startSuspendCountdown(event.detail.isPlaying);
+            }
         });
         sdkLogger.log("[Lifecycle] Added event listeners for system events");
     }
 
+    /**
+     * @private Checks if the UI is in foreground or transitioning to foreground.
+     * @returns {boolean}
+     */
+    _isForegroundOrTransitioning() {
+        return this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND;
+    }
+
     /**
      * @private Checks if auto background is enabled including overrides.
      * @returns {boolean}
@@ -253,6 +381,30 @@ class Lifecycle extends LifecycleInterface {
         return this._autoBackgroundOnUIDelay;
     }
 
+    /**
+     * @private Checks if auto suspend is enabled.
+     * @returns {boolean}
+     */
+    _isAutoSuspendEnabled() {
+        return this._autoSuspend.enabled;
+    }
+
+    /**
+     * @private Gets the auto suspend playing delay.
+     * @returns {number}
+     */
+    _getAutoSuspendOnPlayingDelay() {
+        return this._autoSuspend.timeout.playing;
+    }
+
+    /**
+     * @private Gets the auto suspend idle delay.
+     * @returns {number}
+     */
+    _getAutoSuspendOnIdleDelay() {
+        return this._autoSuspend.timeout.idle;
+    }
+
     configure(config) {
         if (config?.autoBackground) {
             const { enabled, timeout } = config.autoBackground;
@@ -284,12 +436,45 @@ class Lifecycle extends LifecycleInterface {
             }
 
             // Start or stop countdown based on new configuration
-            if (this._isAutoBackgroundEnabled()) {
+            if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
                 this._startCountdown();
             } else {
                 this._stopCountdown();
             }
         }
+
+        if (config?.autoSuspend) {
+            const { enabled, timeout } = config.autoSuspend;
+
+            // Update enabled state
+            if (typeof enabled === "boolean") {
+                this._autoSuspend.enabled = enabled;
+            }
+            // Update timeouts
+            if (timeout) {
+                if (timeout.playing !== undefined) {
+                    if (typeof timeout.playing === "number") {
+                        this._autoSuspend.timeout.playing = timeout.playing;
+                    } else {
+                        sdkLogger.warn("Invalid autoSuspend.timeout.playing value, expected number");
+                    }
+                }
+                if (timeout.idle !== undefined) {
+                    if (typeof timeout.idle === "number") {
+                        this._autoSuspend.timeout.idle = timeout.idle;
+                    } else {
+                        sdkLogger.warn("Invalid autoSuspend.timeout.idle value, expected number");
+                    }
+                }
+            }
+
+            // Start or stop suspend countdown based on new configuration
+            if (this._isAutoSuspendEnabled() && this._state === this.UiState.BACKGROUND) {
+                this._startSuspendCountdown();
+            } else {
+                this._stopSuspendCountdown();
+            }
+        }
     }
 
     getConfiguration() {
@@ -300,6 +485,13 @@ class Lifecycle extends LifecycleInterface {
                     playing: this._autoBackgroundOnVideoDelay <= 0 ? false : this._autoBackgroundOnVideoDelay,
                     idle: this._autoBackgroundOnUIDelay <= 0 ? false : this._autoBackgroundOnUIDelay
                 }
+            },
+            autoSuspend: {
+                enabled: this._autoSuspend.enabled,
+                timeout: {
+                    playing: this._autoSuspend.timeout.playing,
+                    idle: this._autoSuspend.timeout.idle
+                }
             }
         };
     }
@@ -364,7 +556,7 @@ class Lifecycle extends LifecycleInterface {
 
     set autoBackground(enabled) {
         this._autoBackground = enabled;
-        if (this._isAutoBackgroundEnabled()) {
+        if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
             this._startCountdown();
         } else {
             this._stopCountdown();
@@ -377,7 +569,7 @@ class Lifecycle extends LifecycleInterface {
 
     set autoBackgroundDelay(delay) {
         this._autoBackgroundOnVideoDelay = delay;
-        if (this._isAutoBackgroundEnabled() && remotePlayer._isPlaying) {
+        if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning() && remotePlayer._isPlaying) {
             this._startCountdown();
         }
     }
@@ -388,7 +580,7 @@ class Lifecycle extends LifecycleInterface {
 
     set autoBackgroundOnUIDelay(delay) {
         this._autoBackgroundOnUIDelay = delay;
-        if (this._isAutoBackgroundEnabled() && !remotePlayer._isPlaying) {
+        if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning() && !remotePlayer._isPlaying) {
             this._startCountdown();
         }
     }
@@ -408,9 +600,25 @@ class Lifecycle extends LifecycleInterface {
         // Only start countdown if delay is positive
         if (timeoutDelay > 0) {
             sdkLogger.debug("Starting countdown timeout", timeoutDelay, isPlaying ? "(video)" : "(UI)");
-            this._countdown = setTimeout(() => {
+            this._countdown = setTimeout(async () => {
                 sdkLogger.debug("Countdown timeout reached, moving to background");
-                this.moveToBackground();
+
+                // Create the event with cancelable: true
+                const event = new Event("beforestatechange", { cancelable: true });
+                event.state = this.UiState.BACKGROUND;
+                // Use the event manager to dispatch the event and wait for all listeners
+                await this._eventManager.dispatch("beforestatechange", event);
+                // Check if any listener called preventDefault()
+                if (event.defaultPrevented) {
+                    sdkLogger.info("moveToBackground was prevented by a listener");
+                    // Restart the countdown since the move was cancelled
+                    if (this._isForegroundOrTransitioning()) {
+                        this._startCountdown();
+                    }
+                } else {
+                    this.moveToBackground(true);
+                }
+
             }, timeoutDelay * 1000);
         } else {
             sdkLogger.debug("Countdown not started - delay is negative or zero");
@@ -424,8 +632,70 @@ class Lifecycle extends LifecycleInterface {
         if (this._countdown) {
             sdkLogger.debug("Stopping countdown timer");
             clearTimeout(this._countdown);
+            this._countdown = null;
+        }
+    }
+
+    /**
+    * @private Start the suspend countdown timer when in background state
+    */
+    _startSuspendCountdown(isPlaying = remotePlayer._isPlaying) {
+        this._stopSuspendCountdown();
+
+        // Only start if we're in background state and auto suspend is enabled
+        if (this._state !== this.UiState.BACKGROUND || !this._isAutoSuspendEnabled()) {
+            return;
+        }
+
+        const timeoutDelay = isPlaying ? this._getAutoSuspendOnPlayingDelay() : this._getAutoSuspendOnIdleDelay();
+
+        // Only start countdown if delay is positive
+        if (timeoutDelay > 0) {
+            sdkLogger.debug("Starting suspend countdown timeout", timeoutDelay, isPlaying ? "(playing)" : "(idle)");
+            this._suspendCountdown = setTimeout(async () => {
+                sdkLogger.debug("Suspend countdown timeout reached, moving to suspended");
+                if (this._state === this.UiState.BACKGROUND) {
+                    // Create the event with cancelable: true
+                    const event = new Event("beforestatechange", { cancelable: true });
+                    event.state = this.UiState.SUSPENDED;
+                    // Use the event manager to dispatch the event and wait for all listeners
+                    await this._eventManager.dispatch("beforestatechange", event);
+                    // Check if any listener called preventDefault()
+                    if (event.defaultPrevented) {
+                        sdkLogger.info("moveToSuspended was prevented by a listener");
+                        // Restart the suspend countdown since the move was cancelled
+                        this._startSuspendCountdown();
+                    } else {
+                        try {
+                        // Set flag to indicate suspend was triggered by timer
+                            this._isSuspendTriggeredByTimer = true;
+                            await this.moveToSuspended();
+                        } catch (error) {
+                            sdkLogger.error("Failed to move to suspended:", error);
+                        }
+                    }
+
+                } else {
+                    sdkLogger.warn("suspend timer was called while not in background");
+                }
+
+            }, timeoutDelay * 1000);
+        } else {
+            sdkLogger.debug("Suspend countdown not started - delay is zero or negative");
+        }
+    }
+
+    /**
+    * @private Stop the suspend countdown timer
+    */
+    _stopSuspendCountdown() {
+        if (this._suspendCountdown) {
+            sdkLogger.debug("Stopping suspend countdown timer");
+            clearTimeout(this._suspendCountdown);
+            this._suspendCountdown = null;
+            // Reset the timer flag when stopping countdown
+            this._isSuspendTriggeredByTimer = false;
         }
-        this._countdown = null;
     }
 
     /**
@@ -457,9 +727,15 @@ class Lifecycle extends LifecycleInterface {
     }
 
     moveToForeground() {
+        // Reset activity timestamp when moving to foreground
+        this._lastActivityTimestamp = Date.now();
+
+        // Clear the timer-triggered background flag when moving to foreground
+        this._isBackgroundTriggeredByTimer = false;
+
         if (window.cefQuery) {
             const inTransition = this._isInTransition();
-            if (inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
+            if (inTransition || this._isForegroundOrTransitioning()) {
                 sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${inTransition}`);
                 return Promise.resolve(false);
             }
@@ -537,6 +813,16 @@ class Lifecycle extends LifecycleInterface {
     }
 
     _moveToBackground() {
+        // Report metrics for time since last user activity when moving to background
+
+        const duration = (Date.now() - this._lastActivityTimestamp)/1000;
+
+        sdkLogger.metrics({
+            type: "backgroundTransitions",
+            isAutoBackground: this._isBackgroundTriggeredByTimer,
+            isPlaying: remotePlayer._isPlaying,
+            duration
+        });
         if (window.cefQuery) {
             // If audio sync is disabled, we only need to sync before remote player starts playing
             if (!isAudioSyncConfigured()) {
@@ -600,6 +886,8 @@ class Lifecycle extends LifecycleInterface {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
                         this._inTransitionToBackground = false;
+                        // Clear the timer flag even if the transition fails
+                        this._isBackgroundTriggeredByTimer = false;
                         timerId = clearTimer(timerId);
                         reject(new SenzaError(code, msg));
                     }
@@ -610,6 +898,8 @@ class Lifecycle extends LifecycleInterface {
                     timerId = setTimeout(() => {
                         logger.log(`play reached timeout of ${timeout} ms, canceling query id ${queryId}`);
                         this._inTransitionToBackground = false;
+                        // Clear the timer flag even if the transition times out
+                        this._isBackgroundTriggeredByTimer = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `play reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -620,7 +910,11 @@ class Lifecycle extends LifecycleInterface {
         return Promise.resolve(false);
     }
 
-    moveToBackground() {
+    moveToBackground(isTriggeredByTimer = false) {
+
+        // If the background transition is triggered by the auto background timer, set the flag
+        this._isBackgroundTriggeredByTimer = isTriggeredByTimer;
+
         if (window.cefQuery) {
             const inTransition = this._isInTransition();
             if (inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
@@ -771,23 +1065,73 @@ class Lifecycle extends LifecycleInterface {
         return Promise.reject("disconnect is not supported if NOT running e2e");
     }
 
+    moveToSuspended() {
+        // Check if the current state is BACKGROUND
+        if (this._state !== this.UiState.BACKGROUND) {
+            const errorMsg = `moveToSuspended can only be called from BACKGROUND state. Current state: ${this._state}`;
+            sdkLogger.error(errorMsg);
+            return Promise.reject(errorMsg);
+        }
+
+        // Report metrics for time between background and suspend
+        const duration = (Date.now() - this._backgroundTimestamp) / 1000;
+
+        sdkLogger.metrics({
+            type: "suspendTransitions",
+            isAutoSuspend: this._isSuspendTriggeredByTimer,
+            isPlaying: remotePlayer._isPlaying,
+            duration
+        });
+
+        // Reset the timer flag after reporting metrics
+        const reason = this._isSuspendTriggeredByTimer ? "timer" : "appInitiated";
+        this._isSuspendTriggeredByTimer = false;
+
+        if (window.cefQuery) {
+            return new Promise((resolve, reject) => {
+                const FCID = getFCID();
+                const logger = sdkLogger.withFields({ FCID });
+                const message = {
+                    type: "suspend",
+                    reason,
+                    fcid: FCID
+                };
+                const request = { target: "TC",
+                    waitForResponse: false,
+                    message: JSON.stringify(message) };
+
+                logger.log("moveToSuspended: sending suspend message");
+                window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: () => {
+                        logger.log("moveToSuspended request successfully sent");
+                        resolve(true);
+                    },
+                    onFailure: (code, msg) => {
+                        logger.error(`moveToSuspended failed: ${code} ${msg}`);
+                        reject(new SenzaError(code, msg));
+                    }
+                });
+            });
+        }
+        sdkLogger.warn("moveToSuspended is not supported if NOT running e2e");
+        return Promise.reject("moveToSuspended is not supported if NOT running e2e");
+    }
+
+
     addEventListener(type, listener, options) {
-        if (type === "userdisconnected") {
-            // Use the event manager for userdisconnected events
+        if (Lifecycle._waitForListenersEvents.includes(type)) {
             this._eventManager.addEventListener(type, listener);
         } else {
-            // For all other event types, use the parent class implementation
             super.addEventListener(type, listener, options);
         }
     }
 
-
     removeEventListener(type, listener, options) {
-        if (type === "userdisconnected") {
-            // Use the event manager for userdisconnected events
+        if (Lifecycle._waitForListenersEvents.includes(type)) {
             this._eventManager.removeEventListener(type, listener);
         } else {
-            // For all other event types, use the parent class implementation
             super.removeEventListener(type, listener, options);
         }
     }

package/src/interface/lifecycle.js

@@ -13,6 +13,23 @@ import {
  * });
  */
 
+/**
+ * @event Lifecycle#beforestatechange
+ * @description Fired before transitioning to a new state. This event is cancelable.<br>
+ * Currently only fired when transitioning to BACKGROUND state (e.g., from autoBackground feature).<br>
+ * The actual state transition will occur after all event listeners have completed processing.
+ * Can be used to prevent automatic transitions to background state when using autoBackground feature.
+ * @property {UiState} state - Indicates the target state the lifecycle is trying to transition to.
+ * @property {boolean} cancelable - true, indicating the event can be cancelled using preventDefault()
+ * @example
+ * lifecycle.addEventListener("beforestatechange", (e) => {
+ *     if (e.state === lifecycle.UiState.BACKGROUND && userIsInteracting) {
+ *         // Prevent transition to background
+ *         e.preventDefault();
+ *     }
+ * });
+ */
+
 /**
  * @event Lifecycle#userinactivity
  * @description Fired after the ui has been inactive (i.e. no key presses) for a configurable number of seconds.<br>
@@ -83,10 +100,15 @@ class Lifecycle extends EventTarget {
      * Configure lifecycle settings
      * @param {Object} config - Configuration object
      * @param {Object} [config.autoBackground] - Auto background settings
-     * @param {boolean} [config.autoBackground.enabled] - Enable/disable auto background
+     * @param {boolean} [config.autoBackground.enabled=true] - Enable/disable auto background
      * @param {Object} [config.autoBackground.timeout] - Timeout settings
      * @param {number|false} [config.autoBackground.timeout.playing=30] - Timeout in seconds when video is playing, false to disable
-     * @param {number|false} [config.autoBackground.timeout.idle=false] - Timeout in seconds when in UI mode, false to disable
+     * @param {number|false} [config.autoBackground.timeout.idle=30] - Timeout in seconds when in UI mode, false to disable
+     * @param {Object} [config.autoSuspend] - Auto suspend settings
+     * @param {boolean} [config.autoSuspend.enabled=false] - Enable/disable auto suspend
+     * @param {Object} [config.autoSuspend.timeout] - Timeout settings
+     * @param {number} [config.autoSuspend.timeout.playing=60] - Timeout in seconds when video is playing before moving to suspended state
+     * @param {number} [config.autoSuspend.timeout.idle=60] - Timeout in seconds when in background mode before moving to suspended state
      */
     configure(config) {
         noop("lifecycle.configure", config);
@@ -97,9 +119,12 @@ class Lifecycle extends EventTarget {
      * @returns {Object} The current configuration object
      * @example
      * const config = lifecycle.getConfiguration();
-     * console.log(config.autoBackground.enabled); // true/false
+     * console.log(config.autoBackground.enabled); // true
      * console.log(config.autoBackground.timeout.playing); // 30
-     * console.log(config.autoBackground.timeout.idle); // false
+     * console.log(config.autoBackground.timeout.idle); // 30
+     * console.log(config.autoSuspend.enabled); // false
+     * console.log(config.autoSuspend.timeout.playing); // 60
+     * console.log(config.autoSuspend.timeout.idle); // 60
      */
     getConfiguration() {
         return {
@@ -109,6 +134,13 @@ class Lifecycle extends EventTarget {
                     playing: 0,
                     idle: 0
                 }
+            },
+            autoSuspend: {
+                enabled: false,
+                timeout: {
+                    playing: 0,
+                    idle: 0
+                }
             }
         };
     }
@@ -262,10 +294,21 @@ class Lifecycle extends EventTarget {
         return noop("lifecycle.disconnect");
     }
 
+    /**
+     * Use this api to move the application to suspended state.
+     * This method can only be called when the application is in BACKGROUND state.
+     * @return {Promise} Promise which is resolved when the suspend command has been successfully sent.
+     * Failure to process the suspend command will result in the promise being rejected.
+    * @alpha API has not yet been released
+    */
+    moveToSuspended() {
+        return noop("lifecycle.moveToSuspended");
+    }
+
     /**
      * Add event listener for lifecycle events
      * @param {string} type - The event type to listen for
-     * @param {Function} listener - The callback function. Listeners for 'userdisconnected' events should return a promise to ensure the event is processed before the application exits.
+     * @param {Function} listener - The callback function. Listeners for 'userdisconnected' and 'beforestatechange' events should return a promise to ensure the event is processed before the application exits.
      * @param {Object} options - Event listener options
      */
     addEventListener(type, listener, options) {

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.4.4";
+export const version = "4.4.6";