senza-sdk 4.2.47 → 4.2.49

package/package.json

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

package/src/alarmManager.js

@@ -1,4 +1,5 @@
 import { getFCID, sdkLogger } from "./utils";
+import { EventListenersManager } from "./eventListenersManager";
 import { lifecycle } from "./lifecycle";
 
 /**
@@ -25,71 +26,95 @@ class AlarmManager extends EventTarget {
      */
     constructor() {
         super();
-        this._eventListeners = {};
-        typeof document !== "undefined" && document.addEventListener("hs/alarmFiredEvent", (e) => {
-            const logger = sdkLogger.withFields({alarmName: e.detail?.alarmName});
-            logger.log("Got hs/alarmFiredEvent", JSON.stringify(e.detail));
+
+        /**
+         * Event listeners manager for alarm events
+         * @type {EventListenersManager}
+         * @private
+         */
+        this._eventManager = new EventListenersManager({
+            timeoutMs: 15000 // Default timeout of 15 seconds, can be overridden by _setDefaultTimeout
+        });
+
+        typeof document !== "undefined" && document.addEventListener("hs/alarmFiredEvent",async (e) => {
+
             if (e.detail?.alarmName) {
-                if (this._eventListeners[e.detail.alarmName]) {
-                    const event = new CustomEvent(e.detail.alarmName, {detail: e.detail.payload});
-                    const timeBeforeAlarmHandling = Date.now();
-                    let sourceState;
-                    if (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND) {
-                        sourceState = "foreground";
-                    } else {
-                        sourceState = "background";
-                    }
-                    this._targetState = sourceState;
-                    Promise.allSettled(Array.from(this._eventListeners[e.detail.alarmName], cb => cb(event))).then(() => {
-                        const alarmHandlingDuration = Date.now() - timeBeforeAlarmHandling;
-                        logger.log(`All callbacks for alarm '${e.detail.alarmName}' are finished within ${alarmHandlingDuration}ms`);
-                        // If this alarm triggered the application, and moveToForeground has not been called as a result of the alarm
-                        // (i.e. the application is still in the background), we want to intentionally terminate the ui in order to save resources.
-                        const isTriggering = lifecycle.triggerEvent.type === "alarmFiredEvent" && lifecycle._triggerEventFcid && lifecycle._triggerEventFcid === e.detail.fcid;
-                        if (isTriggering) {
-                            if (!this._moveToForegroundHasBeenCalled && window.cefQuery) {
-                                logger.log("Application is about to be terminated since didn't move to foreground");
-                                const message = { type: "terminating" };
-                                const request = { target:"TC", waitForResponse: false, message: JSON.stringify(message) };
-                                window.cefQuery({
-                                    request: JSON.stringify(request),
-                                    persistent: false,
-                                    onSuccess: () => {
-                                        logger.log("terminating request successfully sent");
-                                    },
-                                    onFailure: (code, msg) => {
-                                        logger.error(`terminating request failed: ${code} ${msg}`);
-                                    }
-                                });
+                const logger = sdkLogger.withFields({alarmName: e.detail?.alarmName});
+                logger.log("Got hs/alarmFiredEvent", JSON.stringify(e.detail));
+
+                const timeBeforeAlarmHandling = Date.now();
+
+                let sourceState;
+                if (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND) {
+                    sourceState = "foreground";
+                } else {
+                    sourceState = "background";
+                }
+                this._targetState = sourceState;
+
+                // Create the custom event with payload
+                const event = new CustomEvent(e.detail.alarmName, {detail: e.detail.payload});
+
+                // Dispatch the event and wait for all listeners
+                await this._eventManager.dispatch(e.detail.alarmName, event);
+
+                const alarmHandlingDuration = Date.now() - timeBeforeAlarmHandling;
+                logger.log(`All callbacks for alarm '${e.detail.alarmName}' are finished within ${alarmHandlingDuration}ms`);
+                // If this alarm triggered the application, and moveToForeground has not been called as a result of the alarm
+                // (i.e. the application is still in the background), we want to intentionally terminate the ui in order to save resources.
+                const isTriggering = lifecycle.triggerEvent.type === "alarmFiredEvent" && lifecycle._triggerEventFcid && lifecycle._triggerEventFcid === e.detail.fcid;
+                if (isTriggering) {
+                    if (!this._moveToForegroundHasBeenCalled && window.cefQuery) {
+                        logger.log("Application is about to be terminated since didn't move to foreground");
+                        const message = { type: "terminating" };
+                        const request = { target:"TC", waitForResponse: false, message: JSON.stringify(message) };
+                        window.cefQuery({
+                            request: JSON.stringify(request),
+                            persistent: false,
+                            onSuccess: () => {
+                                logger.log("terminating request successfully sent");
+                            },
+                            onFailure: (code, msg) => {
+                                logger.error(`terminating request failed: ${code} ${msg}`);
                             }
-                        }
-                        // For monitoring purposes, log a json with all the necessary labels and a unique prefix [hs-sdk][metrics]
-                        // The ui-streamer will recognize this prefix and handle the json accordingly.
-                        logger.metrics({
-                            type: "monitorAlarm",
-                            alarmName: e.detail.alarmName,
-                            isTriggering,
-                            sourceState,
-                            targetState: this._targetState,
-                            alarmHandlingDuration
                         });
-                    });
+                    }
                 }
+                // For monitoring purposes, log a json with all the necessary labels and a unique prefix [hs-sdk][metrics]
+                // The ui-streamer will recognize this prefix and handle the json accordingly.
+                logger.metrics({
+                    type: "monitorAlarm",
+                    alarmName: e.detail.alarmName,
+                    isTriggering,
+                    sourceState,
+                    targetState: this._targetState,
+                    alarmHandlingDuration
+                });
             }
-        });
+        }
+        );
     }
 
-    addEventListener(type, callback) {
-        if (!this._eventListeners[type]) {
-            this._eventListeners[type] = new Set();
+    /**
+     * Set the default timeout for alarm event listeners
+     * @param {number} timeout - Timeout in milliseconds for alarm event listeners
+     * @private
+     */
+    _setDefaultTimeout(timeout) {
+        if (typeof timeout === "number" && timeout > 0) {
+            this._eventManager.timeoutMs = timeout;
+            sdkLogger.log(`Alarm event listener timeout set to ${timeout}ms`);
+        } else {
+            sdkLogger.warn(`Invalid timeout value: ${timeout}. Must be a positive number.`);
         }
-        this._eventListeners[type].add(callback);
+    }
+
+    addEventListener(type, callback) {
+        this._eventManager.addEventListener(type, callback);
     }
 
     removeEventListener(type, callback){
-        if (this._eventListeners[type]) {
-            this._eventListeners[type].delete(callback);
-        }
+        this._eventManager.removeEventListener(type, callback);
     }
 
     _moveToForegroundCalled() {

package/src/api.js

@@ -4,6 +4,7 @@ import { sessionInfo } from "./SessionInfo";
 const { version } = pack;
 import { initSequence, showSequence } from "./devSequence.js";
 import { lifecycle } from "./lifecycle";
+import { alarmManager } from "./alarmManager";
 
 let authToken;
 
@@ -110,6 +111,12 @@ export async function init() {
             sdkLogger.log(`onUpdateSessionEvent: token = ${authToken}`);
         });
 
+        // Set default alarm timeout using UI-Streamer settings
+        const alarmTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.alarmTimeout;
+        if (alarmTimeout) {
+            alarmManager._setDefaultTimeout(alarmTimeout);
+        }
+
         // Get trigger event
         const triggerEventStr = await new Promise((resolve) => {
             const FCID = getFCID();
@@ -157,6 +164,8 @@ export async function init() {
     window.close = () => {
         sdkLogger.warn("window.close is disabled on Senza platform. Use lifecycle.exitApplication() instead.");
     };
+
+
 }
 
 /**
@@ -343,7 +352,7 @@ export function getDeviceInfo() {
 export { lifecycle } from "./lifecycle";
 export { deviceManager } from "./deviceManager";
 export { platformManager } from "./platformManager";
-export { alarmManager } from "./alarmManager";
+export { alarmManager };
 export { messageManager } from "./messageManager";
 export { initSequence, showSequence } from "./devSequence";
 export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer";

package/src/eventListenersManager.js

@@ -0,0 +1,108 @@
+import { sdkLogger } from "./utils";
+
+/**
+ * EventListenersManager - A utility class to manage event listeners with Promise-based completion tracking
+ * Handles both synchronous and asynchronous listeners, with timeout support
+ */
+export class EventListenersManager {
+    /**
+   * Create a new EventListenersManager
+   * @param {Object} options - Configuration options
+   * @param {number} [options.timeoutMs=5000] - Timeout in milliseconds for each listener
+    */
+    constructor(options = {}) {
+        this.listeners = new Map(); // Map of event types to arrays of listeners
+        this.timeoutMs = options.timeoutMs || 5000;
+    }
+
+    /**
+   * Add an event listener for a specific event type
+   * @param {string} eventType - The type of event to listen for
+   * @param {Function} listener - The callback function
+   */
+    addEventListener(eventType, listener) {
+        if (!this.listeners.has(eventType)) {
+            this.listeners.set(eventType, []);
+        }
+        this.listeners.get(eventType).push(listener);
+    }
+
+    /**
+   * Remove an event listener for a specific event type
+   * @param {string} eventType - The type of event
+   * @param {Function} listener - The callback function to remove
+   */
+    removeEventListener(eventType, listener) {
+        if (!this.listeners.has(eventType)) return;
+
+        const listenerArray = this.listeners.get(eventType);
+        const index = listenerArray.indexOf(listener);
+        if (index !== -1) {
+            listenerArray.splice(index, 1);
+        }
+    }
+
+
+    /**
+   * Dispatch an event and wait for all listeners to complete
+   * @param {string} eventType - The type of event to dispatch
+   * @param {*} eventDetail - The event detail or Event object to pass to listeners
+   * @returns {Promise<void>} A promise that resolves when all listeners have completed
+   */
+    async dispatch(eventType, eventDetail = {}){
+        const eventListeners = this.listeners.get(eventType) || [];
+
+        if (eventListeners.length === 0) {
+            return;
+        }
+
+        // Create event object if eventDetail isn't already an Event
+        const event = eventDetail instanceof Event ? eventDetail : new CustomEvent(eventType, { detail: eventDetail });
+
+        // Execute all listeners and wrap each in a safe promise that won't reject
+        const listenerPromises = eventListeners.map(listener => {
+            try {
+                return Promise.resolve(listener(event))
+                    .catch(error => {
+                        sdkLogger.error(`Error in ${eventType} listener (promise rejection):`, error);
+                        return undefined; // Convert rejected promises to resolved promises
+                    });
+            } catch (error) {
+                sdkLogger.error(`Error in ${eventType} listener:`, error);
+                return Promise.resolve(); // Continue with other listeners even if one fails
+            }
+        });
+
+        try {
+            // Create a timeout timer we can cancel
+            let timeoutId = null;
+
+            // Create a single timeout promise for the entire batch
+            const timeoutPromise = new Promise((resolve) => {
+                timeoutId = setTimeout(() => {
+                    sdkLogger.warn(`Event dispatch for ${eventType} timed out after ${this.timeoutMs}ms`);
+                    resolve();
+                }, this.timeoutMs);
+            });
+
+            // Create a promise for all listeners completing
+            const allListenersPromise = Promise.allSettled(listenerPromises).then(results => {
+                // Clear the timeout when all listeners complete
+                if (timeoutId !== null) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                return results;
+            });
+
+            // Race between all listeners completing and the timeout
+            await Promise.race([allListenersPromise, timeoutPromise]);
+
+
+        } catch (error) {
+            sdkLogger.error(`Error waiting for ${eventType} listeners to complete:`, error);
+
+        }
+
+    }
+}

package/src/lifecycle.js

@@ -9,6 +9,7 @@ import {
     SenzaError,
     TargetPlayingState
 } from "./utils";
+import { EventListenersManager } from "./eventListenersManager";
 import { sessionInfo } from "./SessionInfo";
 import { DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT, remotePlayer } from "./remotePlayer";
 
@@ -103,6 +104,15 @@ class Lifecycle extends EventTarget {
         this._isInitialized = false;
         this._inTransition = false;
 
+        /**
+         * Event listeners manager for the userdisconnected event
+         * @type {EventListenersManager}
+         * @private
+         */
+        this._eventManager = new EventListenersManager({
+            timeoutMs: 10000
+        });
+
         /**
          * @type {boolean}
          * @private
@@ -139,9 +149,14 @@ class Lifecycle extends EventTarget {
             this.dispatchEvent(event);
         });
 
-        typeof document !== "undefined" && document.addEventListener("hs/endOfSession", () => {
+        typeof document !== "undefined" && document.addEventListener("hs/endOfSession", async () => {
+            // Create the event
             const event = new Event("userdisconnected");
-            this.dispatchEvent(event);
+
+            // Use the event manager to dispatch the event and wait for all listeners
+            await this._eventManager.dispatch("userdisconnected", event);
+
+            this._sendTerminatingMessage();
         });
 
         typeof document !== "undefined" && document.addEventListener("keydown", () => {
@@ -167,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
      */
@@ -246,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.
@@ -396,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();
@@ -746,6 +822,64 @@ class Lifecycle extends EventTarget {
         sdkLogger.warn("exitApplication is not supported if NOT running e2e");
         return Promise.reject("exitApplication is not supported if NOT running e2e");
     }
+
+    /**
+     * Override addEventListener to handle "userdisconnected" event specially
+     * @param {string} type - The event type to listen for
+     * @param {Function} listener - The callback function
+     * @param {Object} options - Event listener options
+     */
+    addEventListener(type, listener, options) {
+        if (type === "userdisconnected") {
+            // Use the event manager for userdisconnected events
+            this._eventManager.addEventListener(type, listener);
+        } else {
+            // For all other event types, use the parent class implementation
+            super.addEventListener(type, listener, options);
+        }
+    }
+
+    /**
+     * Override removeEventListener to handle "userdisconnected" event specially
+     * @param {string} type - The event type
+     * @param {Function} listener - The callback function to remove
+     * @param {Object} options - Event listener options
+     */
+    removeEventListener(type, listener, options) {
+        if (type === "userdisconnected") {
+            // Use the event manager for userdisconnected events
+            this._eventManager.removeEventListener(type, listener);
+        } else {
+            // For all other event types, use the parent class implementation
+            super.removeEventListener(type, listener, options);
+        }
+    }
+
+    /**
+     * Sends the terminating message to the platform
+     * @private
+     */
+    _sendTerminatingMessage() {
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const message = {
+                type: "terminating",
+                fcid: FCID
+            };
+            const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
+
+            window.cefQuery({
+                request: JSON.stringify(request),
+                persistent: false,
+                onSuccess: () => {
+                    sdkLogger.log("Terminating signal sent after userdisconnected event was processed");
+                },
+                onFailure: (code, msg) => {
+                    sdkLogger.error(`Failed to send terminating signal: ${code} ${msg}`);
+                }
+            });
+        }
+    }
 }
 
 /**