senza-sdk 4.4.4-86e7d7a.0 → 4.4.4

package/dist/implementation.bundle.js.LICENSE.txt

@@ -0,0 +1,82 @@
+/*
+ @license
+ Copyright 2006 The Closure Library Authors
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Copyright 2008 The Closure Library Authors
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Copyright 2013 Ali Al Dallal
+
+ Licensed under the MIT license.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+*/
+
+/*
+ @license
+ MSS Transmuxer
+ Copyright 2015 Dash Industry Forum
+ SPDX-License-Identifier: BSD-3-Clause
+*/
+
+/*
+ @license
+ Shaka Player
+ Copyright 2016 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Shaka Player
+ Copyright 2022 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Shaka Player
+ Copyright 2023 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Shaka Player
+ Copyright 2025 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ tXml
+ Copyright 2015 Tobias Nickel
+ SPDX-License-Identifier: MIT
+*/
+
+//! moment.js
+
+//! moment.js locale configuration

package/package.json

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

package/src/api.js

@@ -1,6 +1,6 @@
 import { sdkLogger, noop } from "./interface/utils.js";
 
-import { Lifecycle, RemotePlayer, DeviceManager, PlatformManager, AlarmManager, MessageManager, ShakaPlayer, shaka, showSequence, initSequence } from "./interface/api.js";
+import { Lifecycle, RemotePlayer, DeviceManager, PlatformManager, AlarmManager, MessageManager, ShakaPlayer, shaka, showSequence, initSequence, DisplayManager } from "./interface/api.js";
 
 import { version } from "./interface/version.js";
 
@@ -252,6 +252,18 @@ let alarmManager;
  */
 let deviceManager;
 
+/**
+ * @module
+ * @private
+ * @type {DisplayManager}
+ * @example
+ * import { displayManager } from "senza-sdk";
+ * const connection = await displayManager.connection;
+ * console.info(connection);
+ *
+ * @return {DisplayManager} pointer to the DisplayManager singleton
+ */
+let displayManager;
 
 /**
  * @module
@@ -317,6 +329,7 @@ if (!isRunningE2E()) {
     remotePlayer = new RemotePlayer();
     alarmManager = new AlarmManager();
     deviceManager = new DeviceManager();
+    displayManager = new DisplayManager();
     platformManager = new PlatformManager();
     messageManager = new MessageManager();
     ShakaPlayerImplementation = ShakaPlayer;
@@ -327,6 +340,7 @@ if (!isRunningE2E()) {
     remotePlayer = window.senzaSDKImplementation.remotePlayer;
     alarmManager = window.senzaSDKImplementation.alarmManager;
     deviceManager = window.senzaSDKImplementation.deviceManager;
+    displayManager = window.senzaSDKImplementation.displayManager;
     platformManager = window.senzaSDKImplementation.platformManager;
     messageManager = window.senzaSDKImplementation.messageManager;
     ShakaPlayerImplementation = window.senzaSDKImplementation.ShakaPlayer;
@@ -373,7 +387,7 @@ export function setTimezone(timezone) {
     }
 }
 
-export { lifecycle, remotePlayer, alarmManager, deviceManager, platformManager, messageManager, ShakaPlayerImplementation as ShakaPlayer, shakaImplementation as shaka, showSequence, initSequence };
+export { lifecycle, remotePlayer, alarmManager, deviceManager, displayManager, platformManager, messageManager, ShakaPlayerImplementation as ShakaPlayer, shakaImplementation as shaka, showSequence, initSequence };
 
 // Assign the senza library to the old name (hs) for backward compatibility
 import * as senzaSDK from "./api.js";

package/src/implementation/api.js

@@ -4,11 +4,13 @@ import { lifecycle } from "./lifecycle.js";
 import { alarmManager } from "./alarmManager.js";
 import { remotePlayer } from "./remotePlayer.js";
 import { deviceManager } from "./deviceManager.js";
+import { displayManager } from "./displayManager.js";
 import { messageManager } from "./messageManager.js";
 
 export { remotePlayer };
-export { lifecycle } from "./lifecycle.js";
+export { lifecycle };
 export { deviceManager };
+export { displayManager };
 export { platformManager } from "./platformManager.js";
 export { alarmManager };
 export { messageManager };
@@ -101,9 +103,9 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         }
 
         // Set default device manager event timeout using UI-Streamer settings
-        const deviceManagerEventTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.deviceManagerEventTimeout;
-        if (deviceManagerEventTimeout) {
-            deviceManager._setDefaultTimeout(deviceManagerEventTimeout);
+        const displayManagerEventTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.displayManagerEventTimeout;
+        if (displayManagerEventTimeout) {
+            displayManager._setDefaultTimeout(displayManagerEventTimeout);
         }
 
         // Get trigger event
@@ -139,7 +141,7 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         await remotePlayer._init(sessionInfoObj, triggerEvent);
         alarmManager._init();
         messageManager._init();
-        deviceManager._init();
+        await displayManager._init();
         sdkLogger.log("All submodules initialized");
 
 

package/src/implementation/deviceManager.js

@@ -1,16 +1,13 @@
 import { DeviceManager as DeviceManagerInterface } from "../interface/deviceManager";
-import { getFCID, sdkLogger, getRestResponse, clearTimer, SenzaError } from "./utils";
+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;
 let wifi_status_last_update = 0;
 
 const WIFI_STATUS_CACHE_SECONDS = 5;
-const API_CONFIRMATION_TIMEOUT_MS = 5000;
+const FACTORY_RESET_TIMEOUT_SECONDS = 5;
 
 async function getWifiApData() {
     // Wi-Fi access point data is static, so it needs to be retrieved only once
@@ -41,134 +38,6 @@ 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() {
@@ -188,46 +57,6 @@ 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) {
@@ -344,12 +173,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 ${timeout} ms`);
+                logger.error(`factoryReset failed: reached timeout of ${FACTORY_RESET_TIMEOUT_SECONDS * 1000} ms`);
                 window.cefQueryCancel(queryId);
-                reject(`factoryReset failed: reached timeout of ${timeout} ms`);
-            }, timeout);
+                reject(`factoryReset failed: reached timeout of ${FACTORY_RESET_TIMEOUT_SECONDS * 1000} ms`);
+            }, FACTORY_RESET_TIMEOUT_SECONDS * 1000);
         });
     }
 

package/src/implementation/displayManager.js

@@ -0,0 +1,181 @@
+import { DisplayManager as DisplayManagerInterface } from "../interface/displayManager";
+import { sdkLogger, getRestResponse } from "./utils";
+import { parseEdid } from "./edidParser";
+import { EventListenersManager } from "./eventListenersManager";
+import { bus, Events } from "./eventBus";
+import { lifecycle } from "./lifecycle";
+
+
+export class DisplayManager extends DisplayManagerInterface {
+
+    constructor() {
+        super();
+        /**
+        * Event listeners manager for the displayManager 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;
+    }
+
+    async _updateDisplayInfo() {
+        try {
+            const displayInfoResponse = await getRestResponse("display-info");
+            const displayInfo = this._parseDisplayInfo(displayInfoResponse);
+            this._setDisplayProperties(displayInfo);
+        } catch (e) {
+            sdkLogger.error(e);
+            this._setDisplayProperties({ connection: this.DisplayConnectionStatus.UNKNOWN });
+        }
+    }
+
+    async _init() {
+        sdkLogger.log("Initializing DisplayManager");
+        await this._updateDisplayInfo();
+        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/displayInfoChanged", async (event) => {
+            sdkLogger.info("Got hs/displayInfoChanged event with detail", JSON.stringify(event?.detail));
+
+            try {
+                const displayInfo = this._parseDisplayInfo(event.detail.displayInfo);
+                this._setDisplayProperties(displayInfo);
+
+                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("displayinfochanged", { displayInfo });
+
+                const callbackDuration = Date.now() - timeBeforeCallbacks;
+                sdkLogger.log(`All callbacks for displayInfoChanged are finished within ${callbackDuration}ms`);
+            } catch (error) {
+                sdkLogger.error("Failed to handle displayInfo update", error);
+            }
+
+            const isTriggering = lifecycle.triggerEvent.type === "displayInfoChanged" && 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 display manager event listeners
+    * @param {number} timeout - Timeout in milliseconds for display manager event listeners
+    * @private
+    */
+    _setDefaultTimeout(timeout) {
+        if (typeof timeout === "number" && timeout > 0) {
+            this._eventManager.timeoutMs = timeout;
+            sdkLogger.log(`displayManager event listener timeout set to ${timeout}ms`);
+        } else {
+            sdkLogger.warn(`Invalid timeout value: ${timeout}. Must be a positive number.`);
+        }
+    }
+
+    _setDisplayProperties(displayInfo) {
+
+        if (displayInfo.connection !== undefined) {
+            this.connection = displayInfo.connection;
+        }
+
+        // If the connection is disconnected/unknown, reset all the display properties
+        if (this.connection !== this.DisplayConnectionStatus.CONNECTED) {
+            this.selected = undefined;
+            this.resolution = undefined;
+            this.framerate = undefined;
+            this.security = undefined;
+            this.make = undefined;
+            this.model = undefined;
+            return;
+        }
+
+        for (const [key, value] of Object.entries(displayInfo)) {
+            if (value !== undefined) {
+                this[key] = value;
+            }
+        }
+    }
+
+    _parseDisplayInfo(displayInfoResponseStr) {
+        const displayInfoResponse = JSON.parse(displayInfoResponseStr);
+
+        const displayInfo = {
+            connection: displayInfoResponse?.connection,
+            selected: displayInfoResponse?.connectedDisplayInfo?.selected,
+            resolution: displayInfoResponse?.connectedDisplayInfo?.resolution,
+            framerate: displayInfoResponse?.connectedDisplayInfo?.framerate,
+            security: displayInfoResponse?.connectedDisplayInfo?.hdcpVersion
+        };
+
+
+        if (displayInfoResponse?.connectedDisplayInfo?.edid) {
+            try {
+                const { manufacturerName, modelName } = parseEdid(displayInfoResponse.connectedDisplayInfo.edid);
+                displayInfo.make = manufacturerName ? manufacturerName : "unknown";
+                displayInfo.model = modelName ? modelName : "unknown";
+            } catch (error) {
+                sdkLogger.error("Failed to parse EDID", error);
+                displayInfo.make = "unknown";
+                displayInfo.model = "unknown";
+            }
+        }
+        return displayInfo;
+    }
+
+    addEventListener(type, callback) {
+        this._eventManager.addEventListener(type, callback);
+    }
+
+    removeEventListener(type, callback) {
+        this._eventManager.removeEventListener(type, callback);
+    }
+}
+
+
+/**
+ * @module
+ * @type {DisplayManager}
+ * @example
+ * import { displayManager } from "senza-sdk";
+ * const connection = await displayManager.connection;
+ * console.info(connection);
+ *
+ * @return {DisplayManager} pointer to the DisplayManager singleton
+ */
+export const displayManager = new DisplayManager();