senza-sdk 4.2.64-70c0747.0 → 4.2.65-90c49ac.0

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

@@ -1,4 +1,3 @@
-import { DeviceManager as DeviceManagerInterface } from "../interface/deviceManager";
 import { getFCID, sdkLogger, getRestResponse } from "./utils";
 import { isRunningE2E } from "./api";
 import { sessionInfo } from "./SessionInfo";
@@ -36,7 +35,10 @@ async function getWifiStatus() {
     }
 }
 
-class DeviceManager extends DeviceManagerInterface {
+/**
+ * DeviceManager is a singleton class that manages the device
+ */
+class DeviceManager extends EventTarget {
 
     constructor() {
         super();
@@ -44,7 +46,15 @@ class DeviceManager extends DeviceManagerInterface {
         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);
+         * });
+         *
+         */
         typeof document !== "undefined" && document.addEventListener("wifiSignalReport", (e) => {
             wifiInfo.level = e.detail.level;
             wifiInfo.quality = e.detail.quality;
@@ -55,6 +65,17 @@ class DeviceManager extends DeviceManagerInterface {
 
     }
 
+    /**
+     * @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() {
         const sessionInfoObj = sessionInfo.sessionInfoObj;
         if (isRunningE2E() && sessionInfoObj) {
@@ -82,10 +103,23 @@ class DeviceManager extends DeviceManagerInterface {
         };
     }
 
+    /**
+     * @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 new Promise((resolve, reject) => {
             if (window.cefQuery) {
@@ -115,6 +149,11 @@ class DeviceManager extends DeviceManagerInterface {
         });
     }
 
+    /**
+     * 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 new Promise((resolve, reject) => {
             const FCID = getFCID();
@@ -139,6 +178,16 @@ class DeviceManager extends DeviceManagerInterface {
         });
     }
 
+    /**
+     * 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) {
         if (typeof data !== "string") {
             throw new Error("data must be of type 'string'");
@@ -170,6 +219,12 @@ class DeviceManager extends DeviceManagerInterface {
         });
     }
 
+    /**
+     * 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) {
         if (typeof reboot !== "boolean") {
             throw new Error("reboot param must be of type 'boolean'");
@@ -227,6 +282,12 @@ class DeviceManager extends DeviceManagerInterface {
      * @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() {
         await Promise.all([getWifiApData(), getWifiStatus()]);
         return { ...wifi_ap_data, ...wifi_status };
@@ -234,7 +295,7 @@ class DeviceManager extends DeviceManagerInterface {
 }
 
 /**
-
+ *
  * @module
  * @example
  * import { deviceManager } from "senza-sdk";

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

@@ -1,6 +1,4 @@
-import { Lifecycle as LifecycleInterface } from "../interface/lifecycle";
-import { getPlatformInfo } from "./api";
-import { alarmManager } from "./alarmManager";
+import { alarmManager, getPlatformInfo } from "./api";
 import {
     getFCID,
     isAudioSyncConfigured,
@@ -26,7 +24,76 @@ const DEFAULT_AUTO_BACKGROUND_ENABLED = false;
   * @fires userinactivity
   * @fires userdisconnected
  */
-class Lifecycle extends LifecycleInterface {
+class Lifecycle extends EventTarget {
+
+    /**
+     * @typedef {Object} ConnectReason - The reason the ui app has been loaded
+     * @property {string} UNKNOWN
+     * @property {string} INITIAL_CONNECTION - Indicates that ui app has been loaded for the first time
+     * @property {string} APPLICATION_RELOAD - Indicates that ui app has been reloaded (e.g. after HOME keypress)
+     * @property {string} UI_RELEASE - Indicates that ui app has been reloaded after ui release
+     * @property {string} UI_TERMINATION - Indicates that ui app has been reloaded due to ui termination
+     * @property {string} WEBRTC_ERROR - Indicates that ui app has been reloaded due to webrtc error
+     * @property {string} UI_WATCHDOG - Indicates that ui app has been reloaded due to ui watchdog not receiving ui frames
+     */
+    ConnectReason = Object.freeze({
+        UNKNOWN: "unknown",
+        INITIAL_CONNECTION: "initial_connection",
+        APPLICATION_RELOAD: "reload_app",
+        UI_RELEASE: "ui_release",
+        UI_TERMINATION: "ui_termination",
+        WEBRTC_ERROR: "webrtc_error",
+        UI_WATCHDOG: "ui_watchdog"
+    });
+
+    /**
+     * @typedef {Object} UiState - The ui lifecycle state
+     * @property {string} UNKNOWN - state is unknown at this time
+     * @property {string} FOREGROUND - ui is displayed
+     * @property {string} IN_TRANSITION_TO_FOREGROUND - ui is about to be displayed
+     * @property {string} BACKGROUND - remote player is playing (full screen playback is displayed)
+     * @property {string} IN_TRANSITION_TO_BACKGROUND - remote player is about to be playing
+     */
+    UiState = Object.freeze({
+        UNKNOWN: "unknown",
+        FOREGROUND: "foreground",
+        IN_TRANSITION_TO_FOREGROUND: "inTransitionToForeground",
+        BACKGROUND: "background",
+        IN_TRANSITION_TO_BACKGROUND: "inTransitionToBackground"
+    });
+
+    /**
+     * @event Lifecycle#onstatechange
+     * @description Fired after transition from one state to another.<br>
+     * The flow is: foreground --> inTransitionToBackground --> background --> inTransitionToForeground --> foreground
+     * @property {UiState} state - Indicates the new state.
+     * @example
+     * lifecycle.addEventListener("onstatechange", (e) => {
+     *     console.log("new state is", e.state);
+     * });
+     */
+
+    /**
+     * @event Lifecycle#userinactivity
+     * @description Fired after the ui has been inactive (i.e. no key presses) for a configurable number of seconds.<br>
+     * @property {number} timeout - the number of seconds after which the application will be unloaded.
+     * @example
+     * lifecycle.addEventListener("userinactivity", (e) => {
+     *     console.log(`Application will be unloaded in ${e.timeout} seconds`);
+     * });
+     * @alpha API has not yet been released
+     */
+
+    /**
+     * @event Lifecycle#userdisconnected
+     * @description Fired when the user session ends .
+     * This event is useful for cleaning up application state or saving data before the application closes. Event callback should return promise to ensure that the event is handled before the application is terminated
+     * @example
+     * lifecycle.addEventListener("userdisconnected", () => {
+     *     console.log("User session ended, cleaning up application state");
+     *     // Perform any necessary cleanup here
+     * });
+     */
     constructor() {
         super();
 
@@ -35,7 +102,9 @@ class Lifecycle extends LifecycleInterface {
          * @private
          */
         this._isInitialized = false;
-        this._inTransition = false;
+        this._inTransitionToForeground = false;
+        this._inTransitionToBackground = false;
+        this._inTransitionToStandby = false;
 
         /**
          * Event listeners manager for the userdisconnected event
@@ -238,6 +307,15 @@ class Lifecycle extends LifecycleInterface {
         return this._autoBackgroundOnUIDelay;
     }
 
+    /**
+     * Configure lifecycle settings
+     * @param {Object} config - Configuration object
+     * @param {Object} [config.autoBackground] - Auto background settings
+     * @param {boolean} [config.autoBackground.enabled] - Enable/disable auto background
+     * @param {Object} [config.autoBackground.timeout] - Timeout settings
+     * @param {number|false} [config.autoBackground.timeout.playing=30] - Timeout in seconds when video is playing, false to disable
+     * @param {number|false} [config.autoBackground.timeout.idle=false] - Timeout in seconds when in UI mode, false to disable
+     */
     configure(config) {
         if (config?.autoBackground) {
             const { enabled, timeout } = config.autoBackground;
@@ -277,6 +355,15 @@ class Lifecycle extends LifecycleInterface {
         }
     }
 
+    /**
+     * Get the current configuration settings
+     * @returns {Object} The current configuration object
+     * @example
+     * const config = lifecycle.getConfiguration();
+     * console.log(config.autoBackground.enabled); // true/false
+     * console.log(config.autoBackground.timeout.playing); // 30
+     * console.log(config.autoBackground.timeout.idle); // false
+     */
     getConfiguration() {
         return {
             autoBackground: {
@@ -299,7 +386,7 @@ class Lifecycle extends LifecycleInterface {
     // This api is part of epic HSDEV-713
     _moveToUiStandby() {
         if (window.cefQuery) {
-            this._inTransition = true;
+            this._inTransitionToStandby = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const request = { target: "TC", waitForResponse: false, internalAction: "uiExit", message: JSON.stringify({ type: "uiStandbyRequest", fcid: FCID }) };
@@ -310,12 +397,12 @@ class Lifecycle extends LifecycleInterface {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("[ moveToUiStandby ] moveToUiStandby successfully sent");
-                        this._inTransition = false;
+                        this._inTransitionToStandby = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
                         logger.error(`[ moveToUiStandby ] moveToUiStandby failed: ${code} ${msg}`);
-                        this._inTransition = false;
+                        this._inTransitionToStandby = false;
                         reject(`moveToUiStandby failed: ${code} ${msg}`);
                     }
                 });
@@ -325,6 +412,10 @@ class Lifecycle extends LifecycleInterface {
         return Promise.resolve(true);
     }
 
+    /**
+     * Getter for returning the ui lifecycle state
+     * @returns {UiState} the current application lifecycle state
+     */
     get state() {
         if (!this._isInitialized) {
             this._state = this.UiState.UNKNOWN;
@@ -332,6 +423,10 @@ class Lifecycle extends LifecycleInterface {
         return this._state;
     }
 
+    /**
+     * Getter for returning the application connection reason
+     * @returns {ConnectReason} the application connection reason
+     */
     get connectReason() {
         if (!this._isInitialized) {
             this._connectReason = this.ConnectReason.UNKNOWN;
@@ -339,6 +434,11 @@ class Lifecycle extends LifecycleInterface {
         return this._connectReason;
     }
 
+    /**
+     * Getter for returning the event that triggered the reloading of the ui after ui has been released
+     * @returns {Object} trigger event
+     * @property {string} type - the type of the trigger event (e.g. keyPressEvent, videoPlaybackEvent)
+     * @property {object} data - data of the event, dependent on its type (e.g. keyPressEvent has data of keyValue) */
     get triggerEvent() {
         if (!this._isInitialized) {
             this._triggerEvent = {};
@@ -346,6 +446,14 @@ class Lifecycle extends LifecycleInterface {
         return this._triggerEvent;
     }
 
+    /**
+     * @deprecated Use `lifecycle.configure()` instead.
+     * Controls the autoBackground feature.<br>
+     * When enabled, the application will automatically move to the background state after a configurable
+     * period of inactivity. Use the `configure` method to set timeouts for video playback and UI states.
+     * @type {boolean}
+     * @see {@link Lifecycle#configure}
+     */
     set autoBackground(enabled) {
         this._autoBackground = enabled;
         if (this._isAutoBackgroundEnabled()) {
@@ -359,6 +467,14 @@ class Lifecycle extends LifecycleInterface {
         return this._autoBackground;
     }
 
+    /**
+     * @deprecated Use `lifecycle.configure()` instead.
+     * The number of seconds of user inactivity before the application moves to the background state while playing video.
+     * Use the `configure` method to set this timeout.
+     * @type {integer}
+     * @default 30
+     * @see {@link Lifecycle#configure}
+     */
     set autoBackgroundDelay(delay) {
         this._autoBackgroundOnVideoDelay = delay;
         if (this._isAutoBackgroundEnabled() && remotePlayer._isPlaying) {
@@ -370,6 +486,14 @@ class Lifecycle extends LifecycleInterface {
         return this._autoBackgroundOnVideoDelay;
     }
 
+    /**
+     * @deprecated Use `lifecycle.configure()` instead.
+     * The number of seconds of user inactivity before the application moves to the background state while in the UI (not playing).
+     * Use the `configure` method to set this timeout.
+     * @type {integer}
+     * @default -1
+     * @see {@link Lifecycle#configure}
+     */
     set autoBackgroundOnUIDelay(delay) {
         this._autoBackgroundOnUIDelay = delay;
         if (this._isAutoBackgroundEnabled() && !remotePlayer._isPlaying) {
@@ -412,6 +536,26 @@ class Lifecycle extends LifecycleInterface {
         this._countdown = null;
     }
 
+    /**
+     * @private
+     */
+    _isInTransition() {
+        return this._inTransitionToForeground || this._inTransitionToBackground || this._inTransitionToStandby;
+    }
+
+
+    /**
+     * @deprecated use lifecycle.state instead.
+     * Async function that returns the ui lifecycle state
+     * @returns {UiState} the current application lifecycle state
+     * @example
+     * try {
+     *     const state = await lifecycle.getState();
+     *     console.log("current state is", state);
+     * } catch (e) {
+     *     console.error("getState failed", e);
+     * }
+     */
     getState() {
         if (window.cefQuery) {
             return new Promise((resolve, reject) => {
@@ -432,16 +576,29 @@ class Lifecycle extends LifecycleInterface {
         sdkLogger.warn("lifecycle getState is not supported if NOT running e2e");
     }
 
+    /**
+     * Once playback starts on the remote player,
+     * the application is moved from foreground to inTransitionToBackground and eventually to background.
+     * The application will need to call moveToForeground when it receives an event that needs the UI to be displayed again,
+     * for example a key press, a playback end-of-file or a playback error.
+     * @return {Promise} Promise which is resolved when the moveToForeground command has been successfully processed.
+     * Failure to process the moveToForeground command will result in the promise being rejected.
+     */
     moveToForeground() {
         if (window.cefQuery) {
-            if (this._inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
-                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${this._inTransition}`);
+            const inTransition = this._isInTransition();
+            if (inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
+                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${inTransition}`);
                 return Promise.resolve(false);
             }
-            this._inTransition = true;
+            this._inTransitionToForeground = true;
             alarmManager._moveToForegroundCalled();
             const FCID = getFCID();
             if (this._remotePlayerApiVersion >= 2) {
+                // Only update to playing UI if we started seeking in ABR. But, if we are seeking while already paused, keep the target seek state as is.
+                if (remotePlayer._isSeekingByApplication && remotePlayer._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
+                    remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
+                }
                 return new Promise((resolve, reject) => {
                     const FCID = getFCID();
                     const logger = sdkLogger.withFields({ FCID });
@@ -461,14 +618,14 @@ class Lifecycle extends LifecycleInterface {
                         onSuccess: () => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop completed successfully after ${duration} ms`);
-                            this._inTransition = false;
+                            this._inTransitionToForeground = false;
                             timerId = clearTimer(timerId);
                             resolve(true);
                         },
                         onFailure: (code, msg) => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                            this._inTransition = false;
+                            this._inTransitionToForeground = false;
                             timerId = clearTimer(timerId);
                             reject(new SenzaError(code, msg));
                         }
@@ -477,7 +634,7 @@ class Lifecycle extends LifecycleInterface {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransition = false;
+                        this._inTransitionToForeground = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -492,11 +649,11 @@ class Lifecycle extends LifecycleInterface {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("uiActiveRequest successfully sent");
-                        this._inTransition = false;
+                        this._inTransitionToForeground = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
-                        this._inTransition = false;
+                        this._inTransitionToForeground = false;
                         logger.error(`uiActiveRequest failed: ${code} ${msg}`);
                         reject(`uiActiveRequest failed: ${code} ${msg}`);
                     }
@@ -509,10 +666,6 @@ class Lifecycle extends LifecycleInterface {
 
     _moveToBackground() {
         if (window.cefQuery) {
-            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
-                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
-                return Promise.resolve(false);
-            }
             // If audio sync is disabled, we only need to sync before remote player starts playing
             if (!isAudioSyncConfigured()) {
                 remotePlayer._syncRemotePlayerWithLocalPlayer();
@@ -524,7 +677,7 @@ class Lifecycle extends LifecycleInterface {
                 return this._moveToUiStandby();
             }
 
-            this._inTransition = true;
+            this._inTransitionToBackground = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const logger = sdkLogger.withFields({ FCID });
@@ -565,14 +718,14 @@ class Lifecycle extends LifecycleInterface {
                     onSuccess: () => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play completed successfully after ${duration} ms`);
-                        this._inTransition = false;
+                        this._inTransitionToBackground = false;
                         timerId = clearTimer(timerId);
                         resolve();
                     },
                     onFailure: (code, msg) => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                        this._inTransition = false;
+                        this._inTransitionToBackground = false;
                         timerId = clearTimer(timerId);
                         reject(new SenzaError(code, msg));
                     }
@@ -582,7 +735,7 @@ class Lifecycle extends LifecycleInterface {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`play reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransition = false;
+                        this._inTransitionToBackground = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `play reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -593,13 +746,24 @@ class Lifecycle extends LifecycleInterface {
         return Promise.resolve(false);
     }
 
+    /**
+     * This method moves the application to the background.
+     * It should be called after remotePlayer.play().
+     * As a consequence, remote player playback will be displayed in full screen.
+     * @example
+     * remotePlayer.load("https://example.com/video.mp4", 0);
+     * remotePlayer.play();
+     * lifecycle.moveToBackground();
+     * @return {Promise} Promise which is resolved when the moveToBackground command has been successfully processed.
+     * Failure to process the moveToBackground command will result in the promise being rejected.
+     */
     moveToBackground() {
         if (window.cefQuery) {
-            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
-                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
+            const inTransition = this._isInTransition();
+            if (inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${inTransition}`);
                 return Promise.resolve(false);
             }
-
             if (remotePlayer._isSeekingByApplication) {
                 remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
                 return Promise.resolve(true);
@@ -616,6 +780,13 @@ class Lifecycle extends LifecycleInterface {
         return this._moveToBackground();
     }
 
+    /**
+     * Use this api to switch to another tenant (other than the home tenant) which will launch the application associated with the tenantId. The tenantId must be configured in the
+     * Senza platform. Switching to the home tenant should use the exitApplication().
+     * @param {string} tenantId The tenantId to switch
+     * @return {Promise} Promise which is resolved when the switchTenant command has been successfully processed.
+     * Failure to process the switchTenant command will result in the promise being rejected.
+     */
     switchTenant(tenantId) {
         if (tenantId && tenantId.length > 0) {
             if (tenantId === getPlatformInfo().sessionInfo?.tenantId) {
@@ -661,6 +832,11 @@ class Lifecycle extends LifecycleInterface {
         return Promise.reject("SwitchTenant requires a valid tenantId string parameter");
     }
 
+    /**
+     * Use this api to exit the application which will redirect the browser to the home tenant application.
+     * @return {Promise} Promise which is resolved when the exitApplication command has been successfully processed.
+     * Failure to process the exitApplication command will result in the promise being rejected.
+     */
     exitApplication() {
         if (window.cefQuery) {
             return new Promise((resolve, reject) => {
@@ -709,6 +885,12 @@ class Lifecycle extends LifecycleInterface {
         return Promise.reject("exitApplication is not supported if NOT running e2e");
     }
 
+    /**
+     * Add event listener for lifecycle events
+     * @param {string} type - The event type to listen for
+     * @param {Function} listener - The callback function. Listeners for 'userdisconnected' events should return a promise to ensure the event is processed before the application exits.
+     * @param {Object} options - Event listener options
+     */
     addEventListener(type, listener, options) {
         if (type === "userdisconnected") {
             // Use the event manager for userdisconnected events
@@ -719,7 +901,12 @@ class Lifecycle extends LifecycleInterface {
         }
     }
 
-
+    /**
+     * Remove event listener
+     * @param {string} type - The event type
+     * @param {Function} listener - The callback function to remove
+     * @param {Object} options - Event listener options
+     */
     removeEventListener(type, listener, options) {
         if (type === "userdisconnected") {
             // Use the event manager for userdisconnected events

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

@@ -1,12 +1,12 @@
-import { MessageManager as MessageManagerInterface } from "../interface/messageManager";
-import { getFCID, sdkLogger } from "./utils";
+
+import {getFCID, sdkLogger} from "./utils";
 
 /**
  * MessageManager is a singleton class that manages the external messages received by the application. It fires custom events as "message" with the payload as the content
  * @fires MessageManager#message
  */
 
-class MessageManager extends MessageManagerInterface {
+class MessageManager extends EventTarget {
 
     /**
      * @typedef {object} MessageDetails - object which contains the content of the message
@@ -34,7 +34,7 @@ class MessageManager extends MessageManagerInterface {
         super();
         typeof document !== "undefined" && document.addEventListener("hs/externalEvent", (e) => {
             sdkLogger.log("Got hs/externalEvent", JSON.stringify(e.detail));
-            this.dispatchEvent(new CustomEvent("message", { detail: { eventName: e.detail.eventName, payload: e.detail.payload, fcid: e.detail.fcid } }));
+            this.dispatchEvent(new CustomEvent("message", {detail: {eventName: e.detail.eventName, payload: e.detail.payload, fcid: e.detail.fcid } }));
         });
     }
 
@@ -49,13 +49,13 @@ class MessageManager extends MessageManagerInterface {
         return new Promise((resolve, reject) => {
             if (window.cefQuery) {
                 const FCID = getFCID();
-                const logger = sdkLogger.withFields({ FCID });
+                const logger = sdkLogger.withFields({FCID});
                 const message = {
                     type: "registerGroupEvent",
                     fcid: FCID,
                     groups
                 };
-                const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
+                const request = {target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message)};
                 window.cefQuery({
                     request: JSON.stringify(request),
                     persistent: false,

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

@@ -1,12 +1,11 @@
-import { PlatformManager as PlatformManagerInterface } from "../interface/platformManager";
 import { sdkLogger } from "./utils";
-import { sessionInfo } from "./SessionInfo";
+import {sessionInfo} from "./SessionInfo";
 
 
 /**
  * PlatformManager is a singleton class that manages the platform
  */
-class PlatformManager extends PlatformManagerInterface {
+class PlatformManager extends EventTarget {
 
     constructor() {
         super();
@@ -23,7 +22,7 @@ class PlatformManager extends PlatformManagerInterface {
     get appConfig() {
         const sessionInfoObj = sessionInfo.sessionInfoObj;
         const appConfig = sessionInfoObj.homeSessionInfo?.["appConfig"] || {};
-        sdkLogger.info("PlatformManager get appConfig: \n" + JSON.stringify(appConfig, null, 2));
+        sdkLogger.info("PlatformManager get appConfig: \n" + JSON.stringify(appConfig, null,2));
         return appConfig;
     }
 
@@ -36,7 +35,7 @@ class PlatformManager extends PlatformManagerInterface {
      */
     setTimezone(timezone) {
         if (window.cefQuery) {
-            const request = { message: JSON.stringify({ type: "setTimeZone", timezone }), waitForResponse: false, target: "UI-Streamer" };
+            const request = {message: JSON.stringify({type: "setTimeZone", timezone}), waitForResponse: false, target: "UI-Streamer"};
             window.cefQuery({
                 request: JSON.stringify(request),
                 persistent: false,