senza-sdk 4.4.2-efcb53d.0 → 4.4.4-86e7d7a.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.4.2-efcb53d.0",
+    "version": "4.4.4-86e7d7a.0",
     "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,13 +1,16 @@
 import { DeviceManager as DeviceManagerInterface } from "../interface/deviceManager";
-import { getFCID, sdkLogger, getRestResponse } from "./utils";
+import { getFCID, sdkLogger, getRestResponse, clearTimer, SenzaError } 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;
 let wifi_status_last_update = 0;
 
 const WIFI_STATUS_CACHE_SECONDS = 5;
-const FACTORY_RESET_TIMEOUT_SECONDS = 5;
+const API_CONFIRMATION_TIMEOUT_MS = 5000;
 
 async function getWifiApData() {
     // Wi-Fi access point data is static, so it needs to be retrieved only once
@@ -38,6 +41,134 @@ 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();
+        }
+    }
+
+    /**
+     * 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
+     * @private
+     */
+    _translateHdmiStatus(hdmiStatusStr) {
+        const hdmiStatusObj = JSON.parse(hdmiStatusStr ?? "{}"); // Object containing the 3 statuses
+        let hdmiStatus = this.HdmiStatus.UNKNOWN;
+        if (hdmiStatusObj?.cecStatus) {
+            if (hdmiStatusObj.hdmiStatus !== "connected") {
+                hdmiStatus = this.HdmiStatus.INACTIVE;
+            } else {
+                const cecActive = this._cecActiveSourceStatusMap[hdmiStatusObj.cecActiveSourceStatus];
+                hdmiStatus = cecActive ?? this.HdmiStatus.UNKNOWN;
+                if (!cecActive) {
+                    sdkLogger.warn(`Unknown CEC active source status: ${hdmiStatusObj.cecActiveSourceStatus}`);
+                }
+            }
+        } else {
+            sdkLogger.warn("cec is disabled or no hdmiStatus");
+        }
+        sdkLogger.log("HDMI status is:", hdmiStatus);
+        return hdmiStatus;
+    }
+
+    /**
+     * @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));
+
+            const hdmiStatus = this._translateHdmiStatus(event?.detail?.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() {
@@ -57,6 +188,46 @@ class DeviceManager extends DeviceManagerInterface {
         return super.deviceInfo;
     }
 
+    getHdmiStatus() {
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const message = {
+                type: "getHdmiStatus",
+                fcid: FCID
+            };
+            const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
+            sdkLogger.log("Sending getHdmiStatus request");
+            return new Promise((resolve, reject) => {
+                let timerId = 0;
+                const timeBeforeSendingRequest = Date.now();
+                const queryId = window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: (data) => {
+                        timerId = clearTimer(timerId);
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        sdkLogger.withFields({ duration }).log(`getHdmiStatus completed successfully after ${duration} ms with data: ${data}`);
+                        const hdmiStatus = this._translateHdmiStatus(data ? data : "{}");
+                        resolve(hdmiStatus);
+                    },
+                    onFailure: (code, msg) => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        sdkLogger.withFields({ duration }).log(`getHdmiStatus failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                        timerId = clearTimer(timerId);
+                        reject(new SenzaError(code, msg));
+                    }
+                });
+                sdkLogger.log(`window.cefQuery for getHdmiStatus returned query id ${queryId}`);
+                const timeout = API_CONFIRMATION_TIMEOUT_MS + 1000;
+                timerId = setTimeout(() => {
+                    sdkLogger.log(`getHdmiStatus reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new SenzaError(6000, `getHdmiStatus reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+    }
+
     reboot() {
         return new Promise((resolve, reject) => {
             if (window.cefQuery) {
@@ -173,12 +344,12 @@ class DeviceManager extends DeviceManagerInterface {
                     reject(`factoryReset failed: ${code} ${msg}`);
                 }
             });
-
+            const timeout = API_CONFIRMATION_TIMEOUT_MS + 1000;
             timeoutHandler = setTimeout(() => {
-                logger.error(`factoryReset failed: reached timeout of ${FACTORY_RESET_TIMEOUT_SECONDS * 1000} ms`);
+                logger.error(`factoryReset failed: reached timeout of ${timeout} ms`);
                 window.cefQueryCancel(queryId);
-                reject(`factoryReset failed: reached timeout of ${FACTORY_RESET_TIMEOUT_SECONDS * 1000} ms`);
-            }, FACTORY_RESET_TIMEOUT_SECONDS * 1000);
+                reject(`factoryReset failed: reached timeout of ${timeout} ms`);
+            }, timeout);
         });
     }
 

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
@@ -30,6 +54,16 @@ export class DeviceManager extends EventTarget {
 
     }
 
+    /**
+     * Get the current HDMI status from the connector
+     * @return {Promise<HdmiStatus>} Promise which is resolved when getHdmiStatus has been successfully performed
+     * Failure to getHdmiStatus for any reason, results in the promise being rejected.
+     * @private
+     */
+    getHdmiStatus() {
+        return noop("DeviceManager.getHdmiStatus");
+    }
+
     /**
      * Reboot the device
      * @return {Promise} Promise which is resolved when the reboot command has been successfully processed.

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.4.2-efcb53d.0";
+export const version = "4.4.4-86e7d7a.0";