senza-sdk 4.5.9 → 4.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.5.9",
+    "version": "4.6.0",
     "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()
+        ]);
+
         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 {
@@ -38,6 +39,12 @@ export class DisplayManager extends DisplayManagerInterface {
     }
 
     async _init() {
+        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;
+        }
         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 });
@@ -1641,14 +1656,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 +1953,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 +1985,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 +2022,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 +2115,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 +2182,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.
@@ -820,6 +835,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/version.js

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