senza-sdk 4.2.47-a34cd6b.0 → 4.2.48

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.2.47-a34cd6b.0",
+    "version": "4.2.48",
     "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/deviceManager.js

@@ -269,16 +269,18 @@ class DeviceManager extends EventTarget {
 
     /**
      * @typedef {Object} WiFiInfo
-     * @property {string} ssid the name of the Wi-Fi network that the device is connected to
-     * @property {string} bssid the unique identifier of the Wi-Fi access point
-     * @property {string} standard the Wi-Fi standard in use, such as 802.11a/b/g/n/ac/ax
-     * @property {string} security the type of security protocol used by the Wi-Fi network, such as WEP, WPA, WPA2, or WPA3
-     * @property {string} device-mac the MAC address of the device
-     * @property {string} device-ip4 the IPv4 address assigned to the device on the Wi-Fi network
-     * @property {number} channel the number of the Wi-Fi channel currently being used
-     * @property {number} width width of the Wi-Fi channel in megahertz, e.g. 20MHz or 40 MHz channel
-     * @property {number} level a measure of the received signal strength, in the range 0 to 100 (the higher, the better). The level value is 100+RSSI (RSSI is the signal strength, measured in decibels)
-     * @property {number} quality a measure of the signal quality, in the range 0 to 100 (the higher, the better). The quality value is derived from the signal EVM.
+     * @property {string}   ssid the name of the Wi-Fi network that the device is connected to
+     * @property {string}   bssid the unique identifier of the Wi-Fi access point
+     * @property {string}   standard the Wi-Fi standard in use, such as 802.11a/b/g/n/ac/ax
+     * @property {string}   security the type of security protocol used by the Wi-Fi network, such as WEP, WPA, WPA2, or WPA3
+     * @property {string}   device-mac the MAC address of the device
+     * @property {string}   device-ip4 the IPv4 address assigned to the device on the Wi-Fi network
+     * @property {string}   dhcp-server the IP address of the DHCP server that assigned the device's network configuration
+     * @property {string[]} dns-server array of IP addresses of the DNS servers the device uses to resolve domain names
+     * @property {number}   channel the number of the Wi-Fi channel currently being used
+     * @property {number}   width width of the Wi-Fi channel in megahertz, e.g. 20MHz or 40 MHz channel
+     * @property {number}   level a measure of the received signal strength, in the range 0 to 100 (the higher, the better). The level value is 100+RSSI (RSSI is the signal strength, measured in decibels)
+     * @property {number}   quality a measure of the signal quality, in the range 0 to 100 (the higher, the better). The quality value is derived from the signal EVM.
      * */
 
     /**

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", () => {
@@ -746,6 +761,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}`);
+                }
+            });
+        }
+    }
 }
 
 /**

package/src/remotePlayer.js

@@ -199,7 +199,8 @@ class RemotePlayer extends EventTarget {
             sdkLogger.info("Got hs/playbackInfoEvent");
             // When attached, the sdk controls the synchronization between the local and remote player.
             if (this._videoElement) {
-                if ((lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+                // When audio sync is configured, the local player is already in sync with the remote player.
+                if (!isAudioSyncConfigured() && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
                     this._syncLocalPlayerWithRemotePlayer();
                 }
             } else {
@@ -621,7 +622,6 @@ class RemotePlayer extends EventTarget {
 
     _syncLocalPlayerWithRemotePlayer() {
         if (this._videoElement) {
-            if (isAudioSyncConfigured()) this._isSeekingByPlatform = true;
             this._videoElement.currentTime = this.currentTime;
         }
     }