senza-sdk 4.5.0 → 4.5.1

package/package.json

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

package/src/implementation/lifecycle.js

@@ -757,6 +757,7 @@ class Lifecycle extends LifecycleInterface {
                         class: "remotePlayer",
                         action: "stop",
                         streamType: remotePlayer._isAudioSyncEnabled() ? StreamType.VIDEO | StreamType.SUBTITLE : StreamType.AUDIO | StreamType.VIDEO | StreamType.SUBTITLE,
+                        switchMode: remotePlayer._isAudioSyncEnabled() ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS,
                         fcid: FCID
                     };
                     let timerId = 0;

package/src/implementation/overlay.js

@@ -7,15 +7,49 @@ class Overlay extends OverlayInterface {
 
         this._element = null;
         this._configuration = {
-            useTransparency: true
+            useTransparency: true,
+            autoRefreshSeconds: 2
         };
+        this._retryGeneration = 0;
+        this._retryTimerId = null;
     }
 
     _isTransparencyEnabled() {
         return this._configuration.useTransparency !== false;
     }
 
-    _sendFrame(x, y, width, height) {
+    _clearRetryTimers() {
+        this._retryGeneration++;
+        clearTimeout(this._retryTimerId);
+        this._retryTimerId = null;
+    }
+
+    _scheduleRetries(maxMs) {
+        const startTime = Date.now();
+        let delay = 100;
+        const generation = ++this._retryGeneration;
+
+        const scheduleNext = () => {
+            if (this._retryGeneration !== generation) return;
+            const elapsed = Date.now() - startTime;
+            if (elapsed + delay > maxMs) return;
+
+            this._retryTimerId = setTimeout(async () => {
+                if (this._retryGeneration !== generation) return;
+                try {
+                    await this._renderFrame(true);
+                } catch (err) {
+                    sdkLogger.log(`Overlay: conditional refresh error: ${err}`);
+                }
+                delay *= 2;
+                scheduleNext();
+            }, delay);
+        };
+
+        scheduleNext();
+    }
+
+    _sendFrame(x, y, width, height, conditional = false) {
         if (window.cefQuery) {
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
@@ -26,7 +60,8 @@ class Overlay extends OverlayInterface {
                     width,
                     height,
                     useTransparency: this._isTransparencyEnabled(),
-                    fcid: FCID
+                    fcid: FCID,
+                    conditional
                 };
                 const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
                 window.cefQuery({
@@ -44,18 +79,25 @@ class Overlay extends OverlayInterface {
         return Promise.reject("Overlay is not supported if NOT running e2e");
     }
 
-    _renderFrame() {
+    _renderFrame(conditional = false) {
         if (!this._element) {
             return Promise.reject("No element configured");
         }
         const rect = this._element.getBoundingClientRect();
         const frame = this._normalizeFrame(rect);
 
-        sdkLogger.log(`Overlay: rendering frame x=${frame.x} y=${frame.y} width=${frame.width} height=${frame.height}`);
-        return this._sendFrame(frame.x, frame.y, frame.width, frame.height).then(() => {
-            const refreshEvent = new Event("refresh");
-            refreshEvent.frame = frame;
-            this.dispatchEvent(refreshEvent);
+        if (frame.width === 0 || frame.height === 0) {
+            sdkLogger.warn(`Overlay: skipping frame with zero size (width=${frame.width}, height=${frame.height})`);
+            return Promise.resolve(false);
+        }
+
+        sdkLogger.log(`Overlay: rendering frame x=${frame.x} y=${frame.y} width=${frame.width} height=${frame.height} (conditional=${conditional})`);
+        return this._sendFrame(frame.x, frame.y, frame.width, frame.height, conditional).then(() => {
+            if (!conditional) {
+                const refreshEvent = new Event("refresh");
+                refreshEvent.frame = frame;
+                this.dispatchEvent(refreshEvent);
+            }
             return true;
         });
     }
@@ -65,8 +107,8 @@ class Overlay extends OverlayInterface {
 
         const x = Math.round(toFiniteNumber(rect.x));
         const y = Math.round(toFiniteNumber(rect.y));
-        const width = Math.max(1, Math.round(toFiniteNumber(rect.width)));
-        const height = Math.max(1, Math.round(toFiniteNumber(rect.height)));
+        const width = Math.round(toFiniteNumber(rect.width));
+        const height =Math.round(toFiniteNumber(rect.height));
 
         return { x, y, width, height };
     }
@@ -78,6 +120,11 @@ class Overlay extends OverlayInterface {
             normalizedConfiguration.useTransparency = normalizedConfiguration.useTransparency !== false;
         }
 
+        if (Object.prototype.hasOwnProperty.call(normalizedConfiguration, "autoRefreshSeconds")) {
+            const v = normalizedConfiguration.autoRefreshSeconds;
+            normalizedConfiguration.autoRefreshSeconds = (typeof v === "number" && v >= 0) ? v : this._configuration.autoRefreshSeconds;
+        }
+
         this._configuration = { ...this._configuration, ...normalizedConfiguration };
     }
 
@@ -111,6 +158,7 @@ class Overlay extends OverlayInterface {
             return Promise.reject(errorMsg);
         }
 
+        this._clearRetryTimers();
         this._element = null;
 
         return Promise.resolve(true);
@@ -122,11 +170,20 @@ class Overlay extends OverlayInterface {
             sdkLogger.error(errorMsg);
             return Promise.reject(errorMsg);
         }
-        return this._renderFrame();
+        this._clearRetryTimers();
+        const result = await this._renderFrame();
+        if (result === true) {
+            const maxMs = (this._configuration.autoRefreshSeconds ?? 0) * 1000;
+            if (maxMs > 0) {
+                this._scheduleRetries(maxMs);
+            }
+        }
+        return result;
     }
 
     async removeAllElements() {
         sdkLogger.log("Overlay: removing all elements");
+        this._clearRetryTimers();
         this._element = null;
     }
 
@@ -162,6 +219,7 @@ class Overlay extends OverlayInterface {
      * @returns {Promise<boolean>} Resolves to true if successful, rejects with error if failed.
      */
     hideOverlay() {
+        this._clearRetryTimers();
         return this._sendHideOverlay();
     }
 

package/src/implementation/remotePlayer.js

@@ -1021,7 +1021,7 @@ class RemotePlayer extends RemotePlayerInterface {
         }
         // if load in background is supported, play called while state is in background should include all streams
         const backgroundStreamType = this.textTrackVisibility ? (StreamType.AUDIO | StreamType.VIDEO | StreamType.SUBTITLE) : (StreamType.AUDIO | StreamType.VIDEO);
-        const streamType = backgroundLoadSupported ? backgroundStreamType : StreamType.AUDIO;
+        const streamType = (backgroundLoadSupported && !isForegroundState) ? backgroundStreamType : StreamType.AUDIO;
 
         return this._play(streamType, switchMode);
     }

package/src/implementation/senzaShakaPlayer.js

@@ -504,6 +504,18 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
 
     }
 
+    _hasActiveTrackForLanguageAndRole(tracks, language, role) {
+        const activeTrack = tracks.find(track => track.active);
+        if (!activeTrack) {
+            return false;
+        }
+
+        if ((!role || activeTrack.roles?.includes(role)) && activeTrack.language === language) {
+            return true;
+        }
+
+        return false;
+    }
 
     _attach(videoElement) {
         this.videoElement = videoElement;
@@ -525,7 +537,10 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
                     this.handleSenzaError(error.code, error.message || "Unknown play error");
                     throw error;
                 });
-                return this._originalPlay.call(this.videoElement);
+                this._originalPlay.call(this.videoElement).catch(error => {
+                    this.handleSenzaError(error.code, error.message || "Unknown play error");
+                });
+                return;
             }
 
             if (this.remotePlayer._isPlaying) {
@@ -620,7 +635,6 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         return [...new Set(tracks.map(item => item.lang))];
     }
 
-
     selectVariantTrack(track, clearBuffer = false, safeMargin = 0) {
         const audioLang = track.language;
         const audioRole = Array.isArray(track.audioRoles) && track.audioRoles.length > 0
@@ -632,8 +646,11 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         const apCode = this._getAccessibilityCodeFromPurpose(track.accessibilityPurpose);
         remotePlayer.selectAudioLanguage(audioLang, audioRole, apCode);
 
-        super.selectVariantTrack(track, clearBuffer, safeMargin);
-
+        if (track && !track.active) {
+            super.selectVariantTrack(track, clearBuffer, safeMargin);
+        } else {
+            sdkLogger.log("selectVariantTrack() skipping local Shaka selection because track is already active");
+        }
     }
 
     selectAudioTrack(audioTrack, safeMargin = 0) {
@@ -646,13 +663,24 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         const apCode = this._getAccessibilityCodeFromPurpose(audioTrack.accessibilityPurpose);
         remotePlayer.selectAudioLanguage(audioLang, role, apCode);
 
-        super.selectAudioTrack(audioTrack, safeMargin);
+        if (audioTrack && !audioTrack.active) {
+            super.selectAudioTrack(audioTrack, safeMargin);
+        } else {
+            sdkLogger.log("selectAudioTrack() skipping local Shaka selection because track is already active");
+        }
     }
 
     selectAudioLanguage(language, role) {
         sdkLogger.log("selectAudioLanguage() Selecting audio language:", language, "with role: ", role);
         remotePlayer.selectAudioLanguage(language, role);
-        super.selectAudioLanguage(language, role);
+
+        const tracks = this.getAudioTracks();
+        sdkLogger.log("selectAudioLanguage: audio tracks", JSON.stringify(tracks), "language", language, "role", role);
+        if (!this._hasActiveTrackForLanguageAndRole(tracks, language, role)) {
+            super.selectAudioLanguage(language, role);
+        } else {
+            sdkLogger.log("selectAudioLanguage() skipping local Shaka selection because language is already active");
+        }
     }
 
     selectTextTrack(textTrack) {
@@ -665,12 +693,22 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         const apCode = this._getAccessibilityCodeFromPurpose(textTrack.accessibilityPurpose);
         remotePlayer.selectTextLanguage(textLang, role, apCode);
 
-        super.selectTextTrack(textTrack);
+        if (textTrack && !textTrack.active) {
+            super.selectTextTrack(textTrack);
+        } else {
+            sdkLogger.log("selectTextTrack() skipping local Shaka selection because track is already active");
+        }
     }
     selectTextLanguage(language, role) {
         sdkLogger.log("selectTextLanguage() Selecting text language:", language, "with role: ", role);
         remotePlayer.selectTextLanguage(language, role);
-        super.selectTextLanguage(language, role);
+        const tracks = this.getTextTracks();
+        sdkLogger.log("selectTextLanguage: text tracks", JSON.stringify(tracks));
+        if (!this._hasActiveTrackForLanguageAndRole(tracks, language, role)) {
+            super.selectTextLanguage(language, role);
+        } else {
+            sdkLogger.log("selectTextLanguage() skipping local Shaka selection because language is already active");
+        }
     }
 
     setTextTrackVisibility(visible) {

package/src/interface/overlay.js

@@ -46,6 +46,14 @@ class Overlay extends EventTarget {
      * This is useful when the element's content or position has changed.
      * The overlay must have an element registered before calling refresh.
      *
+     * After the initial capture, conditional retries are automatically scheduled using
+     * exponential backoff (starting at 100 ms, doubling each step) until the window
+     * configured by `configure({ autoRefreshSeconds })` expires (default: 2 seconds).
+     * Each retry is skipped by the UI-Streamer unless the browser has repainted since
+     * the last non-conditional capture, eliminating redundant JPEG encodes.
+     * Pending retries are cancelled by a subsequent call to refresh(), hideOverlay(),
+     * or removeElement().
+     *
      * @returns {Promise<boolean>} Resolves to true if successful, rejects with error if failed.
      */
     refresh() {
@@ -77,6 +85,9 @@ class Overlay extends EventTarget {
      * @param {Object} configuration - The new configuration to apply.
      * @param {boolean} [configuration.useTransparency=true] - Controls whether the overlay should be rendered with transparency.
      * When set to `true`, the value is forwarded to UI-Streamer in `displayOverlay` requests.
+     * @param {number} [configuration.autoRefreshSeconds=2] - Maximum window in seconds for automatic
+     * conditional retries after each refresh() call. Retries are spaced with exponential backoff
+     * starting at 100 ms. Set to 0 to disable automatic retries.
      */
     configure(configuration) {
         noop(configuration);

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.5.0";
+export const version = "4.5.1";