senza-sdk 4.4.4-86e7d7a.0 → 4.4.5

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.5",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -23,17 +23,18 @@
         "version:output": "echo 'export const version = \"'$npm_package_version'\";' > src/interface/version.js"
     },
     "devDependencies": {
-        "@babel/cli": "^7.13.16",
-        "@babel/core": "7.18.6",
-        "@babel/plugin-transform-modules-commonjs": "^7.16.8",
-        "@babel/preset-env": "^7.14.1",
+        "@babel/cli": "^7.22.0",
+        "@babel/core": "^7.22.0",
+        "@babel/plugin-transform-modules-commonjs": "^7.22.0",
+        "@babel/preset-env": "^7.22.0",
         "@eslint/eslintrc": "^3.3.0",
         "@eslint/js": "^9.22.0",
-        "babel-jest": "^27.5.1",
+        "babel-jest": "^30.2.0",
         "eslint": "^9.22.0",
         "eslint-plugin-jest": "^28.11.0",
         "globals": "^16.0.0",
-        "jest": "^27.5.1",
+        "jest": "^30.2.0",
+        "jest-environment-jsdom" : "^30.2.0",
         "jsdoc-to-markdown": "^7.1.1",
         "webpack": "^5.72.1",
         "webpack-cli": "^5.1.4"

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,14 @@ 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";
+import { backgroundRenderControl } from "./backgroundRenderControl.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 +104,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 +142,8 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         await remotePlayer._init(sessionInfoObj, triggerEvent);
         alarmManager._init();
         messageManager._init();
-        deviceManager._init();
+        backgroundRenderControl._init();
+        await displayManager._init();
         sdkLogger.log("All submodules initialized");
 
 

package/src/implementation/backgroundRenderControl.js

@@ -0,0 +1,113 @@
+import { lifecycle } from "./lifecycle.js";
+import { sdkLogger } from "./utils.js";
+import { sessionInfo } from "./SessionInfo";
+
+/**
+ * Internal background render control.
+ * Listens to lifecycle state changes and disables animation / video rendering when in background mode.
+ * Specifically it pauses CSS animations and hides video elements to reduce CPU/GPU load
+ *
+ * For remote-gpu deployments this reduces the CPU use in background mode from 6 cores to 0.4 cores.
+ *
+ * Extra CPU can be saved by also overriding requestAnimationFrame and slowing down time.
+ * This has the effect of ensuring the segments are downloaded at a slower pace
+ * - or not at all if you actually pause video, but these may have more complicated state and audio sync issues.
+ * Either way if you slow the decoding speed then we save more CPU by not doing as much SW video decoding,
+ * but the bulk is saved by the hidden video elements.
+ * See comments on https://jira01.engit.synamedia.com/browse/HSDEV-16827 for more about a PoC / spike that did this.
+ *
+ * As it stands, the current implementation that gets us 0.4 cores in background mode for remote-gpu is a good compromise of complexity vs benefit.
+ * It also roughly matches GPU mode background CPU use (maybe slightly better).
+ * GPU mode with this feature enabled (from my testing) saves about 0.15 cores ~0.45 -> ~0.30 cores
+ *
+ * This module uses the following settings:
+ * {
+ *   "ui-streamer": {
+ *     "throttleRenderingInBackground": {
+ *       "enabled": true,            // enable or disable the feature
+ *     }
+ *   }
+ * }
+ */
+class BackgroundRenderControl {
+
+    /** initialised
+     * @type {boolean}
+     * @private
+     * Whether the instance has been initialized.
+     */
+    _initialized = false;
+
+    /**
+     * @type {boolean}
+     * @private
+     * Whether render control is enabled.
+     */
+    _enabled = false;
+
+    /**
+     * @type {boolean}
+     * @private
+     * Whether rendering is currently active.
+     */
+    _active = true;
+
+    /** @type {string|null}
+     * @private
+     * Stores the last known lifecycle state.
+     */
+    _lastState = null;
+
+    /** @type {Function}
+     * @private
+     * Event listener for lifecycle state changes.
+     */
+    _listener = (e) => this._handleStateChange(e.state);
+
+    _init() {
+        if (this._initialized) return;
+        this._enabled = sessionInfo?.sessionInfoObj.settings?.["ui-streamer"]?.throttleRenderingInBackground?.enabled ?? false;
+        sdkLogger.log(`Initializing BackgroundRenderControl: enabled=${this._enabled}`);
+        if (!this._enabled) return;
+        this._lastState = lifecycle.state;
+        lifecycle.addEventListener("onstatechange", this._listener);
+        this._initialized = true;
+    }
+
+    _handleStateChange(state) {
+        if (!this._enabled) return;
+        if (state === this._lastState) return;
+        this._lastState = state;
+        try {
+            if (state === lifecycle.UiState.FOREGROUND) this._onForeground();
+            else if (state === lifecycle.UiState.BACKGROUND) this._onBackground();
+        } catch (err) {
+            sdkLogger.error("BackgroundRenderControl state handling error", err);
+        }
+    }
+
+    _onForeground() {
+        if (this._active) return;
+        sdkLogger.log("BackgroundRenderControl resume rendering");
+        this._active = true;
+        const style = document.getElementById("hs-sdk-bg-render-styles");
+        if (style) style.remove();
+    }
+
+    _onBackground() {
+        if (!this._active) return;
+        sdkLogger.log("BackgroundRenderControl throttle rendering");
+        this._active = false;
+        if (!document.getElementById("hs-sdk-bg-render-styles")) {
+            const style = document.createElement("style");
+            style.id = "hs-sdk-bg-render-styles";
+            style.textContent = `
+            * { animation-play-state: paused !important; transition: none !important; scroll-behavior: auto !important; }
+            canvas, video, img { visibility: hidden !important; }
+            `;
+            document.head.appendChild(style);
+        }
+    }
+}
+
+export const backgroundRenderControl = new BackgroundRenderControl();

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);
         });
     }