senza-sdk 4.4.1 → 4.4.2

package/package.json

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

package/src/implementation/alarmManager.js

@@ -2,6 +2,7 @@ import { AlarmManager as AlarmManagerInterface } from "../interface/alarmManager
 import { getFCID, sdkLogger } from "./utils.js";
 import { EventListenersManager } from "./eventListenersManager.js";
 import { lifecycle } from "./lifecycle.js";
+import { bus, Events } from "./eventBus";
 
 class AlarmManager extends AlarmManagerInterface {
     constructor() {
@@ -38,6 +39,8 @@ class AlarmManager extends AlarmManagerInterface {
      * @private Add event listeners for system events
      */
     _addSenzaEventListeners() {
+        bus.addEventListener(Events.LifecycleForeground, () => this._moveToForegroundCalled());
+
         typeof document !== "undefined" && document.addEventListener("hs/alarmFiredEvent", async (e) => {
 
             if (e.detail?.alarmName) {

package/src/implementation/api.js

@@ -100,6 +100,12 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
             alarmManager._setDefaultTimeout(alarmTimeout);
         }
 
+        // Set default device manager event timeout using UI-Streamer settings
+        const deviceManagerEventTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.deviceManagerEventTimeout;
+        if (deviceManagerEventTimeout) {
+            deviceManager._setDefaultTimeout(deviceManagerEventTimeout);
+        }
+
         // Get trigger event
         const triggerEventStr = await new Promise((resolve) => {
             const FCID = getFCID();
@@ -133,6 +139,7 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         await remotePlayer._init(sessionInfoObj, triggerEvent);
         alarmManager._init();
         messageManager._init();
+        deviceManager._init();
         sdkLogger.log("All submodules initialized");
 
 

package/src/implementation/deviceManager.js

@@ -1,6 +1,9 @@
 import { DeviceManager as DeviceManagerInterface } from "../interface/deviceManager";
 import { getFCID, sdkLogger, getRestResponse } from "./utils";
 import { sessionInfo } from "./SessionInfo";
+import {EventListenersManager} from "./eventListenersManager";
+import {bus, Events} from "./eventBus";
+import {lifecycle} from "./lifecycle";
 
 let wifi_ap_data;
 let wifi_status;
@@ -38,6 +41,125 @@ class DeviceManager extends DeviceManagerInterface {
 
     constructor() {
         super();
+
+        /**
+         * Mapping of CEC active source status to HdmiStatus.
+         * @type {Object}
+         * @private
+         */
+        this._cecActiveSourceStatusMap = Object.freeze({
+            active: this.HdmiStatus.ACTIVE,
+            inactive: this.HdmiStatus.INACTIVE,
+            unknown: this.HdmiStatus.UNKNOWN
+        });
+
+        /**
+         * Event listeners manager for the deviceManager events
+         * @type {EventListenersManager}
+         * @private
+         */
+        this._eventManager = new EventListenersManager({
+            timeoutMs: 10000 // Default timeout of 10 seconds, can be overridden by _setDefaultTimeout
+        });
+
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._isInitialized = false;
+    }
+
+    /**
+     * @private
+     */
+    _init() {
+        sdkLogger.log("Initializing DeviceManager");
+        if (!this._isInitialized) {
+            this._isInitialized = true;
+            this._addSenzaEventListeners();
+        }
+    }
+
+    /**
+     * @private Add event listeners for system events
+     */
+    _addSenzaEventListeners() {
+        bus.addEventListener(Events.LifecycleForeground, () => {
+            this._moveToForegroundHasBeenCalled = true;
+        });
+
+        typeof document !== "undefined" && document.addEventListener("hs/hdmiStatusChanged", async (event) => {
+            sdkLogger.info("Got hs/hdmiStatusChanged event with detail", JSON.stringify(event?.detail));
+
+            // Translate the HdmiStatus information to a single HdmiStatus for the application
+            // 1) cecStatus is a configuration setting from the client. If false, we always return UNKNOWN to the application
+            // 2) If cecStatus is true, we check the hdmiStatus. If not "connected", the HDMI status is definitely INACTIVE.
+            // 3) If hdmiStatus is "connected" and cecStatus is true, we rely on the cecActiveSourceStatus to determine the HdmiStatus
+            let hdmiStatus = this.HdmiStatus.UNKNOWN;
+            const status = JSON.parse(event?.detail?.hdmiStatus ?? "{}"); // Object containing the 3 statuses
+            if (status?.cecStatus) {
+                if (status.hdmiStatus !== "connected") {
+                    hdmiStatus = this.HdmiStatus.INACTIVE;
+                } else {
+                    const cecActive = this._cecActiveSourceStatusMap[status.cecActiveSourceStatus];
+                    hdmiStatus = cecActive ?? this.HdmiStatus.UNKNOWN;
+                    if (!cecActive) {
+                        sdkLogger.warn(`Unknown CEC active source status: ${status.cecActiveSourceStatus}`);
+                    }
+                }
+            } else {
+                sdkLogger.warn("cec is disabled or no hdmiStatus");
+            }
+
+            const timeBeforeCallbacks = Date.now();
+
+            // Dispatch event to application and allow a chance to move to foreground.
+            // If there are no callbacks or the application doesn't move to foreground, the UI will be disconnected.
+            await this._eventManager.dispatch("hdmistatuschanged", {hdmiStatus});
+
+            const callbackDuration = Date.now() - timeBeforeCallbacks;
+            sdkLogger.log(`All callbacks for hdmiStatusChanged are finished within ${callbackDuration}ms`);
+            const isTriggering = lifecycle.triggerEvent.type === "hdmiStatusChanged" && lifecycle._triggerEventFcid && lifecycle._triggerEventFcid === event.detail.fcid;
+            if (isTriggering) {
+                if (!this._moveToForegroundHasBeenCalled && window.cefQuery) {
+                    sdkLogger.log("Application is about to be disconnected since didn't move to foreground");
+                    const message = { type: "disconnect" };
+                    const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
+                    window.cefQuery({
+                        request: JSON.stringify(request),
+                        persistent: false,
+                        onSuccess: () => {
+                            sdkLogger.log("disconnect request successfully sent");
+                        },
+                        onFailure: (code, msg) => {
+                            sdkLogger.error(`disconnect request failed: ${code} ${msg}`);
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    /**
+     * Set the default timeout for device manager event listeners
+     * @param {number} timeout - Timeout in milliseconds for device manager event listeners
+     * @private
+     */
+    _setDefaultTimeout(timeout) {
+        if (typeof timeout === "number" && timeout > 0) {
+            this._eventManager.timeoutMs = timeout;
+            sdkLogger.log(`DeviceManager event listener timeout set to ${timeout}ms`);
+        } else {
+            sdkLogger.warn(`Invalid timeout value: ${timeout}. Must be a positive number.`);
+        }
+    }
+
+    addEventListener(type, callback) {
+        this._eventManager.addEventListener(type, callback);
+    }
+
+    removeEventListener(type, callback) {
+        this._eventManager.removeEventListener(type, callback);
     }
 
     get deviceInfo() {

package/src/implementation/eventBus.js

@@ -0,0 +1,5 @@
+class EventBus extends EventTarget {}
+export const bus = new EventBus();
+export const Events = {
+    LifecycleForeground: "lifecycle:foreground"
+};

package/src/implementation/lifecycle.js

@@ -14,6 +14,7 @@ import {
 import { EventListenersManager } from "./eventListenersManager.js";
 import { sessionInfo } from "./SessionInfo.js";
 import { DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT, remotePlayer } from "./remotePlayer.js";
+import {bus, Events} from "./eventBus";
 
 // Default values for autoBackground settings. These values are used if the UIStreamer settings are not provided.
 const DEFAULT_AUTO_BACKGROUND_VIDEO_DELAY = 30;
@@ -136,6 +137,8 @@ class Lifecycle extends LifecycleInterface {
                     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");
+                } else if (triggerEvent.type === "hdmiStatusChanged") {
+                    sdkLogger.info("The hdmiStatusChanged data is sent in the callback after uiReady is called");
                 }
             }
             if (triggerEvent.fcid) {
@@ -461,7 +464,7 @@ class Lifecycle extends LifecycleInterface {
                 return Promise.resolve(false);
             }
             this._inTransitionToForeground = true;
-            alarmManager._moveToForegroundCalled();
+            bus.dispatchEvent(new Event(Events.LifecycleForeground));
             const FCID = getFCID();
             if (this._remotePlayerApiVersion >= 2) {
                 // Only update to playing UI if we started seeking in ABR. But, if we are seeking while already paused, keep the target seek state as is.

package/src/interface/deviceManager.js

@@ -1,9 +1,33 @@
 import { sdkLogger, noop } from "./utils.js";
 
 /**
- * DeviceManager is a singleton class that manages the device
+ * @event DeviceManager#hdmistatuschanged
+ * @description Fired when the HDMI connection status changes.<br>
+ * @property {HdmiStatus} hdmiStatus - the status of the HDMI connection.
+ * @example
+ * deviceManager.addEventListener("hdmistatuschanged", (e) => {
+ *     console.info("HDMI status changed:", e.detail.hdmiStatus);
+ * });
+ * @private
+ */
+
+/**
+ * DeviceManager is a singleton class that manages the device.<br>
+ * @fires hdmistatuschanged
  */
 export class DeviceManager extends EventTarget {
+    /**
+     * @typedef {Object} HdmiStatus - The HDMI status of the device
+     * @property {string} ACTIVE - The device is connected to the active HDMI source.
+     * @property {string} INACTIVE - The active HDMI source is different than the one connected to the device or the TV is in standby.
+     * @property {string} UNKNOWN - The status is unknown. This can happen if the TV does not support HDMI status detection.
+     */
+    HdmiStatus = Object.freeze({
+        ACTIVE: "active",
+        INACTIVE: "inactive",
+        UNKNOWN: "unknown"
+    });
+
     /**
      * @property {object} DeviceInfo
      * @property {string} DeviceInfo.deviceId

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.4.1";
+export const version = "4.4.2";