senza-sdk 4.2.60 → 4.2.63-6c9a088.0

package/src/{senzaShakaPlayer.js → implementation/senzaShakaPlayer.js}

@@ -1,4 +1,5 @@
-import * as shaka from "shaka-player";
+import { shaka } from "../interface/senzaShakaPlayer";
+
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
 import { sdkLogger, iso6393to1 } from "./utils";
 
@@ -30,11 +31,6 @@ class SenzaError extends shaka.util.Error {
 }
 
 
-// Copy the shaka module and replace the Player class with SenzaShakaPlayer
-// if we don't Copy the shaka module, the Player class will be replaced for all the other modules that import shaka
-const senzaShaka = { ...shaka };
-
-
 /**
  * SenzaShakaPlayer subclass of Shaka that handles both local and remote playback.
  *
@@ -55,35 +51,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 +150,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 +162,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);
         },
@@ -129,7 +181,7 @@ export class SenzaShakaPlayer extends shaka.Player {
                 originatesFromRemotePlayer: true
             };
 
-            const response = await this.getNetworkingEngine().request(senzaShaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
 
             let responseBody = response.data;
             if (response.status < 200 || response.status >= 300) {
@@ -166,17 +218,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 +321,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 +387,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 +401,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 +442,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 +569,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 +666,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:
@@ -610,5 +800,5 @@ export class SenzaShakaPlayer extends shaka.Player {
 
 }
 
-senzaShaka.Player = SenzaShakaPlayer;
-export { senzaShaka as shaka };
+shaka.Player = SenzaShakaPlayer;
+export { shaka };

package/src/{utils.js → implementation/utils.js}

@@ -1,10 +1,15 @@
 import { getPlatformInfo } from "./api";
-import pack from "../package.json";
 import { sessionInfo } from "./SessionInfo";
-const { version } = pack;
 
 const REST_RESPONSE_TIMEOUT_SECONDS = 5;
 
+export function getVersion() {
+    return typeof IMPLEMENTATION_VERSION !== "undefined"
+        // eslint-disable-next-line no-undef
+        ? IMPLEMENTATION_VERSION
+        : "unknown";
+};
+
 export function getFCID() {
     return Math.round(Math.random() * 100000) + "-" + getPlatformInfo().sessionInfo?.connectionId;
 }
@@ -42,7 +47,7 @@ class SdkLogger {
         console.info(`[hs-sdk] [metrics] ${JSON.stringify(metricObj)}`);
     }
     withFields(logFields) {
-        return new SdkLogger({...this.logFields, ...logFields});
+        return new SdkLogger({ ...this.logFields, ...logFields });
     }
     formatLogString(data) {
         let logString = "[hs-sdk] " + data.join(" ");
@@ -51,9 +56,13 @@ class SdkLogger {
         }
         return logString;
     }
+    addfields(fields) {
+        this.logFields = { ...this.logFields, ...fields };
+        return this;
+    }
 }
 
-export const sdkLogger = new SdkLogger({sdkVersion: version, url: window?.location?.href ?? ""});
+export const sdkLogger = new SdkLogger({ sdkVersion: getVersion(), url: window?.location?.href ?? "" });
 
 export async function getRestResponse(messageName) {
 
@@ -64,14 +73,14 @@ export async function getRestResponse(messageName) {
 
     return new Promise((resolve, reject) => {
         const FCID = getFCID();
-        const logger = sdkLogger.withFields({FCID});
+        const logger = sdkLogger.withFields({ FCID });
         const message = {
             type: "restRequest",
             name: messageName,
             method: "GET",
             fcid: FCID
         };
-        const request = {target: "TC", waitForResponse: true, message: JSON.stringify(message)};
+        const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
         let timeoutHandler = 0;
         const queryId = window.cefQuery({
             request: JSON.stringify(request),

package/src/interface/alarmManager.js

@@ -0,0 +1,69 @@
+import { noop } from "./utils";
+/**
+ * @class AlarmManager
+ * AlarmManager is a singleton class that manages the alarms in the application. It fires events whose types are the names of the alarms.
+ * @fires MyAlarm
+ */
+export class AlarmManager extends EventTarget {
+
+    /**
+     * alarm event
+     *
+     * @event AlarmManager#MyAlarm
+     * @description Fired when time of 'MyAlarm' arrives. If this alarm triggers the application load and the application doesn't call
+     * lifecycle.moveToForeground() in the alarm callback (i.e. the application remains in the background after the callback is completed),
+     * the application will be unloaded.
+     * NOTE: If you perform async operations in the callback (without moving to foreground), you must wait for the async
+     * operation to finish before returning from the callback, otherwise the application will be unloaded before the async operation is finished.<br>
+     * @example
+     * alarmManager.addEventListener("MyAlarm", async (e) => {
+     *     console.log("alarm MyAlarm arrived with data", e.detail);
+     *     await fetch("http://www.example.com");
+     * });
+     * alarmManager.addAlarm("MyAlarm", Date.now() + 60*60*1000, "MyData");
+     */
+    constructor() {
+        super();
+    }
+
+    addEventListener(type, callback) {
+        noop("AlarmManager.addEventListener", type, callback);
+    }
+
+    removeEventListener(type, callback) {
+        noop("AlarmManager.removeEventListener", type, callback);
+    }
+
+    /** Set alarm to be fired at the specified time, event when ui is released
+     * @param {string} alarmName unique name for the alarm
+     * @param {number} alarmTime target time for the alarm to be fired, represented by the number of milliseconds elapsed since the epoch
+     * @param {string} [data] data to be passed back when the alarm is fired
+     * */
+    addAlarm(alarmName, alarmTime, data = "", toleranceBefore = 0, toleranceAfter = 0) {
+        noop("AlarmManager.addAlarm", alarmName, alarmTime, data, toleranceBefore, toleranceAfter);
+    }
+
+    /** Delete the specified alarm
+     * @param {string} alarmName name of alarm to be deleted
+     *
+     * */
+    deleteAlarm(alarmName) {
+        noop("AlarmManager.deleteAlarm", alarmName);
+    }
+
+    /** Delete all alarms
+     *
+     * */
+    deleteAllAlarms() {
+        noop("AlarmManager.deleteAllAlarms");
+    }
+
+    /** Async function that asks for all active alarms
+     * @returns {Promise} when resolved, returns an array of objects containing alarmName and alarmTime fields
+     * @throws {string} error string in case of an error
+     *
+     * */
+    getActiveAlarms() {
+        return noop("AlarmManager.getActiveAlarms");
+    }
+}

package/src/interface/api.js

@@ -0,0 +1,8 @@
+export { Lifecycle } from "./lifecycle.js";
+export { DeviceManager } from "./deviceManager.js";
+export { PlatformManager } from "./platformManager.js";
+export { AlarmManager } from "./alarmManager.js";
+export { MessageManager } from "./messageManager.js";
+export { RemotePlayer } from "./remotePlayer.js";
+export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
+export { showSequence, initSequence } from "./devSequence.js";

package/src/interface/deviceManager.js

@@ -0,0 +1,133 @@
+import { sdkLogger, noop } from "./utils.js";
+
+const wifiInfo = {};
+
+/**
+ * @class DeviceManager
+ * DeviceManager is a singleton class that manages the device
+ */
+export class DeviceManager extends EventTarget {
+
+    constructor() {
+        super();
+        wifiInfo.level = 0;
+        wifiInfo.quality = 0;
+        wifiInfo.ssid = "unknown";
+        wifiInfo.bssid = "unknown";
+        /**
+         * @deprecated Instead, call deviceManager.getWifiInfo() periodically
+         * @event DeviceManager#wifiInfoUpdated
+         * @example
+         * deviceManager.addEventListener("wifiInfoUpdated", () => {
+         *   console.info("Wifi info has been updated to", deviceManager.wifiInfo);
+         * });
+         *
+         */
+    }
+
+    /**
+     * @property {object} DeviceInfo
+     * @property {string} DeviceInfo.deviceId
+     * @property {string} DeviceInfo.modelNumber
+     * @property {string} DeviceInfo.connectionId
+     * @property {string} DeviceInfo.community
+     * @property {string} DeviceInfo.tenant
+     * @property {string} DeviceInfo.clientIp
+     * @property {string} DeviceInfo.countryCode A 2-letter code as defined in ISO_3166-1
+     * @property {string} DeviceInfo.connectionType The type of device used during the current connection. Possible values are "device" which mean real device, "simulator" - simulated device - that used during development.
+     */
+    get deviceInfo() {
+        sdkLogger.log("getDeviceInfo running locally, returning dummy info");
+        return {
+            deviceId: "123456789",
+            modelNumber: "ABC",
+            connectionId: "dummy",
+            community: "LocalDev",
+            tenant: "XXXXXX",
+            clientIp: "0.0.0.0",
+            countryCode: "XX",
+            connectionType: "simulator"
+        };
+
+    }
+
+    /**
+     * @deprecated use deviceManager.getWifiInfo() instead
+     * @property {object} WifiInfo
+     * @property {number} WifiInfo.level
+     * @property {number} WifiInfo.quality
+     * @property {string} WifiInfo.ssid
+     * @property {string} WifiInfo.bssid
+     */
+    get wifiInfo() {
+        return wifiInfo;
+    }
+
+    /**
+     * Reboot the device
+     * @return {Promise} Promise which is resolved when the reboot command has been successfully processed.
+     * Failure to process the reboot command will result in the promise being rejected.
+     */
+    reboot() {
+        return noop("DeviceManager.reboot");
+    }
+
+    /**
+     * Delete current wifi configuration and forget network
+     * @return {Promise} Promise which is resolved when the clearWifi command has been successfully processed.
+     * Failure to process the clearWifi command will result in the promise being rejected.
+     */
+    clearWifi() {
+        return noop("DeviceManager.clearWifi");
+    }
+
+    /**
+     * Send raw data directly to a customer's device via the USB serial connection of a Senza device.
+     * This function is specifically designed for customers who have their devices connected to a Senza device.
+     * Using this API, these customers can transmit messages or data directly to their connected devices.
+     * The transmission occurs through the Senza device's USB serial interface, facilitating direct communication
+     * between the customer's web application and their device.
+     * @param {String} data raw data to be passed to the device
+     * @return {Promise} Promise which is resolved when the command has been successfully processed.
+     * Failure to process the command will result in the promise being rejected.
+     */
+    sendDataToDevice(data) {
+        return noop("DeviceManager.sendDataToDevice", data);
+    }
+
+    /**
+     * Perform device factory reset.
+     * @param {Boolean} [reboot=true] a flag that is passed to the device to indicate whether it should reboot after the factory reset. defaults to true.
+     * @return {Promise} Promise which is resolved when factoryReset has been successfully performed
+     * Failure to factoryReset for any reason, result in the promise being rejected.
+     */
+    async factoryReset(reboot = true) {
+        return noop("DeviceManager.factoryReset", reboot);
+    }
+
+    /**
+     * @typedef {Object} WiFiInfo
+     * @property {string}   ssid the name of the Wi-Fi network that the device is connected to
+     * @property {string}   bssid the unique identifier of the Wi-Fi access point
+     * @property {string}   standard the Wi-Fi standard in use, such as 802.11a/b/g/n/ac/ax
+     * @property {string}   security the type of security protocol used by the Wi-Fi network, such as WEP, WPA, WPA2, or WPA3
+     * @property {string}   device-mac the MAC address of the device
+     * @property {string}   device-ip4 the IPv4 address assigned to the device on the Wi-Fi network
+     * @property {string}   dhcp-server the IP address of the DHCP server that assigned the device's network configuration
+     * @property {string[]} dns-server array of IP addresses of the DNS servers the device uses to resolve domain names
+     * @property {number}   channel the number of the Wi-Fi channel currently being used
+     * @property {number}   width width of the Wi-Fi channel in megahertz, e.g. 20MHz or 40 MHz channel
+     * @property {number}   level a measure of the received signal strength, in the range 0 to 100 (the higher, the better). The level value is 100+RSSI (RSSI is the signal strength, measured in decibels)
+     * @property {number}   quality a measure of the signal quality, in the range 0 to 100 (the higher, the better). The quality value is derived from the signal EVM.
+     * */
+
+    /**
+     * Get Wi-Fi info - access point data and status (the status is cached for 5 seconds)
+     * @returns {WiFiInfo} An object containing the Wi-Fi info
+     * @alpha API has not yet been released
+     * */
+    // This api is part of epic HSDEV-4185
+    async getWifiInfo() {
+        return Promise.resolve({});
+    }
+}