senza-sdk 4.2.65-d2761c0.0 → 4.3.1-ca3d96f.0

package/src/interface/deviceManager.js

@@ -0,0 +1,142 @@
+import { sdkLogger, noop } from "./utils.js";
+
+const wifiInfo = {
+    level: 0,
+    quality: 0,
+    ssid: "unknown",
+    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);
+ * });
+ *
+ */
+/**
+ * DeviceManager is a singleton class that manages the device
+ */
+export class DeviceManager extends EventTarget {
+    /**
+     * @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({});
+    }
+}
+
+
+/**
+ * @module
+ * @type {DeviceManager}
+ * @example
+ * import { deviceManager } from "senza-sdk";
+ * const wifiInfo = await deviceManager.getWifiInfo();
+ * console.info(wifiInfo.ssid);
+ * await deviceManager.clearWifi();
+ * deviceManager.reboot();
+ *
+ * @return {DeviceManager} pointer to the DeviceManager singleton
+ */
+"needed for the module doc comment to be recognized";

package/src/interface/lifecycle.js

@@ -0,0 +1,283 @@
+import {
+    sdkLogger,
+    noop
+} from "./utils.js";
+/**
+ * @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
+ * });
+ */
+
+/**
+  * Lifecycle is a singleton class that manages the application lifecycle states.<br>
+  * @fires onstatechange
+  * @fires userinactivity
+  * @fires userdisconnected
+ */
+export 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"
+    });
+
+    /**
+     * 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) {
+        noop("lifecycle.configure", config);
+    }
+
+    /**
+     * 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: {
+                enabled: false,
+                timeout: {
+                    playing: 0,
+                    idle: 0
+                }
+            }
+        };
+    }
+
+    /**
+     * Getter for returning the ui lifecycle state
+     * @returns {UiState} the current application lifecycle state
+     */
+    get state() {
+        this._state = this.UiState.UNKNOWN;
+        return this._state;
+    }
+
+    /**
+     * Getter for returning the application connection reason
+     * @returns {ConnectReason} the application connection reason
+     */
+    get connectReason() {
+        return this.ConnectReason.UNKNOWN;
+    }
+
+    /**
+     * 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() {
+        return {};
+    }
+
+    /**
+     * @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) {
+        noop("lifecycle.autoBackground", enabled);
+    }
+
+    get autoBackground() {
+        return false;
+    }
+
+    /**
+     * @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) {
+        noop("lifecycle.autoBackgroundDelay", delay);
+    }
+
+    get autoBackgroundDelay() {
+        return 0;
+    }
+
+    /**
+     * @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) {
+        noop("lifecycle.autoBackgroundOnUIDelay", delay);
+    }
+
+    get autoBackgroundOnUIDelay() {
+        return 0;
+    }
+
+    /**
+     * @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() {
+        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() {
+        return noop("lifecycle.moveToForeground");
+    }
+
+    /**
+     * 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() {
+        return noop("lifecycle.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) {
+        return noop("lifecycle.switchTenant", tenantId);
+    }
+
+    /**
+     * 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() {
+        return noop("lifecycle.exitApplication");
+    }
+
+    /**
+     * 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) {
+        super.addEventListener(type, listener, options);
+    }
+
+    /**
+     * 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) {
+        super.removeEventListener(type, listener, options);
+    }
+}
+
+
+/**
+ * @module
+ * @type {Lifecycle}
+ * @example
+ * import { lifecycle } from "senza-sdk";
+ *
+ * @return {Lifecycle} pointer to the Lifecycle singleton
+ */
+"needed for the module doc comment to be recognized";

package/src/interface/messageManager.js

@@ -0,0 +1,53 @@
+
+import { noop } from "./utils";
+
+/**
+ * @typedef {object} MessageDetails - object which contains the content of the message
+ * @property {string} eventName - The name of the event message, a property of MessageDetails
+ * @property {object} payload - The payload for this event, a property of MessageDetails
+ * @property {string} fcid - The flow context for this message, a property of MessageDetails
+ */
+
+/**
+ * message event
+ *
+ * @event MessageManager#message
+ * @type {CustomEvent}
+ * @property {MessageDetails} detail - object containing data related to the event:
+
+ *
+ * @description Fired when an external event arrives. This is a generic handler for all messages received for any registered group <br>
+ * @example
+ * messageManager.addEventListener("message", (e) => {
+ *     console.log("message arrived with data", e.detail);
+ * });
+ *
+ */
+
+/**
+ * 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
+ * @class MessageManager
+ * @fires MessageManager#message
+ */
+export class MessageManager extends EventTarget {
+
+    /** Register to specific group(s). This function replaces the previously registered groups
+     * @param {Array<String>} groups group events to receive messages.
+     * @return {Promise} Promise which is resolved when the registerGroups command has been successfully processed.
+     * Failure to process the registerGroups command will result in the promise being rejected.
+     * messageManager.registerGroups(["A","B"]);
+     * */
+    async registerGroups(groups) {
+        return noop("MessageManager.registerGroups", groups);
+    }
+}
+
+/**
+ * @module
+ * @type {MessageManager}
+ * @example
+ * import { MessageManager } from "senza-sdk";
+ *
+ * @return {MessageManager} pointer to the MessageManager singleton
+ */
+"needed for the module doc comment to be recognized";

package/src/interface/platformManager.js

@@ -0,0 +1,41 @@
+import { noop } from "./utils";
+/**
+ * PlatformManager is a singleton class that manages the platform
+ */
+export class PlatformManager extends EventTarget {
+
+    /**
+     * @returns {Object} appConfig object
+     * @property {String[]} territories - a list of territories configured for the tenant.
+     * if the list is undefined or empty - there are no restrictions.
+     * @example
+     * import { platformManager } from "senza-sdk";
+     * const appConfig = platformManager.appConfig
+     * */
+    get appConfig() {
+        return {};
+    }
+
+    /**
+     *
+     * @param {string} timezone the timezone to set to
+     * the format of the timezone is according to the standard TZ identifier
+     * (e.g. America/Los_Angeles, Asia/Tokyo, Europe/Brussels)
+     * for a full list of TZ identifiers, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+     */
+    setTimezone(timezone) {
+        noop("PlatformManager.setTimezone", timezone);
+    }
+}
+
+/**
+ * @module
+ * @type {PlatformManager}
+ * @example
+ * import { platformManager } from "senza-sdk";
+ * console.info(platformManager.appConfig);
+ * platformManager.setTimezone("Europe/Brussels");
+ *
+ * @return {PlatformManager} pointer to the PlatformManager singleton
+ */
+"needed for the module doc comment to be recognized";