senza-sdk 4.4.2-efcb53d.0 → 4.4.3

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.2-efcb53d.0",
+    "version": "4.4.3",
     "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,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,16 @@ class DeviceManager extends DeviceManagerInterface {
         return super.deviceInfo;
     }
 
+    async getHdmiStatus() {
+        try {
+            const response = await getRestResponse("hdmi-status");
+            return this._translateHdmiStatus(response);
+        } catch (e) {
+            sdkLogger.error(e);
+            return this.HdmiStatus.UNKNOWN;
+        }
+    }
+
     reboot() {
         return new Promise((resolve, reject) => {
             if (window.cefQuery) {

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.3";