senza-sdk 4.5.9 → 4.6.1

package/package.json

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

package/src/implementation/api.js

@@ -60,7 +60,7 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
 
     if (window.cefQuery) {
 
-        // First, check compatability with ui-streamer api version
+        // First, check compatibility with ui-streamer api version
         await new Promise((resolve, reject) => {
             window.cefQuery({
                 request: "apiVersion " + API_VERSION,
@@ -140,13 +140,15 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
             }
         }
 
-        // Initialize lifecycle first to make sure the state is updated.
-        await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
-        await remotePlayer._init(sessionInfoObj, triggerEvent);
+        await Promise.all([
+            lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent),
+            remotePlayer._init(sessionInfoObj, triggerEvent),
+            displayManager._init(triggerEvent)
+        ]);
+
         alarmManager._init();
         messageManager._init();
         backgroundRenderControl._init();
-        await displayManager._init();
         sdkLogger.log("All submodules initialized");
 
 

package/src/implementation/displayManager.js

@@ -4,6 +4,7 @@ import { parseEdid } from "./edidParser";
 import { EventListenersManager } from "./eventListenersManager";
 import { bus, Events } from "./eventBus";
 import { lifecycle } from "./lifecycle";
+import { sessionInfo } from "./SessionInfo";
 
 
 export class DisplayManager extends DisplayManagerInterface {
@@ -37,7 +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

@@ -29,6 +29,7 @@ const MULTI_SEEK_DELAY_MSEC = 250;
 const LOAD_START_SYNC_DIFF = 1;
 const INVALID_SET_PLAYABLE_URI_CODE = 99;
 export const ONE_DAY_SECONDS = 86400;
+export const VOD_INIT_SEEK_EPSILON_SEC = 1;
 const BACKGROUND_LOAD_MIN_SDK_VERSION = "4.5.0";
 
 // Default timeout for waiting for the remote player confirmation
@@ -145,6 +146,14 @@ class RemotePlayer extends RemotePlayerInterface {
          */
         this._isSeekingByPlatform = false;
 
+        /**
+         * Start position (seconds) from the most recent load(). Used to ignore the local player's
+         * first seeking event when VOD is loaded from a non-zero position (Shaka init seek).
+         * @type {number}
+         * @private
+         */
+        this._loadStartPosition = 0;
+
         /**
          * @type {boolean}
          * @description field indicating if the remote player is playing abr or not. Should be changed when starting/stoping playback
@@ -225,14 +234,18 @@ class RemotePlayer extends RemotePlayerInterface {
         this._autoTune = false;
 
         this._isPlaying = window?.sessionStorage?.getItem("senzaSdk_isPlaying") === "true";
+        this._textTrackVisibility = window?.sessionStorage?.getItem("senzaSdk_textTrackVisibility") === "true";
         if (this._isPlaying) {
             this._playbackPositionAnchor = getPlaybackInfo()?.playbackPosition || 0;
             this._startPlaybackClock();
+
+            // UI release while playing: local player may load and seek; seed load start so that seek is treated as init.
+            this._loadStartPosition = this.currentTime;
         } else {
             this._stopPlaybackClock();
         }
 
-        sdkLogger.info(`RemotePlayer initialized with load mode: ${this._loadMode}, senzaSdk_isPlaying: ${this._isPlaying}`);
+        sdkLogger.info(`RemotePlayer initialized with load mode: ${this._loadMode}, senzaSdk_isPlaying: ${this._isPlaying}, senzaSdk_textTrackVisibility: ${this._textTrackVisibility}`);
         this._loadedUrl = playerState?.playbackUrl || "";
         // Make sure that the event listeners are registered only once
         if (!this._isInitialized) {
@@ -601,6 +614,7 @@ class RemotePlayer extends RemotePlayerInterface {
         this._isSeekingByPlatform = false;
         this._isSeekingByApplication = false;
         this._isPlayingEventPending = false;
+        this._loadStartPosition = 0;
         this._stopPlaybackClock();
         this._playbackPositionAnchor = 0;
     }
@@ -949,6 +963,7 @@ class RemotePlayer extends RemotePlayerInterface {
             this._changePlayMode(false);
             return new Promise((resolve, reject) => {
                 const playbackPosition = position || 0;
+                this._loadStartPosition = playbackPosition;
                 if (reset) {
                     // first, zero playback position
                     setPlaybackInfo({ playbackPosition: 0 });
@@ -1239,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
@@ -1641,14 +1717,33 @@ class RemotePlayer extends RemotePlayerInterface {
         // Convert to boolean in case apps pass 0/1 instead false/true.
         const newVisibility = !!visible;
 
+        this._textTrackVisibility = newVisibility;
+        window?.sessionStorage?.setItem("senzaSdk_textTrackVisibility", String(newVisibility));
+
         if (oldVisibility === newVisibility) {
             return;
         }
 
-        this._textTrackVisibility = newVisibility;
-        if (!this._textTrackVisibility) {
-            // Setting the visibility to false clears any previous selections user has done
-            this._selectedSubtitlesTrack = "";
+        if (this._remotePlayerApiVersion <= 2) {
+            if (!this._textTrackVisibility) {
+                // For older versions, we need to clear the selected subtitles track
+                this._selectedSubtitlesTrack = "";
+            }
+            return;
+        }
+
+        if (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND) {
+            if (!this._textTrackVisibility) {
+                this._stop(StreamType.SUBTITLE).catch((error) => {
+                    sdkLogger.warn(`remotePlayer setTextTrackVisibility: stop subtitles failed with error ${error.message}.`);
+                });
+            } else {
+                this._play(StreamType.SUBTITLE).catch((error) => {
+                    sdkLogger.warn(`remotePlayer setTextTrackVisibility: play subtitles failed with error ${error.message}.`);
+                });
+            }
+        } else {
+            sdkLogger.info("remotePlayer setTextTrackVisibility V3+: not updating remote subtitle stream outside background");
         }
     }
 
@@ -1919,16 +2014,24 @@ class RemotePlayer extends RemotePlayerInterface {
             this._pendingSeekPosition = playbackPosition;
             this._setPlaybackPositionAnchor(playbackPosition);
             // If the local player is just initializing after loading the manifest, ignore the seeking event.
-            if (this._localPlayerLoadCurrentTime === 0 && this._videoElement.currentTime > ONE_DAY_SECONDS) {
-                sdkLogger.info(`Seeking ignored for video currentTime init: currentTime: ${this._videoElement.currentTime}`);
-                this._localPlayerLoadCurrentTime = this._videoElement.currentTime;
-                // if the difference between the remote player and the video element current time is greater than the load start sync diff (default 1 second), seek to the remote player current time
-                if (this._isPlaying && this.currentTime > 0 && Math.abs(this._videoElement.currentTime - this.currentTime) > this._loadStartSyncDiff) {
-                    sdkLogger.info(`Remote player is playing, seeking from ${this._videoElement.currentTime} to ${this.currentTime}`);
-                    this._isSeekingByPlatform = true;
-                    this._videoElement.currentTime = this.currentTime;
+            // Live: Shaka jumps from 0 to a UTC wall-clock time (> one day in seconds).
+            // VOD: load(url, startPosition) causes Shaka to seek near that start position (within epsilon).
+            if (this._videoElement) {
+                const currentTime = this._videoElement.currentTime;
+                const isLiveInitSeek = this._localPlayerLoadCurrentTime === 0 && currentTime > ONE_DAY_SECONDS;
+                const isVodInitSeek = this._localPlayerLoadCurrentTime === 0 && this._loadStartPosition > 0 && Math.abs(currentTime - this._loadStartPosition) <= VOD_INIT_SEEK_EPSILON_SEC;
+                sdkLogger.info(`Check for init seek: currentTime: ${currentTime}, loadStartPosition: ${this._loadStartPosition}, isLiveInitSeek: ${isLiveInitSeek}, isVodInitSeek: ${isVodInitSeek}`);
+                if (isLiveInitSeek || isVodInitSeek) {
+                    sdkLogger.info(`Seeking ignored for video currentTime init: currentTime: ${currentTime}, loadStartPosition: ${this._loadStartPosition}`);
+                    this._localPlayerLoadCurrentTime = currentTime;
+                    // if the difference between the remote player and the video element current time is greater than the load start sync diff (default 1 second), seek to the remote player current time
+                    if (isLiveInitSeek && this._isPlaying && this.currentTime > 0 && Math.abs(currentTime - this.currentTime) > this._loadStartSyncDiff) {
+                        sdkLogger.info(`Remote player is playing, seeking from ${currentTime} to ${this.currentTime}`);
+                        this._isSeekingByPlatform = true;
+                        this._videoElement.currentTime = this.currentTime;
+                    }
+                    return;
                 }
-                return;
             }
         }
         const backgroundSeekSupported = isAppVersionAboveOrEqual(this._deviceAppVersion, backgroundSeekMinClientAppVersion);
@@ -1943,6 +2046,31 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
+    /**
+     * Resolve the initial target playing state from current playback and lifecycle state.
+     *
+     * | _isPlaying | lifecycle.state             | _inTransitionToForeground | Result       |
+     * |------------|-----------------------------|---------------------------|--------------|
+     * | false      | any                         | any                       | PAUSED       |
+     * | true       | FOREGROUND                  | any                       | PLAYING_UI   |
+     * | true       | BACKGROUND                  | true                      | PLAYING_UI   |
+     * | true       | BACKGROUND                  | false                     | PLAYING_ABR  |
+     * | true       | IN_TRANSITION_TO_BACKGROUND | any                       | PLAYING_ABR  |
+     *
+     * @private
+     * @returns {string} TargetPlayingState value
+     */
+    _getInitialTargetPlayingState() {
+        if (!this._isPlaying) {
+            return TargetPlayingState.PAUSED;
+        }
+        if (!lifecycle._inTransitionToForeground
+            && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+            return TargetPlayingState.PLAYING_ABR;
+        }
+        return TargetPlayingState.PLAYING_UI;
+    }
+
     /** Performs the seek operation which comprises the following steps:
      *  1) Possible pause if playing
      *  2) Wait for any further changes in the currentTime
@@ -1955,16 +2083,7 @@ class RemotePlayer extends RemotePlayerInterface {
      * */
     async _atomicSeek() {
         sdkLogger.info("Seeking: local video element seeking start while isPlaying: ", this._isPlaying);
-        if (this._isPlaying) {
-            if (!(lifecycle._inTransitionToForeground || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND) && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
-                sdkLogger.info("seek in background", this._isPlaying);
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-            } else {
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-            }
-        } else {
-            this._targetSeekPlayingState = TargetPlayingState.PAUSED;
-        }
+        this._targetSeekPlayingState = this._getInitialTargetPlayingState();
 
         // The platform could be currently syncing audio/video using playback rate. Reset when performing seek.
         if (this._videoElement) {
@@ -2057,7 +2176,7 @@ class RemotePlayer extends RemotePlayerInterface {
             return Promise.resolve();
         }
 
-        this._targetSetAudioPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        this._targetSetAudioPlayingState = this._getInitialTargetPlayingState();
         sdkLogger.log(`remotePlayer _atomicSetAudioLanguage: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetAudioPlayingState}`);
 
         this._abortSetAudioLanguage = false;
@@ -2124,7 +2243,7 @@ class RemotePlayer extends RemotePlayerInterface {
             return Promise.resolve();
         }
 
-        this._targetSetSubtitlePlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        this._targetSetSubtitlePlayingState = this._getInitialTargetPlayingState();
         sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetSubtitlePlayingState}`);
 
         this._abortSetSubtitleLanguage = false;

package/src/implementation/senzaShakaPlayer.js

@@ -1,7 +1,7 @@
 import { SenzaShakaPlayer as SenzaShakaInterface, shaka } from "../interface/senzaShakaPlayer";
 import * as shakaDebug from "shaka-player/dist/shaka-player.compiled.debug.js";
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
-import { ONE_DAY_SECONDS } from "./remotePlayer.js";
+import { ONE_DAY_SECONDS, VOD_INIT_SEEK_EPSILON_SEC } from "./remotePlayer.js";
 import { sdkLogger, SwitchMode } from "./utils";
 import moment from "moment";
 import set from "lodash.set";
@@ -156,12 +156,19 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
     _seekCounterAfterLoad = 0;
 
     /**
-     * When true, the next `seeked` is Shaka jumping to live-edge time after load; skip background pause logic.
+     * When true, the next `seeked` is Shaka jumping to live-edge / VOD startTime after load; skip background pause logic.
      * @private
      * @type {boolean}
      */
     _ignoreNextSeekedForInit = false;
 
+    /**
+     * Start position (seconds) from the most recent load(). Used to ignore Shaka's VOD init seeking/seeked.
+     * @private
+     * @type {number}
+     */
+    _loadStartPosition = 0;
+
     /**
      * Whether the player should call lifecycle.moveToForeground on pause, remote ended/error, unload, and destroy.
      * Only when auto-background is enabled (including streamer overrides) and the UI moved to background via the
@@ -185,8 +192,16 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             this._ignoreNextSeekedForInit = false;
         },
         "seeking": () => {
-            // If the first seeking after load started from time 0, and the current time is a UTC time (live asset), ignore the next seeked event to avoid background pause logic.
-            if (this._seekCounterAfterLoad < 1 && this._loadStartedAtZero && this.videoElement.currentTime > ONE_DAY_SECONDS) {
+            // Ignore the first seeking after load when it is Shaka's initialization jump:
+            // - Live: currentTime is a UTC wall-clock time (> one day in seconds)
+            // - VOD: currentTime is within epsilon of this._loadStartPosition
+            const isFirstSeekAfterLoadAtZero = this._seekCounterAfterLoad < 1 && this._loadStartedAtZero;
+            const isLiveInitSeek = isFirstSeekAfterLoadAtZero && this.videoElement.currentTime > ONE_DAY_SECONDS;
+            const isVodInitSeek = isFirstSeekAfterLoadAtZero
+                && this._loadStartPosition > 0
+                && Math.abs(this.videoElement.currentTime - this._loadStartPosition) <= VOD_INIT_SEEK_EPSILON_SEC;
+            if (isLiveInitSeek || isVodInitSeek) {
+                sdkLogger.info("senzaShakaPlayer seeking: ignoring next seeked for init");
                 this._ignoreNextSeekedForInit = true;
             } else {
                 // Another seeking before seeked means this is no longer the load initialization jump.
@@ -562,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;
@@ -786,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);
         }
 
@@ -820,6 +837,9 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             startTime = -minInitialLiveOffset;
         }
 
+        // Used to ignore Shaka's init seeking/seeked when currentTime matches load start.
+        this._loadStartPosition = startTime ?? 0;
+
         // This callback will be activated when the manifest is loaded. It will trigger load of the remote player.
         // This will ensure that the remote player is loaded only after the manifest is loaded by local player.
         const responseFilterCallback = async (type, response) => {

package/src/interface/overlay.js

@@ -10,7 +10,6 @@ import { noop } from "./utils.js";
 /**
  * Overlay is a singleton class that manages displaying UI frames as image overlays. The image can be displayed over background video playback.
  * It can be used in any lifecycle state.
- * @private
  * @fires error
  */
 class Overlay extends EventTarget {

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.5.9";
+export const version = "4.6.1";