senza-sdk 4.2.46-fdbcc4c.0 → 4.2.47-a34cd6b.0

package/package.json

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

package/src/alarmManager.js

@@ -1,6 +1,5 @@
 import { getFCID, sdkLogger } from "./utils";
 import { lifecycle } from "./lifecycle";
-import { getTriggerEvent } from "./api";
 
 /**
  * AlarmManager is a singleton class that manages the alarms in the application. It fires events whose types are the names of the alarms.
@@ -27,7 +26,6 @@ class AlarmManager extends EventTarget {
     constructor() {
         super();
         this._eventListeners = {};
-        this._isFirstAlarm = true;
         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));
@@ -35,23 +33,20 @@ class AlarmManager extends EventTarget {
                 if (this._eventListeners[e.detail.alarmName]) {
                     const event = new CustomEvent(e.detail.alarmName, {detail: e.detail.payload});
                     const timeBeforeAlarmHandling = Date.now();
-                    let uiStateBeforeAlarmHandling;
+                    let sourceState;
                     if (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND) {
-                        uiStateBeforeAlarmHandling = "foreground";
+                        sourceState = "foreground";
                     } else {
-                        uiStateBeforeAlarmHandling = "background";
+                        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 the application was triggered due to an alarm, and after all callbacks are handled, the application is still in the background and
-                        // moveToForeground has not been called as a result of the alarm, we want to intentionally terminate the ui in order to save resources.
-                        let isTriggering = false;
-                        if (getTriggerEvent().type === "alarmFiredEvent" && lifecycle.state === lifecycle.UiState.BACKGROUND) {
-                            if (this._isFirstAlarm) {
-                                isTriggering = true;
-                                this._isFirstAlarm = false;
-                            }
+                        // 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" };
@@ -70,18 +65,12 @@ class AlarmManager extends EventTarget {
                         }
                         // 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.
-                        let uiStateAfterAlarmHandling;
-                        if (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND) {
-                            uiStateAfterAlarmHandling = "foreground";
-                        } else {
-                            uiStateAfterAlarmHandling = "background";
-                        }
                         logger.metrics({
                             type: "monitorAlarm",
                             alarmName: e.detail.alarmName,
                             isTriggering,
-                            uiStateBefore: uiStateBeforeAlarmHandling,
-                            uiStateAfter: uiStateAfterAlarmHandling,
+                            sourceState,
+                            targetState: this._targetState,
                             alarmHandlingDuration
                         });
                     });
@@ -105,6 +94,11 @@ class AlarmManager extends EventTarget {
 
     _moveToForegroundCalled() {
         this._moveToForegroundHasBeenCalled = true;
+        this._targetState = "foreground";
+    }
+
+    _moveToBackgroundCalled() {
+        this._targetState = "background";
     }
 
     /** Set alarm to be fired at the specified time, event when ui is released

package/src/api.js

@@ -30,6 +30,7 @@ export const auth = {
 };
 
 /**
+ * @deprecated use lifecycle.ConnectReason instead.
  * @typedef {Object} ConnectReason - The reason the ui app has been loaded
  * @property {string} UNKNOWN
  * @property {string} INITIAL_CONNECTION - Indicates that ui app has been loaded for the first time
@@ -49,9 +50,6 @@ export const ConnectReason = Object.freeze({
     UI_WATCHDOG: "ui_watchdog"
 });
 
-let connectReason = ConnectReason.UNKNOWN;
-let triggerEvent = {};
-
 import { remotePlayer } from "./remotePlayer";
 export { remotePlayer };
 
@@ -112,33 +110,7 @@ export async function init() {
             sdkLogger.log(`onUpdateSessionEvent: token = ${authToken}`);
         });
 
-        // Get connection reason
-        connectReason = await new Promise((resolve) => {
-            const FCID = getFCID();
-            const logger = sdkLogger.withFields({ FCID });
-            const message = { type: "connectReason", fcid: FCID };
-            const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
-            window.cefQuery({
-                request: JSON.stringify(request),
-                persistent: false,
-                onSuccess: (response) => {
-                    logger.log(`connectReason request successfully returned '${response}'`);
-                    resolve(response);
-                },
-                onFailure: (code, msg) => {
-                    logger.error(`connectReason request failed: ${code} ${msg}`);
-                    resolve(ConnectReason.UNKNOWN);
-                }
-            });
-        });
-
         // Get trigger event
-        // Currently the known types (and details per type) are:
-        // keyPressEvent (keyValue)
-        // alarmFiredEvent (alarmName, payload)
-        // userAlertEvent (eventCode, message)
-        // externalEvent (eventName, payload)
-        // videoPlaybackEvent (eventCode, errorCode)
         const triggerEventStr = await new Promise((resolve) => {
             const FCID = getFCID();
             const logger = sdkLogger.withFields({ FCID });
@@ -157,34 +129,18 @@ export async function init() {
                 }
             });
         });
-        triggerEvent = {};
-        let originalTriggerEvent = {};
+        let triggerEvent = {};
         if (triggerEventStr) {
             try {
-                originalTriggerEvent = JSON.parse(triggerEventStr);
-                triggerEvent.type = originalTriggerEvent.type;
-                sdkLogger.info(`Got trigger event of type ${triggerEvent.type}`);
-                if (triggerEvent.type === "keyPressEvent") {
-                    triggerEvent.data = { keyValue: originalTriggerEvent.keyValue };
-                } else if (triggerEvent.type === "alarmFiredEvent") {
-                    triggerEvent.data = { alarmName: originalTriggerEvent.alarmName, payload: originalTriggerEvent.payload };
-                } else if (triggerEvent.type === "userAlertEvent") {
-                    triggerEvent.data = { eventCode: originalTriggerEvent.eventCode, message: originalTriggerEvent.message };
-                } else if (triggerEvent.type === "externalEvent") {
-                    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");
-                }
+                triggerEvent = JSON.parse(triggerEventStr);
             } catch (e) {
                 sdkLogger.error(`failed to parse trigger event string ${triggerEventStr}: ${e.message}`);
             }
         }
 
         // Initialize lifecycle first to make sure the state is updated.
-        await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"]);
-        await remotePlayer._init(sessionInfoObj?.settings?.["ui-streamer"], originalTriggerEvent);
+        await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
+        await remotePlayer._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
 
         const devSequence = sessionInfoObj?.settings?.["ui-streamer"]?.devSequence;
         if (devSequence) {
@@ -203,18 +159,20 @@ export async function init() {
     };
 }
 
-/** Returns the reason the ui has been loaded
- * @returns {ConnectReason} */
+/**
+ * @deprecated use lifecycle.connectReason instead
+ * Returns the reason the ui has been loaded
+ **/
 export function getConnectReason() {
-    return connectReason;
+    return lifecycle.connectReason;
 }
 
-/** Returns the event that triggered the reloading of the ui after ui has been released
- * @returns {Object} trigger event
- * @property {string} type - the type of the trigger event (e.g. keyPressEvent, videoPlaybackEvent)
- * @property {object} data - data of the event, dependent on its type (e.g. keyPressEvent has data of keyValue) */
+/**
+ * @deprecated use lifecycle.triggerEvent instead
+ * Returns the event that triggered the reloading of the ui after ui has been released
+ **/
 export function getTriggerEvent() {
-    return triggerEvent;
+    return lifecycle.triggerEvent;
 }
 
 // Returns the platform information, including version, pod, pod ip and session info.

package/src/lifecycle.js

@@ -21,8 +21,30 @@ const DEFAULT_AUTO_BACKGROUND_ENABLED = false;
   * Lifecycle is a singleton class that manages the application lifecycle states.<br>
   * @fires onstatechange
   * @fires userinactivity
+  * @fires userdisconnected
  */
 class Lifecycle extends EventTarget {
+
+    /**
+     * @typedef {Object} ConnectReason - The reason the ui app has been loaded
+     * @property {string} UNKNOWN
+     * @property {string} INITIAL_CONNECTION - Indicates that ui app has been loaded for the first time
+     * @property {string} APPLICATION_RELOAD - Indicates that ui app has been reloaded (e.g. after HOME keypress)
+     * @property {string} UI_RELEASE - Indicates that ui app has been reloaded after ui release
+     * @property {string} UI_TERMINATION - Indicates that ui app has been reloaded due to ui termination
+     * @property {string} WEBRTC_ERROR - Indicates that ui app has been reloaded due to webrtc error
+     * @property {string} UI_WATCHDOG - Indicates that ui app has been reloaded due to ui watchdog not receiving ui frames
+     */
+    ConnectReason = Object.freeze({
+        UNKNOWN: "unknown",
+        INITIAL_CONNECTION: "initial_connection",
+        APPLICATION_RELOAD: "reload_app",
+        UI_RELEASE: "ui_release",
+        UI_TERMINATION: "ui_termination",
+        WEBRTC_ERROR: "webrtc_error",
+        UI_WATCHDOG: "ui_watchdog"
+    });
+
     /**
      * @typedef {Object} UiState - The ui lifecycle state
      * @property {string} UNKNOWN - state is unknown at this time
@@ -60,6 +82,17 @@ class Lifecycle extends EventTarget {
      * });
      * @alpha API has not yet been released
      */
+
+    /**
+     * @event Lifecycle#userdisconnected
+     * @description Fired when the user session ends .
+     * This event is useful for cleaning up application state or saving data before the application closes.
+     * @example
+     * lifecycle.addEventListener("userdisconnected", () => {
+     *     console.log("User session ended, cleaning up application state");
+     *     // Perform any necessary cleanup here
+     * });
+     */
     constructor() {
         super();
 
@@ -106,6 +139,11 @@ class Lifecycle extends EventTarget {
             this.dispatchEvent(event);
         });
 
+        typeof document !== "undefined" && document.addEventListener("hs/endOfSession", () => {
+            const event = new Event("userdisconnected");
+            this.dispatchEvent(event);
+        });
+
         typeof document !== "undefined" && document.addEventListener("keydown", () => {
             if (this._autoBackground) {
                 if (this.state === this.UiState.BACKGROUND ||
@@ -135,8 +173,10 @@ class Lifecycle extends EventTarget {
      * @param {number} [uiStreamerSettings.remotePlayerConfirmationTimeout=5000] - Timeout in milliseconds for remote player operations
      * @param {number} [uiStreamerSettings.remotePlayerApiVersion=1] - Remote player API version
      */
-    async _init(uiStreamerSettings) {
+    async _init(uiStreamerSettings, triggerEvent) {
         if (window.cefQuery) {
+
+            // Get UI state
             this._state = await new Promise((resolve) => {
                 window.cefQuery({
                     request: "uiState",
@@ -151,6 +191,57 @@ class Lifecycle extends EventTarget {
                     }
                 });
             });
+
+            // Get connection reason
+            this._connectReason = await new Promise((resolve) => {
+                const FCID = getFCID();
+                const logger = sdkLogger.withFields({ FCID });
+                const message = { type: "connectReason", fcid: FCID };
+                const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
+                window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: (response) => {
+                        logger.log(`connectReason request successfully returned '${response}'`);
+                        resolve(response);
+                    },
+                    onFailure: (code, msg) => {
+                        logger.error(`connectReason request failed: ${code} ${msg}`);
+                        resolve(this.ConnectReason.UNKNOWN);
+                    }
+                });
+            });
+
+            // Set internal trigger event and fcid.
+            // Currently, the known types (and details per type) are:
+            // keyPressEvent (keyValue)
+            // alarmFiredEvent (alarmName, payload)
+            // userAlertEvent (eventCode, message)
+            // externalEvent (eventName, payload)
+            // videoPlaybackEvent (eventCode, errorCode)
+            // getLicense
+            this._triggerEvent = {};
+            if (triggerEvent.type) {
+                this._triggerEvent.type = triggerEvent.type;
+                sdkLogger.info(`Got trigger event of type ${this._triggerEvent.type}`);
+                if (triggerEvent.type === "keyPressEvent") {
+                    this._triggerEvent.data = { keyValue: triggerEvent.keyValue };
+                } else if (triggerEvent.type === "alarmFiredEvent") {
+                    this._triggerEvent.data = { alarmName: triggerEvent.alarmName, payload: triggerEvent.payload };
+                } else if (triggerEvent.type === "userAlertEvent") {
+                    this._triggerEvent.data = { eventCode: triggerEvent.eventCode, message: triggerEvent.message };
+                } else if (triggerEvent.type === "externalEvent") {
+                    this._triggerEvent.data = { eventName: triggerEvent.eventName, payload: triggerEvent.payload };
+                } else if (triggerEvent.type === "videoPlaybackEvent") {
+                    this._triggerEvent.data = { eventCode: triggerEvent.eventCode, errorCode: triggerEvent.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");
+                }
+            }
+            if (triggerEvent.fcid) {
+                this._triggerEventFcid = triggerEvent.fcid;
+            }
+
             this._isInitialized = true;
             this._remotePlayerConfirmationTimeout = uiStreamerSettings?.remotePlayerConfirmationTimeout ?? DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT;
             this._remotePlayerApiVersion = uiStreamerSettings?.remotePlayerApiVersion || 1;
@@ -219,6 +310,29 @@ class Lifecycle extends EventTarget {
         return this._state;
     }
 
+    /**
+     * Getter for returning the application connection reason
+     * @returns {ConnectReason} the application connection reason
+     */
+    get connectReason() {
+        if (!this._isInitialized) {
+            this._connectReason = this.ConnectReason.UNKNOWN;
+        }
+        return this._connectReason;
+    }
+
+    /**
+     * Getter for returning the event that triggered the reloading of the ui after ui has been released
+     * @returns {Object} trigger event
+     * @property {string} type - the type of the trigger event (e.g. keyPressEvent, videoPlaybackEvent)
+     * @property {object} data - data of the event, dependent on its type (e.g. keyPressEvent has data of keyValue) */
+    get triggerEvent() {
+        if (!this._isInitialized) {
+            this._triggerEvent = {};
+        }
+        return this._triggerEvent;
+    }
+
     /**
      * Controls the autoBackground feature<br>
      * When enabled, the application will automatically move to the background state after a configurable
@@ -432,6 +546,8 @@ class Lifecycle extends EventTarget {
                 remotePlayer._syncRemotePlayerWithLocalPlayer();
             }
 
+            alarmManager._moveToBackgroundCalled();
+
             if (!remotePlayer._isPlaying) {
                 return this._moveToUiStandby();
             }

package/src/remotePlayer.js

@@ -199,8 +199,7 @@ 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) {
-                // 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)) {
+                if ((lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
                     this._syncLocalPlayerWithRemotePlayer();
                 }
             } else {
@@ -622,6 +621,7 @@ class RemotePlayer extends EventTarget {
 
     _syncLocalPlayerWithRemotePlayer() {
         if (this._videoElement) {
+            if (isAudioSyncConfigured()) this._isSeekingByPlatform = true;
             this._videoElement.currentTime = this.currentTime;
         }
     }

package/src/utils.js

@@ -39,7 +39,7 @@ class SdkLogger {
         console.error(this.formatLogString(data));
     }
     metrics(metricObj) {
-        console.info(`[hs-sdk][metrics] ${JSON.stringify(metricObj)}`);
+        console.info(`[hs-sdk] [metrics] ${JSON.stringify(metricObj)}`);
     }
     withFields(logFields) {
         return new SdkLogger({...this.logFields, ...logFields});