senza-sdk 4.2.59 → 4.2.62

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.2.59",
+    "version": "4.2.62",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -14,7 +14,8 @@
         "prepublish": "npm run build",
         "eslint": "eslint --max-warnings 0  src test",
         "build": "npx webpack --config webpack.config.js",
-        "test": "jest --coverage"
+        "test": "jest --coverage --verbose",
+        "testall" : "jest --coverage --verbose && npm run eslint --fix"
     },
     "devDependencies": {
         "@babel/cli": "^7.13.16",

package/src/deviceManager.js

@@ -1,6 +1,6 @@
 import { getFCID, sdkLogger, getRestResponse } from "./utils";
-import {isRunningE2E} from "./api";
-import {sessionInfo} from "./SessionInfo";
+import { isRunningE2E } from "./api";
+import { sessionInfo } from "./SessionInfo";
 
 const wifiInfo = {};
 let wifi_ap_data;
@@ -290,7 +290,7 @@ class DeviceManager extends EventTarget {
     // This api is part of epic HSDEV-4185
     async getWifiInfo() {
         await Promise.all([getWifiApData(), getWifiStatus()]);
-        return {...wifi_ap_data, ...wifi_status};
+        return { ...wifi_ap_data, ...wifi_status };
     }
 }
 

package/src/lifecycle.js

@@ -670,10 +670,10 @@ class Lifecycle extends EventTarget {
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const logger = sdkLogger.withFields({ FCID });
-                logger.log("lifecycle moveToBackground: sending play action");
                 const configuration = remotePlayer.getConfiguration();
                 const audioLanguage = remotePlayer._selectedAudioTrack || configuration.preferredAudioLanguage || "";
-                const subtitlesLanguage = remotePlayer.textTrackVisibility && (remotePlayer._selectedSubtitlesTrack || configuration.preferredSubtitlesLanguage) || "";
+                const subtitlesLanguage = remotePlayer._selectedSubtitlesTrack || configuration.preferredSubtitlesLanguage || "";
+
                 let request;
                 const message = {
                     action: "play",
@@ -685,7 +685,7 @@ class Lifecycle extends EventTarget {
                     message.type = "remotePlayer.play";
                     message.class = "remotePlayer";
                     message.switchMode = remotePlayer._isAudioSyncEnabled() ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
-                    message.streamType = StreamType.AUDIO | StreamType.VIDEO | StreamType.SUBTITLE;
+                    message.streamType = remotePlayer.textTrackVisibility ? (StreamType.AUDIO | StreamType.VIDEO | StreamType.SUBTITLE) : (StreamType.AUDIO | StreamType.VIDEO);
                     request = {
                         target: "TC",
                         waitForResponse: true,
@@ -693,8 +693,12 @@ class Lifecycle extends EventTarget {
                         message: JSON.stringify(message)
                     };
                 } else {
+                    if (!remotePlayer.textTrackVisibility) {
+                        message.subtitlesLanguage = "";
+                    }
                     request = message;
                 }
+                logger.log(`lifecycle moveToBackground: sending play action audioLanguage=${message.audioLanguage} subtitlesLanguage=${message.subtitlesLanguage} textTrackVisibility=${remotePlayer.textTrackVisibility}`);
                 let timerId = 0;
                 const timeBeforeSendingRequest = Date.now();
                 const queryId = window.cefQuery({

package/src/remotePlayer.js

@@ -171,6 +171,15 @@ class RemotePlayer extends EventTarget {
          * });
          * */
 
+        /**
+         * @event RemotePlayer#playing
+         * @description playing event will be dispatched when the remote player started playback of the first audio frame. This event can be used to synchronize the local player with the remote player.
+         * @example
+         * remotePlayer.addEventListener("playing", () => {
+         *   console.info("remotePlayer playing");
+         * });
+         * */
+
         /**
          * @event RemotePlayer#loadedmetadata
          * @description loadedmetadata event will be dispatched when the remote player metadata is loaded
@@ -495,13 +504,7 @@ class RemotePlayer extends EventTarget {
         }
         if (this._availableTextTracks) {
             const selectedTrack = this._availableTextTracks.find((track) => track.selected === true);
-            if (selectedTrack) {
-                this._selectedSubtitlesTrack = selectedTrack.id;
-                this._textTrackVisibility = true;
-            } else {
-                this._selectedSubtitlesTrack = "";
-                this._textTrackVisibility = false;
-            }
+            this._selectedSubtitlesTrack = selectedTrack?.id || "";
         }
     }
 
@@ -698,12 +701,14 @@ class RemotePlayer extends EventTarget {
         if (window.cefQuery) {
             const FCID = getFCID();
             const logger = sdkLogger.withFields({ FCID });
-            logger.log("remotePlayer play: sending play action");
             const audioLanguage = this._selectedAudioTrack || this._config.preferredAudioLanguage || "";
-            let subtitlesLanguage = "";
-            if (this._textTrackVisibility) {
-                subtitlesLanguage = this._selectedSubtitlesTrack || this._config.preferredSubtitlesLanguage || "";
+            const subtitlesLanguage = this._selectedSubtitlesTrack || this._config.preferredSubtitlesLanguage || "";
+
+            if (this._remotePlayerApiVersion >= 2 && !this._textTrackVisibility && streamType === StreamType.SUBTITLE) {
+                logger.log("remotePlayer play: text track visibility is disabled and streamType is only SUBTITLE. returning early with no action.");
+                return Promise.resolve(undefined); // nothing to do
             }
+
             const message = {
                 type: "remotePlayer.play",
                 class: "remotePlayer",
@@ -718,7 +723,16 @@ class RemotePlayer extends EventTarget {
                 message.switchMode = this._isAudioSyncEnabled() ? SwitchMode.SEAMLESS : SwitchMode.NON_SEAMLESS;
                 message.streamType = streamType;
                 waitForResponse = true;
+
+                if (!this._textTrackVisibility && (message.streamType & StreamType.SUBTITLE) !== 0) {
+                    // remove SUBTITLE
+                    message.streamType = message.streamType & ~StreamType.SUBTITLE;
+                    logger.log("remotePlayer play: text track visibility is disabled. Removed SUBTITLE from streamType.");
+                }
+            } else if (!this.textTrackVisibility) {
+                message.subtitlesLanguage = "";
             }
+            logger.log(`remotePlayer play: sending play action remotePlayer._isPlaying: ${this._isPlaying} audioLanguage=${message.audioLanguage} subtitlesLanguage=${message.subtitlesLanguage} textTrackVisibility=${this.textTrackVisibility}`);
             const request = { target: "TC", waitForResponse: waitForResponse, message: JSON.stringify(message) };
             return new Promise((resolve, reject) => {
                 let timerId = 0;
@@ -947,10 +961,7 @@ class RemotePlayer extends EventTarget {
                 const playbackPosition = position ?? 0;
                 const logger = sdkLogger.withFields({ FCID, loadUrl: url, playbackPosition });
                 const audioLanguage = audioTrackId || this._selectedAudioTrack || this._config.preferredAudioLanguage || "";
-                let subtitlesLanguage = "";
-                if (this._textTrackVisibility) {
-                    subtitlesLanguage = textTrackId || this._selectedSubtitlesTrack || this._config.preferredSubtitlesLanguage || "";
-                }
+                const subtitlesLanguage = textTrackId || this._selectedSubtitlesTrack || this._config.preferredSubtitlesLanguage || "";
 
                 const message = {
                     url,
@@ -968,7 +979,7 @@ class RemotePlayer extends EventTarget {
                 } else {
                     message.type = "setPlayableUri";
                 }
-                logger.log(`remotePlayer load: sending ${message.type} request. remotePlayer._isPlaying: ${this._isPlaying}`);
+                logger.log(`remotePlayer load: sending ${message.type} request. remotePlayer._isPlaying: ${this._isPlaying} audioLanguage=${audioLanguage} subtitlesLanguage=${subtitlesLanguage}`);
                 const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
                 let timerId = 0;
                 const timeBeforeSendingRequest = Date.now();
@@ -1519,20 +1530,23 @@ class RemotePlayer extends EventTarget {
     /**
      * Enable or disable the subtitles.
      * If the player is in an unloaded state, the request will be applied next time content is played.
-     * @param {boolean} visible whether the subtitles are visible or not
-     * @throws {TypeError} if visible is not a boolean variable
+     * @param {boolean|0|1} visible whether the subtitles are visible or not
+     * @throws {TypeError} if visible is not a boolean variable or 0/1
      */
     setTextTrackVisibility(visible) {
         const oldVisibility = this._textTrackVisibility;
-        if (typeof visible !== "boolean") {
-            throw new TypeError("visible parameter must be a boolean");
+        if (typeof visible !== "boolean" && !(visible === 0 || visible === 1)) {
+            throw new TypeError("visible parameter must be a boolean or 0/1");
         }
-        const newVisibility = visible;
-        if (newVisibility === oldVisibility) {
+        // Convert to boolean in case apps pass 0/1 instead false/true.
+        const newVisibility = !!visible;
+
+        if (oldVisibility === newVisibility) {
             return;
         }
+
         this._textTrackVisibility = newVisibility;
-        if (!newVisibility) {
+        if (!this._textTrackVisibility) {
             // Setting the visibility to false clears any previous selections user has done
             this._selectedSubtitlesTrack = "";
         }

package/src/senzaShakaPlayer.js

@@ -55,35 +55,92 @@ const senzaShaka = { ...shaka };
  */
 
 export class SenzaShakaPlayer extends shaka.Player {
+    /** @private {SenzaShakaPlayer|null} Previous instance of the player */
     static _prevInstance = null;
+
     /**
      * @private
      * @type {Object.<string, string>}
-     * @description Map between audio track language and id
+     * @description Map of audio track languages to their IDs
      */
     _audioTracksMap = {};
 
     /**
      * @private
      * @type {Object.<string, string>}
-     * @description Map between text track language and id
+     * @description Map of text track languages to their IDs
      */
     _textTracksMap = {};
 
+    /**
+     * @private
+     * @type {number}
+     * @description Timeout in milliseconds to wait for playing event
+     * @default 3000
+     */
+    _playingTimeout = 3000;
+
+    /**
+     * @private
+     * @type {number|null}
+     * @description Timestamp when play was called
+     */
+    _playStartTime = null;
+
+    /**
+     * @private
+     * @type {boolean}
+     * @description Whether to stop remote player on error
+     * @default false
+     */
+    _shouldStopRemotePlayerOnError = false;
+
+    /**
+     * @private
+     * @type {Function|null}
+     * @description Original play function from video element
+     */
+    _originalPlay = null;
+
+    /**
+     * @private
+     * @type {Function|null}
+     * @description Resolve function for play promise
+     */
+    _playPromiseResolve = null;
+
+    /**
+     * @private
+     * @type {Function|null}
+     * @description Reject function for play promise
+     */
+    _playPromiseReject = null;
+
+    /**
+     * @private
+     * @type {number|null}
+     * @description Timer ID for play timeout
+     */
+    _playTimeoutId = null;
+
     /**
      * @private
      * @type {Object.<string, Function>}
-     * @description Object containing event listeners for the video element.
+     * @description Event listeners for video element
      */
     _videoEventListeners = {
         "play": () => {
-            this.remotePlayer.play()
-                .catch(error => {
-                    sdkLogger.error("Failed to play remote player:", error);
-                    this.handleSenzaError(error.code, error.message || "Unknown play error");
-                });
+            // keep old play behavior, in case playing timeout is defined as 0
+            if (this._playingTimeout === 0) {
+                this.remotePlayer.play()
+                    .catch(error => {
+                        sdkLogger.error("Failed to play remote player:", error);
+                        this.handleSenzaError(error.code, error.message || "Unknown play error");
+                    });
+            }
         },
-        "pause": () => {
+        "pause" : () => {
+            this._resetPlayPromise();
             this.remotePlayer.pause()
                 .catch(error => {
                     sdkLogger.error("Failed to pause remote player:", error);
@@ -97,7 +154,7 @@ export class SenzaShakaPlayer extends shaka.Player {
     /**
      * @private
      * @type {Object.<string, Function>}
-     * @description Object containing event listeners for the remote player.
+     * @description Event listeners for remote player
      */
     _remotePlayerEventListeners = {
         "ended": () => {
@@ -109,7 +166,6 @@ export class SenzaShakaPlayer extends shaka.Player {
         },
         "error": (event) => {
             sdkLogger.log("remotePlayer error:", event.detail.errorCode, event.detail.message);
-            // we need to move to foreground here for the auto background mode to work
             lifecycle.moveToForeground();
             this.handleSenzaError(event.detail.errorCode, event.detail.message);
         },
@@ -166,17 +222,85 @@ export class SenzaShakaPlayer extends shaka.Player {
                     this._textTracksMap[lang] = track.id;
                 }
             }
+        },
+        "playing": async () => {
+            sdkLogger.info("remotePlayer playing event received");
+            // If playing timeout was not expored, and the feature is set, handle the playing event
+            if (this._playingTimeout > 0 && this._playTimeoutId !== null) {
+                this._handlePlayingEvent();
+            }
         }
     };
 
+    /**
+     * Clears the play timeout and resets the timer ID
+     * @private
+     * @description Cancels any pending play timeout and nullifies the timeout ID
+     */
+    _clearPlayTimeout = () => {
+        if (this._playTimeoutId) {
+            sdkLogger.info("Clearing play timeout");
+            clearTimeout(this._playTimeoutId);
+            this._playTimeoutId = null;
+        }
+    };
+    /**
+     * @private
+     * @description Handles the playing event from the remote player.
+     */
+    _handlePlayingEvent = async () => {
 
+        this._clearPlayTimeout();
+
+        if (this.videoElement && this._originalPlay && this._playPromiseResolve) {
+            try {
+                const elapsedTime = Date.now() - this._playStartTime;
+                sdkLogger.info(`Time for playback start ${elapsedTime}ms`);
+                await this._originalPlay.call(this.videoElement);
+                sdkLogger.info("Video element play resolved successfully");
+                this._playPromiseResolve();
+            } catch (error) {
+                this._handlePlayPromiseError(error);
+                return;
+            } finally {
+                this._playPromiseResolve = null;
+                this._playPromiseReject = null;
+            }
+        }
+    };
     /**
-     * Flag indicating whether the remote player should be stopped when an error occurs
      * @private
-     * @type {boolean}
-     * @default false
+     * @description Resets the play promise state, clearing any existing resolve/reject functions and timeouts.
      */
-    _shouldStopRemotePlayerOnError = false;
+    _resetPlayPromise = () => {
+        if (this._playPromiseResolve) {
+            sdkLogger.info("Resolving play promise");
+            this._playPromiseResolve();
+        }
+        this._playPromiseResolve = null;
+        this._playPromiseReject = null;
+        this._clearPlayTimeout();
+    };
+
+
+    /**
+     * Handles errors for play promises and remote player events.
+     * @private
+     * @param {Error} error - The error object.
+       */
+    _handlePlayPromiseError(error) {
+
+        sdkLogger.error("Error while waiting for playing event:", error);
+        if (this._playPromiseReject) {
+            this._playPromiseReject(error);
+            this._playPromiseResolve = null;
+            this._playPromiseReject = null;
+        }
+        if (this._playTimeoutId) {
+            clearTimeout(this._playTimeoutId);
+            this._playTimeoutId = null;
+        }
+    }
 
     /**
      * Creates an instance of SenzaShakaPlayer, which is a subclass of shaka.Player.
@@ -201,15 +325,62 @@ export class SenzaShakaPlayer extends shaka.Player {
 
         this.remotePlayer = remotePlayer;
         this._addRemotePlayerEventListeners();
+        SenzaShakaPlayer._prevInstance = this;
+        const playTimeout = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"]?.playingEventTimeout;
+        this._playingTimeout = (playTimeout >= 0) ? playTimeout*1000 : this._playingTimeout;
+
         // if video element is provided, add the listeres here. In this case ,there is no need to call attach.
         if (videoElement) {
-            this.videoElement = videoElement;
-            this._attachVideoElementToRemotePlayer();
+            this._attach(videoElement);
             sdkLogger.warn("SenzaShakaPlayer constructor Adding videoElement in the constructor is going to be deprecated in the future. Please use attach method instead.");
         }
-        SenzaShakaPlayer._prevInstance = this;
 
+    }
+
+    _attach(videoElement) {
+        this.videoElement = videoElement;
+
+        // Store original play and replace with our implementation.
+        if (this._playingTimeout > 0) {
+            this._originalPlay = this.videoElement.play;
+            this.videoElement.play = async () => {
+                if (this._playPromiseResolve || this._playPromiseReject) {
+                    sdkLogger.warn("play() was called while a play promise is already pending. Ignoring play call.");
+                    return;
+                }
+
+                // Clear any existing timeout
+                if (this._playTimeoutId) {
+                    clearTimeout(this._playTimeoutId);
+                }
+                // Store the timestamp of the play call
+                this._playStartTime = Date.now();
+
+                const returnPromise = new Promise((resolve, reject) => {
+                    this._playPromiseResolve = resolve;
+                    this._playPromiseReject = reject;
+
+
+                });
+                // Set timeout to reject if playing event doesn't arrive
+                this._playTimeoutId = setTimeout(() => {
+                    sdkLogger.error("Playing event timeout reached");
+                    // when timeout reached start the local playback anyway
+                    this._handlePlayingEvent();
+                }, this._playingTimeout);
+                await this.remotePlayer.play()
+                    .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;
+            };
+        };
 
+        this._attachVideoElementToRemotePlayer();
     }
 
     /**
@@ -220,8 +391,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      */
     async attach(videoElement, initializeMediaSource = true) {
         await super.attach(videoElement, initializeMediaSource);
-        this.videoElement = videoElement;
-        this._attachVideoElementToRemotePlayer();
+        this._attach(videoElement);
     }
 
     /**
@@ -235,6 +405,17 @@ export class SenzaShakaPlayer extends shaka.Player {
    * @export
    */
     async detach(keepAdManager = false) {
+        // Clear any pending timeout
+        this._resetPlayPromise();
+
+        if (this.videoElement && this._originalPlay) {
+            // Clear any pending play promise
+            this._playPromiseResolve = null;
+            this._playPromiseReject = null;
+            // Restore original play function before detaching
+            this.videoElement.play = this._originalPlay;
+            this._originalPlay = null;
+        }
 
         await super.detach(keepAdManager);
         this._audioTracksMap = {};
@@ -265,6 +446,7 @@ export class SenzaShakaPlayer extends shaka.Player {
         // Call the remote player's unload method
         try {
             await lifecycle.moveToForeground();
+            this._clearPlayTimeout();
             await remotePlayer.unload();
         } catch (error) {
             sdkLogger.error("Failed to unload remote player:", error);
@@ -391,7 +573,8 @@ export class SenzaShakaPlayer extends shaka.Player {
                 sdkLogger.error("Error while trying to stop video element playback:", stopError);
             }
         }
-
+        // Handle error while waiting for play event
+        this._handlePlayPromiseError(error);
         this.dispatchEvent(new shaka.util.FakeEvent("error", errorMap));
     }
 
@@ -487,6 +670,17 @@ export class SenzaShakaPlayer extends shaka.Player {
         return super.destroy();
     }
 
+    /**
+    * A temporary override for older versions of Shaka.
+    * Senza doesn't support out-of-band subtitles
+    */
+    addTextTrack(uri, language, kind, mimeType, codec, label, forced = false) {
+        sdkLogger.warn("addTextTrack is deprecated, please use addTextTrackAsync");
+        super.addTextTrackAsync(uri, language, kind, mimeType, codec, label, forced).then(subs => {
+            sdkLogger.warn("addTextTrackAsync Done" + subs);
+        });
+    }
+
     /**
      * Override the configure method to add custom configuration handling
      * Supports the following additional configuration options:
@@ -502,6 +696,8 @@ export class SenzaShakaPlayer extends shaka.Player {
      * });
      */
     configure(config) {
+        sdkLogger.log("configure player with: ", JSON.stringify(config));
+
         // Handle custom configuration
         if (config.shouldStopRemotePlayerOnError !== undefined) {
             this._shouldStopRemotePlayerOnError = !!config.shouldStopRemotePlayerOnError;
@@ -522,6 +718,7 @@ export class SenzaShakaPlayer extends shaka.Player {
             remoteConfiguration["preferredSubtitlesLanguage"] = config["preferredTextLanguage"];
         }
 
+        sdkLogger.log("configure remote player with: ", JSON.stringify(remoteConfiguration));
         remotePlayer.configure(remoteConfiguration);
     }