senza-sdk 4.2.32 → 4.2.34

package/package.json

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

package/src/api.js

@@ -174,6 +174,8 @@ export async function init() {
                     triggerEvent.data = { eventName: originalTriggerEvent.eventName, payload: originalTriggerEvent.payload };
                 } else if (triggerEvent.type === "videoPlaybackEvent") {
                     triggerEvent.data = { eventCode: originalTriggerEvent.eventCode, errorCode: originalTriggerEvent.errorCode };
+                } else if (triggerEvent.type === "getLicense") {
+                    sdkLogger.info("The license request is available on the license-request event which is triggered after uiReady is called");
                 }
             } catch (e) {
                 sdkLogger.error(`failed to parse trigger event string ${triggerEventStr}: ${e.message}`);

package/src/lifecycle.js

@@ -12,6 +12,11 @@ import {
 import { sessionInfo } from "./SessionInfo";
 import { DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT, remotePlayer } from "./remotePlayer";
 
+// 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;
+
 /**
   * Lifecycle is a singleton class that manages the application lifecycle states.<br>
   * @fires onstatechange
@@ -69,13 +74,19 @@ class Lifecycle extends EventTarget {
          * @type {boolean}
          * @private
          */
-        this._autoBackground = false;
+        this._autoBackground = DEFAULT_AUTO_BACKGROUND_ENABLED;
 
         /**
          * @type {integer}
          * @private
          */
-        this._autoBackgroundDelay = 30;
+        this._autoBackgroundOnVideoDelay = DEFAULT_AUTO_BACKGROUND_VIDEO_DELAY;
+
+        /**
+         * @type {integer}
+         * @private
+         */
+        this._autoBackgroundOnUIDelay = DEFAULT_AUTO_BACKGROUND_UI_DELAY;
 
         typeof document !== "undefined" && document.addEventListener("hs/uistatechange", (e) => {
             sdkLogger.log("Got hs/uistatechange", e.detail);
@@ -105,9 +116,24 @@ class Lifecycle extends EventTarget {
                 }
             }
         });
+
+        // Add playModeChange listener
+        remotePlayer.addEventListener("playModeChange", (event) => {
+            if (this._autoBackground && this.state === this.UiState.FOREGROUND) {
+                sdkLogger.log("Resetting auto background timer due to play mode change", event.detail.isPlaying);
+                this._startCountdown(event.detail.isPlaying);
+            }
+        });
     }
 
     /** @private Initialize the lifecycle
+     * @param {Object} uiStreamerSettings - UI-streamer portion of the settings taken from session info
+     * @param {Object} [uiStreamerSettings.autoBackground] - Auto background mode configuration
+     * @param {boolean} [uiStreamerSettings.autoBackground.enable=false] - Whether auto background mode is enabled
+     * @param {number} [uiStreamerSettings.autoBackground.onVideoDelay=30] - Seconds of inactivity before moving to background while playing video
+     * @param {number} [uiStreamerSettings.autoBackground.onUIDelay=30] - Seconds of inactivity before moving to background while in UI (not playing)
+     * @param {number} [uiStreamerSettings.remotePlayerConfirmationTimeout=5000] - Timeout in milliseconds for remote player operations
+     * @param {number} [uiStreamerSettings.remotePlayerApiVersion=1] - Remote player API version
      */
     async _init(uiStreamerSettings) {
         if (window.cefQuery) {
@@ -128,6 +154,21 @@ class Lifecycle extends EventTarget {
             this._isInitialized = true;
             this._remotePlayerConfirmationTimeout = uiStreamerSettings?.remotePlayerConfirmationTimeout ?? DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT;
             this._remotePlayerApiVersion = uiStreamerSettings?.remotePlayerApiVersion || 1;
+
+            // Take autoBackground settings from uiStreamerSettings if available
+            // The UI setting section format :
+            // "autoBackground": {
+            //     "enable": true,
+            //     "onVideoDelay": 30,
+            //     "onUIDelay": 30
+            // }
+
+            this._autoBackgroundOnVideoDelay = uiStreamerSettings?.autoBackground?.onVideoDelay ?? this._autoBackgroundOnVideoDelay;
+            this._autoBackgroundOnUIDelay = uiStreamerSettings?.autoBackground?.onUIDelay ?? this._autoBackgroundOnUIDelay;
+            this._autoBackground = uiStreamerSettings?.autoBackground?.enable ?? this._autoBackground;
+            /*if (this._autoBackground) {
+                this._startCountdown();
+            }*/
         }
     }
 
@@ -177,7 +218,10 @@ class Lifecycle extends EventTarget {
 
     /**
      * Controls the autoBackground feature<br>
-     * When enabled, the application will automatically move to the background state after {@link Lifecycle#autoBackgroundDelay} seconds of inactivity and return to the foreground state when a key is pressed.
+     * When enabled, the application will automatically move to the background state after a configurable
+     * period of inactivity. The delay depends on whether video is playing ({@link Lifecycle#autoBackgroundDelay})
+     * or the UI is idle ({@link Lifecycle#autoBackgroundOnUIDelay}).
+     * The application will return to the foreground state when a key is pressed.
      * @type {boolean}
      */
     set autoBackground(enabled) {
@@ -194,30 +238,58 @@ class Lifecycle extends EventTarget {
     }
 
     /**
-     * the number of seconds of inactivity before the application moves to the background state
+     * The number of seconds of user inactivity before the application moves to the background state while playing video.
+     * This setting is used when remotePlayer is in playing state.
      * @type {integer}
      * @default 30
      */
     set autoBackgroundDelay(delay) {
-        this._autoBackgroundDelay = delay;
+        this._autoBackgroundOnVideoDelay = delay;
 
-        if (this.autoBackground) {
+        if (this.autoBackground && remotePlayer._isPlaying) {
+            this._startCountdown();
+        }
+    }
+
+    /**
+    * The number of seconds of user inactivity before the application moves to the background state while in the UI (not playing).
+    * This setting is used when remotePlayer is not in playing state.
+    * @type {integer}
+    * @default 30
+    */
+    set autoBackgroundOnUIDelay(delay) {
+        this._autoBackgroundOnUIDelay = delay;
+
+        if (this.autoBackground && !remotePlayer._isPlaying) {
             this._startCountdown();
         }
     }
 
     get autoBackgroundDelay() {
-        return this._autoBackgroundDelay;
+        return this._autoBackgroundOnVideoDelay;
     }
 
+    get autoBackgroundOnUIDelay() {
+        return this._autoBackgroundOnUIDelay;
+    }
     /**
     * @private
     */
-    _startCountdown() {
+    _startCountdown(isPlaying = remotePlayer._isPlaying) {
         this._stopCountdown();
-        this._countdown = setTimeout(() => {
-            this.moveToBackground();
-        }, this.autoBackgroundDelay * 1000);
+
+        const timeoutDelay = isPlaying ? this._autoBackgroundOnVideoDelay : this._autoBackgroundOnUIDelay;
+        sdkLogger.debug("Starting countdown timeout", timeoutDelay, isPlaying ? "(video)" : "(UI)");
+
+        // Only start countdown if delay is positive
+        if (timeoutDelay > 0) {
+            this._countdown = setTimeout(() => {
+                sdkLogger.debug("Countdown timeout reached, moving to background");
+                this.moveToBackground();
+            }, timeoutDelay * 1000);
+        } else {
+            sdkLogger.debug("Countdown not started - delay is negative or zero");
+        }
     }
 
     /**
@@ -225,6 +297,7 @@ class Lifecycle extends EventTarget {
     */
     _stopCountdown() {
         if (this._countdown) {
+            sdkLogger.debug("Stopping countdown timer");
             clearTimeout(this._countdown);
         }
         this._countdown = null;

package/src/remotePlayer.js

@@ -1,4 +1,3 @@
-
 import {
     getFCID,
     isAudioSyncEnabled,
@@ -552,6 +551,13 @@ class RemotePlayer extends EventTarget {
 
     /** @private change the internal load mode and store the new mode in session storage */
     _changePlayMode(newPlayMode) {
+        if (this._isPlaying !== newPlayMode) {
+            // Create event with play mode detail
+            const event = new CustomEvent("playModeChange", {
+                detail: { isPlaying: newPlayMode }
+            });
+            this.dispatchEvent(event);
+        }
         this._isPlaying = newPlayMode;
         window?.sessionStorage?.setItem("senzaSdk_isPlaying", String(newPlayMode));
     }