senza-sdk 4.2.63-8d2e60f.0 → 4.2.64-2642526.0

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

@@ -1,4 +1,6 @@
-import { alarmManager, getPlatformInfo } from "./api";
+import { Lifecycle as LifecycleInterface } from "../interface/lifecycle";
+import { getPlatformInfo } from "./api";
+import { alarmManager } from "./alarmManager";
 import {
     getFCID,
     isAudioSyncConfigured,
@@ -24,76 +26,7 @@ const DEFAULT_AUTO_BACKGROUND_ENABLED = false;
   * @fires userinactivity
   * @fires userdisconnected
  */
-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
-     * });
-     */
+class Lifecycle extends LifecycleInterface {
     constructor() {
         super();
 
@@ -305,15 +238,6 @@ class Lifecycle extends EventTarget {
         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;
@@ -353,15 +277,6 @@ class Lifecycle extends EventTarget {
         }
     }
 
-    /**
-     * 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: {
@@ -410,10 +325,6 @@ class Lifecycle extends EventTarget {
         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;
@@ -421,10 +332,6 @@ class Lifecycle extends EventTarget {
         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;
@@ -432,11 +339,6 @@ class Lifecycle extends EventTarget {
         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 = {};
@@ -444,14 +346,6 @@ class Lifecycle extends EventTarget {
         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()) {
@@ -465,14 +359,6 @@ class Lifecycle extends EventTarget {
         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) {
@@ -484,14 +370,6 @@ class Lifecycle extends EventTarget {
         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) {
@@ -534,18 +412,6 @@ class Lifecycle extends EventTarget {
         this._countdown = null;
     }
 
-    /**
-     * @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) => {
@@ -566,14 +432,6 @@ class Lifecycle extends EventTarget {
         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) {
@@ -735,17 +593,6 @@ class Lifecycle extends EventTarget {
         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) {
@@ -769,13 +616,6 @@ class Lifecycle extends EventTarget {
         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) {
@@ -821,11 +661,6 @@ class Lifecycle extends EventTarget {
         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) => {
@@ -874,12 +709,6 @@ class Lifecycle extends EventTarget {
         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
@@ -890,12 +719,7 @@ class Lifecycle extends EventTarget {
         }
     }
 
-    /**
-     * 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
@@ -914,7 +738,7 @@ class Lifecycle extends EventTarget {
         if (window.cefQuery) {
             const FCID = getFCID();
             const message = {
-                type: "disconnect",
+                type: "terminating",
                 fcid: FCID
             };
             const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };

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

@@ -1,12 +1,12 @@
-
-import {getFCID, sdkLogger} from "./utils";
+import { MessageManager as MessageManagerInterface } from "../interface/messageManager";
+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 EventTarget {
+class MessageManager extends MessageManagerInterface {
 
     /**
      * @typedef {object} MessageDetails - object which contains the content of the message
@@ -34,7 +34,7 @@ class MessageManager extends EventTarget {
         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 EventTarget {
         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/{platformManager.js → implementation/platformManager.js}

@@ -1,11 +1,12 @@
+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 EventTarget {
+class PlatformManager extends PlatformManagerInterface {
 
     constructor() {
         super();
@@ -22,7 +23,7 @@ class PlatformManager extends EventTarget {
     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;
     }
 
@@ -35,7 +36,7 @@ class PlatformManager extends EventTarget {
      */
     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,

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

@@ -1,3 +1,4 @@
+import { RemotePlayer as RemotePlayerInterface } from "../interface/remotePlayer";
 import {
     getFCID,
     isAudioSyncConfigured,
@@ -82,7 +83,7 @@ function setPlaybackInfo(playbackInfo) {
  * @fires seeked (Not implemented yet)
  * @fires loadedmetadata (Not implemented yet)
  */
-class RemotePlayer extends EventTarget {
+class RemotePlayer extends RemotePlayerInterface {
     constructor() {
         super();
         /**

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.
  *
@@ -185,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) {
@@ -804,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";