senza-sdk 4.2.60 → 4.2.62

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.2.60",
+    "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/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

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: