senza-sdk 4.6.0 → 4.6.1

package/package.json

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

package/src/implementation/api.js

@@ -143,7 +143,7 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         await Promise.all([
             lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent),
             remotePlayer._init(sessionInfoObj, triggerEvent),
-            displayManager._init()
+            displayManager._init(triggerEvent)
         ]);
 
         alarmManager._init();

package/src/implementation/displayManager.js

@@ -38,13 +38,20 @@ export class DisplayManager extends DisplayManagerInterface {
         }
     }
 
-    async _init() {
+    async _init(triggerEvent) {
         const enableCec = sessionInfo?.sessionInfoObj?.settings?.client?.hdmi?.cec?.enable_cec;
         if (enableCec === false) {
             sdkLogger.log("CEC disabled via config (client.hdmi.cec.enable_cec=false), skipping DisplayManager init");
             this._setDisplayProperties({ connection: this.DisplayConnectionStatus.UNKNOWN });
             return;
         }
+        // An endOfSession session runs after the connector is gone and never gets another one, so
+        // the display-info request could only be answered by something that is no longer there.
+        if (triggerEvent?.type === "endOfSession") {
+            sdkLogger.log("Session was triggered by endOfSession, no connector to query, skipping DisplayManager init");
+            this._setDisplayProperties({ connection: this.DisplayConnectionStatus.UNKNOWN });
+            return;
+        }
         sdkLogger.log("Initializing DisplayManager");
         await this._updateDisplayInfo();
         if (!this._isInitialized) {

package/src/implementation/remotePlayer.js

@@ -1254,6 +1254,67 @@ class RemotePlayer extends RemotePlayerInterface {
         return this._pause();
     }
 
+    /**
+     * Mute or unmute the remote player audio stream.
+     * This API can be called in any player load state (including not loaded).
+     * Muting sets the remote player volume to zero while keeping audio download/sync behavior intact.
+     * The mute state persists across content changes and remains in effect until unmute is called.
+     * @param {boolean} muted true to mute, false to unmute
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     */
+    mute(muted) {
+        if (!this._isInitialized) {
+            throw new RemotePlayerError(6500, "Cannot call mute() if remote player is not initialized");
+        }
+        if (typeof muted !== "boolean") {
+            throw new RemotePlayerError(6503, `mute() expected boolean muted parameter but got ${typeof muted}`);
+        }
+
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            logger.log(`remotePlayer mute: sending mute request muted=${muted}`);
+            const message = {
+                type: "remotePlayer.mute",
+                class: "remotePlayer",
+                action: "mute",
+                fcid: FCID,
+                muted
+            };
+            const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
+            return new Promise((resolve, reject) => {
+                let timerId = 0;
+                const timeBeforeSendingRequest = Date.now();
+                const queryId = window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: () => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`mute completed successfully after ${duration} ms`);
+                        timerId = clearTimer(timerId);
+                        resolve();
+                    },
+                    onFailure: (code, msg) => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`mute failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                        timerId = clearTimer(timerId);
+                        reject(new RemotePlayerError(code, msg));
+                    }
+                });
+                logger.log(`window.cefQuery for mute returned query id ${queryId}`);
+                const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                timerId = setTimeout(() => {
+                    logger.log(`mute reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new RemotePlayerError(6000, `mute reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+        sdkLogger.error("remotePlayer mute: window.cefQuery is undefined");
+        return Promise.resolve(undefined);
+    }
+
     /** Stop playback of all streams (audio, video and subtitles).
      * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg

package/src/implementation/senzaShakaPlayer.js

@@ -577,12 +577,13 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
                 // when timeout reached start the local playback anyway
                 this._handlePlayingEvent();
             }, this._playingTimeout);
-            await this.remotePlayer.play(autoTune, switchMode)
-                .catch(error => {
-                    sdkLogger.error("Failed to play remote player:", error);
-                    this.handleSenzaError(error.code, error.message || "Unknown play error");
 
-                });
+            try {
+                await this.remotePlayer.play(autoTune, switchMode);
+            } catch (error) {
+                sdkLogger.error("Failed to play remote player:", error);
+                this.handleSenzaError(error.code, error.message || "Unknown play error");
+            }
 
             // Create a new promise that will resolve when the real play succeeds
             return returnPromise;
@@ -801,8 +802,9 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             } catch (stopError) {
                 sdkLogger.error("Error while trying to stop video element playback:", stopError);
             }
-            // Handle error while waiting for play event. If the error is not critical or the system is configured not to stop remote player on error,
-            //  the playback timeout will start the local playback
+        }
+
+        if (isCritical) {
             this._handlePlayPromiseError(error);
         }
 

package/src/interface/remotePlayer.js

@@ -340,6 +340,18 @@ class RemotePlayer extends EventTarget {
         return noop("RemotePlayer.pause");
     }
 
+    /** Mute or unmute the remote player audio stream.
+     * This API can be called in any player load state (including not loaded).
+     * Muting sets the remote player volume to zero while keeping audio download/sync behavior intact.
+     * The mute state persists across content changes and remains in effect until unmute is called.
+     * @param {boolean} muted true to mute, false to unmute
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     */
+    async mute(muted) {
+        return noop("RemotePlayer.mute", muted);
+    }
+
     /** Stop playback of all streams (audio, video and subtitles).
      * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.6.0";
+export const version = "4.6.1";