senza-sdk 4.2.48 → 4.2.50

package/package.json

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

package/src/lifecycle.js

@@ -182,9 +182,10 @@ class Lifecycle extends EventTarget {
     /** @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 {boolean} [uiStreamerSettings.autoBackground.enabled=false] - Enable/disable auto background
+     * @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 {number} [uiStreamerSettings.remotePlayerConfirmationTimeout=5000] - Timeout in milliseconds for remote player operations
      * @param {number} [uiStreamerSettings.remotePlayerApiVersion=1] - Remote player API version
      */
@@ -261,23 +262,83 @@ class Lifecycle extends EventTarget {
             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) {
+            // Apply autoBackground settings if provided
+            if (uiStreamerSettings?.autoBackground) {
+                this.configure({
+                    autoBackground: uiStreamerSettings.autoBackground
+                });
+            }
+        }
+    }
+
+    /**
+     * 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 {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
+     */
+    configure(config) {
+        if (config?.autoBackground) {
+            const { enabled, timeout } = config.autoBackground;
+
+            // Update enabled state
+            if (typeof enabled === "boolean") {
+                this._autoBackground = enabled;
+            }
+            // Update timeouts
+            if (timeout) {
+                if (timeout.playing !== undefined) {
+                    if (timeout.playing === false) {
+                        this._autoBackgroundOnVideoDelay = -1;
+                    } else if (typeof timeout.playing === "number") {
+                        this._autoBackgroundOnVideoDelay = timeout.playing;
+                    } else {
+                        sdkLogger.warn("Invalid autoBackground.timeout.playing value, expected number or false");
+                    }
+                }
+                if (timeout.idle !== undefined) {
+                    if (timeout.idle === false) {
+                        this._autoBackgroundOnUIDelay = -1;
+                    } else if (typeof timeout.idle === "number") {
+                        this._autoBackgroundOnUIDelay = timeout.idle;
+                    } else {
+                        sdkLogger.warn("Invalid autoBackground.timeout.idle value, expected number or false");
+                    }
+                }
+            }
+            // Start or stop countdown based on new configuration
+            if (this._autoBackground) {
                 this._startCountdown();
-            }*/
+            } else {
+                this._stopCountdown();
+            }
         }
     }
 
+    /**
+     * Get the current configuration settings
+     * @returns {Object} The current configuration object
+     * @example
+     * const config = lifecycle.getConfiguration();
+     * console.log(config.autoBackground.enabled); // true/false
+     * console.log(config.autoBackground.timeout.playing); // 30
+     * console.log(config.autoBackground.timeout.idle); // false
+     */
+    getConfiguration() {
+        return {
+            autoBackground: {
+                enabled: this._autoBackground,
+                timeout: {
+                    playing: this._autoBackgroundOnVideoDelay <= 0 ? false : this._autoBackgroundOnVideoDelay,
+                    idle: this._autoBackgroundOnUIDelay <= 0 ? false : this._autoBackgroundOnUIDelay
+                }
+            }
+        };
+    }
+
     /**
      * This method moves the application into standby mode, i.e. last ui frame is displayed and ui resources are released.
      * It should be called whenever the application wishes to go into standby mode and release resources.
@@ -411,10 +472,10 @@ class Lifecycle extends EventTarget {
         this._stopCountdown();
 
         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) {
+            sdkLogger.debug("Starting countdown timeout", timeoutDelay, isPlaying ? "(video)" : "(UI)");
             this._countdown = setTimeout(() => {
                 sdkLogger.debug("Countdown timeout reached, moving to background");
                 this.moveToBackground();

package/src/remotePlayer.js

@@ -586,7 +586,7 @@ class RemotePlayer extends EventTarget {
                     currentFramePTS: metadata.mediaTime.toString(),
                     ptsSessionId: this._ptsSessionId
                 };
-                const request = {target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message)};
+                const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
                 window.cefQuery({
                     request: JSON.stringify(request),
                     persistent: false

package/src/senzaShakaPlayer.js

@@ -1,5 +1,5 @@
 import * as shaka from "shaka-player";
-import { remotePlayer, lifecycle } from "./api";
+import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
 import { sdkLogger, iso6393to1 } from "./utils";
 
 //  Define custom error category
@@ -386,6 +386,18 @@ export class SenzaShakaPlayer extends shaka.Player {
             ]);
         };
 
+        // For live streams, we can set a default offset from the live edge
+        // This allows for synchronizing the start position for both local and remote players
+        // Note: For VOD content, negative start times are treated as 0
+        const { defaultInitialLiveOffset, minInitialLiveOffset } = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"] || {};
+        if ((startTime === undefined || startTime === 0) && defaultInitialLiveOffset !== undefined) {
+            sdkLogger.debug(`load() was called with startTime=${startTime}, setting startTime to ${-defaultInitialLiveOffset}`);
+            startTime = -defaultInitialLiveOffset;
+        } else if (startTime <= 0 && minInitialLiveOffset !== undefined && startTime > -minInitialLiveOffset) {
+            sdkLogger.debug(`load() was called with startTime=${startTime}, setting startTime to ${-minInitialLiveOffset}`);
+            startTime = -minInitialLiveOffset;
+        }
+
         if (!this.isInRemotePlayback || remotePlayer.getAssetUri() !== url) {
             this._audioTracksMap = {};
             this._videoTracksMap = {};