senza-sdk 4.2.65-d2761c0.0 → 4.3.0

package/src/api.js

@@ -1,19 +1,16 @@
-import { getFCID, sdkLogger } from "./utils";
+import { sdkLogger, noop } from "./interface/utils.js";
 import pack from "../package.json";
-import { sessionInfo } from "./SessionInfo";
-const { version } = pack;
-import { initSequence, showSequence } from "./devSequence.js";
-import { lifecycle } from "./lifecycle";
-import { alarmManager } from "./alarmManager";
-
-let authToken;
+import { Lifecycle, RemotePlayer, DeviceManager, PlatformManager, AlarmManager, MessageManager, ShakaPlayer, shaka, showSequence, initSequence } from "./interface/api.js";
 
-const API_VERSION = "1.0";
+const { version } = pack;
 
 typeof document !== "undefined" && document.addEventListener("keydown", (event) => {
     sdkLogger.log(`Got ${event.key} key`);
 });
 
+
+let authToken;
+
 /** @namespace auth
  *@example
  * import { auth } from "senza-sdk";
@@ -51,314 +48,88 @@ export const ConnectReason = Object.freeze({
     UI_WATCHDOG: "ui_watchdog"
 });
 
-import { remotePlayer } from "./remotePlayer";
-export { remotePlayer };
-
-/** Should be called once to init the library
- *@example
+/**
+ *  Should be called once to init the library
+ * @example
  * import { init } from "senza-sdk";
  * await init();
  **/
 export async function init() {
-    sdkLogger.log(`init ${version}`);
-
-    if (!window.diagnostics) {
-        // ------------------------------------------------------------------------------------------------
-        // -- Do NOT change this log, as ui-streamer is checking this string to detect abnormal behavior --
-        // ------------------------------------------------------------------------------------------------
-        sdkLogger.error("[ init ] window.diagnostics is undefined");
-    }
-
-    if (window.cefQuery) {
-
-        // First, check compatability with ui-streamer api version
-        await new Promise((resolve, reject) => {
-            window.cefQuery({
-                request: "apiVersion " + API_VERSION,
-                persistent: false,
-                onSuccess: () => {
-                    sdkLogger.log("api version compatability check succeeded");
-                    resolve();
-                },
-                onFailure: (code, msg) => {
-                    sdkLogger.error("api version compatability check failed: " + msg);
-                    reject(msg);
-                }
-            });
-        });
-
-        const sessionInfoStr = await new Promise((resolve) => {
-            window.cefQuery({
-                request: "sessionInfo",
-                persistent: false,
-                onSuccess: (response) => {
-                    sdkLogger.log("sessionInfo request successfully returned " + response);
-                    resolve(response);
-                },
-                onFailure: (code, msg) => {
-                    sdkLogger.error(`sessionInfo request failed: ${code} ${msg}`);
-                }
-            });
-        });
-
-        sessionInfo.setSessionInfoStr(sessionInfoStr);
-        const sessionInfoObj = JSON.parse(sessionInfoStr);
-        authToken = sessionInfoObj?.settings?.webUI?.backendHeaders?.Authorization;
-        sdkLogger.log(`authToken: token = ${authToken}`);
-        // Listen to updateSession event to set the new token
-        document.addEventListener("updateSession", (e) => {
-            authToken = e.detail?.updateObj;
-            sdkLogger.log(`onUpdateSessionEvent: token = ${authToken}`);
-        });
-
-        // Set default alarm timeout using UI-Streamer settings
-        const alarmTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.alarmTimeout;
-        if (alarmTimeout) {
-            alarmManager._setDefaultTimeout(alarmTimeout);
-        }
-
-        // Get trigger event
-        const triggerEventStr = await new Promise((resolve) => {
-            const FCID = getFCID();
-            const logger = sdkLogger.withFields({ FCID });
-            const message = { type: "triggerEvent", fcid: FCID };
-            const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
-            window.cefQuery({
-                request: JSON.stringify(request),
-                persistent: false,
-                onSuccess: (response) => {
-                    logger.log(`triggerEvent request successfully returned '${response}'`);
-                    resolve(response);
-                },
-                onFailure: (code, msg) => {
-                    logger.error(`triggerEvent request failed: ${code} ${msg}`);
-                    resolve("");
-                }
-            });
-        });
-        let triggerEvent = {};
-        if (triggerEventStr) {
-            try {
-                triggerEvent = JSON.parse(triggerEventStr);
-            } catch (e) {
-                sdkLogger.error(`failed to parse trigger event string ${triggerEventStr}: ${e.message}`);
-            }
-        }
-
-        // Initialize lifecycle first to make sure the state is updated.
-        await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
-        await remotePlayer._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
-
-        const devSequence = sessionInfoObj?.settings?.["ui-streamer"]?.devSequence;
-        if (devSequence) {
-            initSequence({ lifecycle, remotePlayer });
-            showSequence(true);
-        }
-
+    sdkLogger.log(`init interface ${version}`);
+    if (window.senzaSDKImplementation) {
+        await window.senzaSDKImplementation.init(version, showSequence, initSequence);
     } else {
-        authToken = getPlatformInfo().sessionInfo?.settings?.webUI?.backendHeaders?.Authorization;
-        sdkLogger.log(`authToken dummy: token = ${authToken}`);
+        noop("init");
     }
-
     // override window.close() since it's not allowed to close the application this way
     window.close = () => {
         sdkLogger.warn("window.close is disabled on Senza platform. Use lifecycle.exitApplication() instead.");
     };
-
-
-}
-
-/**
- * @deprecated use lifecycle.connectReason instead
- * Returns the reason the ui has been loaded
- **/
-export function getConnectReason() {
-    return lifecycle.connectReason;
-}
-
-/**
- * @deprecated use lifecycle.triggerEvent instead
- * Returns the event that triggered the reloading of the ui after ui has been released
- **/
-export function getTriggerEvent() {
-    return lifecycle.triggerEvent;
 }
 
 // Returns the platform information, including version, pod, pod ip and session info.
 export function getPlatformInfo() {
-    if (typeof window !== "undefined" && window.diagnostics) {
-        try {
-            const platformInfo = window.diagnostics() || {};
-            platformInfo.sessionInfo = sessionInfo.sessionInfoObj;
-            return platformInfo;
-        } catch (e) {
-            sdkLogger.error("Could not get platform info", e.stack);
-        }
-
-    } else {
-        if (typeof window !== "undefined" && !window.diagnostics) {
-            sdkLogger.error("[ getPlatformInfo ] window.diagnostics is undefined");
-        }
-        return {
-            version: "X.X.XX-X",
-            pod: "ui-streamer-X.X.XX-X-QWERT-ASDFG-XXX-XXXXXX-XXXXX",
-            podIP: "0.0.0.0",
-            sessionInfo: {
-                userAgent: "SynamediaSenza/XX.YY.ZZ",
-                connectionId: "dummy",
-                deviceId: "123456789",
-                community: "LocalDev",
-                tenant: "XXXXXX",
-                tenantId: "XXXXXX",
-                manifest: {
-                    transcontainer: "X.X.XX-X"
-                },
-                settings: {
-                    webUI: {
-                        backendHeaders: {
-                            Authorization: "Bearer dummytoken"
-                        }
+    if (window.senzaSDKImplementation) {
+        return window.senzaSDKImplementation.getPlatformInfo();
+    }
+    return {
+        version: "X.X.XX-X",
+        pod: "ui-streamer-X.X.XX-X-QWERT-ASDFG-XXX-XXXXXX-XXXXX",
+        podIP: "0.0.0.0",
+        sessionInfo: {
+            userAgent: "SynamediaSenza/XX.YY.ZZ",
+            connectionId: "dummy",
+            deviceId: "123456789",
+            community: "LocalDev",
+            tenant: "XXXXXX",
+            tenantId: "XXXXXX",
+            manifest: {
+                transcontainer: "X.X.XX-X"
+            },
+            settings: {
+                webUI: {
+                    backendHeaders: {
+                        Authorization: "Bearer dummytoken"
                     }
-                },
-                homeSessionInfo: {
-                    tenantId: "XXXXXX",
-                    community: "LocalDev"
                 }
-            }
-        };
-    }
-}
-/**
- *
- * Returns the device information, including device id, connection id, community, tenant and client ip
- * */
-/**
- * @deprecated use platformManager.setTimezone instead.
- * @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
- */
-export function setTimezone(timezone) {
-    // STOP DO NOT CHANGE THIS FUNCTION AS IT IS DEPRECATED!!!!
-    if (window.cefQuery) {
-        const request = { message: JSON.stringify({ type: "setTimeZone", timezone }), waitForResponse: false, target: "UI-Streamer" };
-        window.cefQuery({
-            request: JSON.stringify(request),
-            persistent: false,
-            onSuccess: () => {
-                sdkLogger.log("timezome is successfully set to", timezone);
             },
-            onFailure: (code, msg) => {
-                sdkLogger.error(`error occurred setting timezone to ${timezone}: ${code} ${msg}`);
+            homeSessionInfo: {
+                tenantId: "XXXXXX",
+                community: "LocalDev"
             }
-        });
-    }
+        }
+    };
 }
 
 async function getToken() {
-    if (!authToken) {
-        sdkLogger.log("getToken wait for promise updateSession event");
-        return new Promise((resolve) => {
-            // Listen to updateSession event to set the new token
-            document.addEventListener("updateSession", (e) => {
-                authToken = e.detail?.updateObj;
-                sdkLogger.log(`onUpdateSessionEvent: token= ${authToken}`);
-                resolve(authToken);
-            }, { once: true });
-        });
+    if (window.senzaSDKImplementation) {
+        return window.senzaSDKImplementation.auth.getToken();
     }
     return Promise.resolve(authToken);
 }
 
 function forceTokenUpdate() {
     authToken = null;
-
-    if (window.cefQuery) {
-        const FCID = getFCID();
-        const logger = sdkLogger.withFields({ FCID });
-        logger.log("forceTokenUpdate: sending updateSessionRequest");
-        const message = {
-            type: "updateSessionRequest",
-            updateKey: "authorization",
-            parentPath: "settings.webUI.backendHeaders.Authorization",
-            fcid: FCID
-        };
-        const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
-        window.cefQuery({
-            request: JSON.stringify(request),
-            persistent: false,
-            onSuccess: () => {
-                logger.log("updateSessionRequest successfully sent");
-            },
-            onFailure: (code, msg) => {
-                logger.error(`updateSessionRequest failed: ${code} ${msg}`);
-            }
-        });
-    } else {
-        sdkLogger.error("forceTokenUpdate: window.cefQuery is undefined");
+    if (window.senzaSDKImplementation) {
+        return window.senzaSDKImplementation.auth.forceTokenUpdate();
     }
+    sdkLogger.error("forceTokenUpdate: window.cefQuery is undefined");
+
 }
 
 /** Returns a boolean that indicates whether we are running in an e2e environment, or on local browser */
 export function isRunningE2E() {
-    return !!(typeof window !== "undefined" && window.cefQuery);
+    return !!(typeof window !== "undefined" && window.senzaSDKImplementation);
 }
 
 /** Call this API once after application startup, when the ui is ready to accept keys/events */
 export function uiReady() {
-    if (window.cefQuery) {
-        window.cefQuery({
-            request: "uiReady",
-            persistent: false,
-            onSuccess: () => {
-                sdkLogger.log("uiReady request successfully sent");
-            },
-            onFailure: (code, msg) => {
-                sdkLogger.error(`uiReady request failed: ${code} ${msg}`);
-            }
-        });
-    } else {
-        sdkLogger.error("uiReady: window.cefQuery is undefined");
+    if (window.senzaSDKImplementation) {
+        return window.senzaSDKImplementation.uiReady();
     }
+    sdkLogger.error("uiReady: window.cefQuery is undefined");
 }
 
-/**
- * @deprecated use deviceManager.deviceInfo instead.
- * Returns the device information, including device id, connection id, community, tenant and client ip
- * */
-export function getDeviceInfo() {
-    // STOP DO NOT CHANGE THIS FUNCTION AS IT IS DEPRECATED!!!!
-    const sessionInfoObj = sessionInfo.sessionInfoObj;
-    if (isRunningE2E()) {
-        return {
-            deviceId: sessionInfoObj.deviceId,
-            connectionId: sessionInfoObj.connectionId,
-            community: sessionInfoObj.community,
-            tenant: sessionInfoObj.tenant,
-            clientIp: sessionInfoObj.clientIp
-        };
-    }
-    sdkLogger.log("getDeviceInfo running locally, returning dummy info");
-    return {
-        deviceId: "123456789",
-        connectionId: "dummy",
-        community: "LocalDev",
-        tenant: "XXXXXX",
-        clientIp: "0.0.0.0"
-    };
-}
-
-export { lifecycle } from "./lifecycle";
-export { deviceManager } from "./deviceManager";
-export { platformManager } from "./platformManager";
-export { alarmManager };
-export { messageManager } from "./messageManager";
-export { initSequence, showSequence } from "./devSequence";
-export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer";
-
-import "./devHelper";
-
 /**
  * @example
  * import { envInfo } from "senza-sdk";
@@ -369,10 +140,12 @@ import "./devHelper";
  * @property {string}  envInfo.sdkVersion      - the version of the SDK
  */
 export const envInfo = {
-    remoteBrowserIp: window.diagnostics ? window.diagnostics().podIP : "127.0.0.1",
-    sdkVersion: version
+    remoteBrowserIp: window?.diagnostics?.()?.podIP || "127.0.0.1",
+    sdkVersion: version,
+    sdkBackendVersion: window?.senzaSDKImplementation?.version || "N/A"
 };
 
+
 /**
  * The function receives a license response and passes it to platform.
  * @param {number} statusCode status code that was received from the license server
@@ -383,31 +156,10 @@ export const envInfo = {
  * In case of error licenseResponse is of type @type {string}
  */
 export function writeLicenseResponse(statusCode, licenseResponse, fcid, sessionId) {
-
-    if (statusCode >= 200 && statusCode < 300) {
-        licenseResponse = window.btoa(String.fromCharCode.apply(null, new Uint8Array(licenseResponse))); // to base64
-    }
-
-    if (window.cefQuery) {
-        const message = {
-            type: "updateLicense",
-            sessionId,
-            fcid
-        };
-        message[statusCode >= 200 && statusCode < 300 ? "response" : "error"] = licenseResponse;
-        const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
-        window.cefQuery({
-            request: JSON.stringify(request),
-            persistent: false,
-            onSuccess: () => {
-                sdkLogger.log("updateLicense request successfully sent");
-            },
-            onFailure: (code, msg) => {
-                sdkLogger.error(`updateLicense request failed: ${code} ${msg}`);
-            }
-        });
+    if (window?.senzaSDKImplementation) {
+        return window.senzaSDKImplementation.writeLicenseResponse(statusCode, licenseResponse, fcid, sessionId);
     }
-
+    sdkLogger.error("writeLicenseResponse: window.cefQuery is undefined");
 }
 
 export class ClientAssertionError extends Error {
@@ -438,34 +190,213 @@ export class ClientAssertionError extends Error {
  * }
  */
 export function getClientAssertion() {
-    if (window.cefQuery) {
-        sdkLogger.log("getClientAssertion is called");
-
-        return new Promise((resolve, reject) => {
-            window.cefQuery({
-                request: "client_assertion",
-                persistent: false,
-                onSuccess: (response) => {
-                    try {
-                        const json_response = JSON.parse(response);
-                        sdkLogger.log(`client_assertion request successfully returned ${response}`);
-                        resolve(json_response);
-                    } catch (e) {
-                        sdkLogger.error(`Failed to parse client assertion ${response}: ${e.message}`);
-                        reject(new ClientAssertionError(0, "Failed to parse client assertion"));
-                    }
+    if (window?.senzaSDKImplementation) {
+        return window.senzaSDKImplementation.auth.getClientAssertion();
+    }
+    sdkLogger.warn("getClientAssertion is not supported if NOT running e2e");
+}
 
-                },
-                onFailure: (code, msg) => {
-                    sdkLogger.log(`client_assertion request failed: ${code} ${msg}`);
-                    reject(new ClientAssertionError(code, msg));
-                }
-            });
+/**
+ * @module
+ * @private
+ * @type {Lifecycle}
+ * @example
+ * import { lifecycle } from "senza-sdk";
+ *
+ * @return {Lifecycle} pointer to the Lifecycle singleton
+ */
+let lifecycle;
+
+/**
+ * @module
+ * @private
+ * @type {RemotePlayer}
+ * @example
+ * import { init, remotePlayer } from "senza-sdk";
+ * await init();
+ * try {
+ *     await remotePlayer.load("http://playable.url/file.mp4");
+ *     remotePlayer.play();
+ * } catch(err) {
+ *     console.log("remotePlayer api failed with error code", err.code, err.msg);
+ * }
+ *
+ * @returns {RemotePlayer} pointer to the RemotePlayer singleton
+ */
+let remotePlayer;
+
+
+/**
+ * @module
+ * @private
+ * @type {AlarmManager}
+ * @example
+ * import { alarmManager } from "senza-sdk";
+ *
+ * @return {AlarmManager} pointer to the AlarmManager singleton
+ */
+let alarmManager;
+
+/**
+ * @module
+ * @private
+ * @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
+ */
+let deviceManager;
+
+
+/**
+ * @module
+ * @private
+ * @type {PlatformManager}
+ * @example
+ * import { platformManager } from "senza-sdk";
+ * console.info(platformManager.appConfig);
+ * platformManager.setTimezone("Europe/Brussels");
+ *
+ * @return {PlatformManager} pointer to the PlatformManager singleton
+ */
+let platformManager;
+
+/**
+ * @module
+ * @private
+ * @type {MessageManager}
+ * @example
+ * import { MessageManager } from "senza-sdk";
+ *
+ * @return {MessageManager} pointer to the MessageManager singleton
+ */
+let messageManager;
+
+
+/**
+ * ShakaPlayer subclass of Shaka that handles both local and remote playback.
+ *
+ * @class ShakaPlayer
+ * @private
+ * @type {new|ShakaPlayer}
+ * @example
+ * import { ShakaPlayer } from "senza-sdk";
+ *
+ * try {
+ *   const videoElement = document.getElementById("video");
+ *   const player = new ShakaPlayer(videoElement);
+ *   await player.load("http://playable.url/file.mpd");
+ *   await videoElement.play(); // will start the playback
+ *
+ * } catch (err) {
+ *   console.error("ShakaPlayer failed with error", err);
+ * }
+ */
+let ShakaPlayerImplementation;
+
+
+/**
+ * @module
+ * @private
+ * @type {shaka}
+ */
+let shakaImplementation;
+
+if (!isRunningE2E()) {
+    sdkLogger.warn("Senza SDK is not running in E2E environment. Some features may not work as expected.");
+
+    lifecycle = new Lifecycle();
+    remotePlayer = new RemotePlayer();
+    alarmManager = new AlarmManager();
+    deviceManager = new DeviceManager();
+    platformManager = new PlatformManager();
+    messageManager = new MessageManager();
+    ShakaPlayerImplementation = ShakaPlayer;
+    shakaImplementation = shaka;
+} else {
+    // If running in E2E environment, use the implementation provided by the platform
+    lifecycle = window.senzaSDKImplementation.lifecycle;
+    remotePlayer = window.senzaSDKImplementation.remotePlayer;
+    alarmManager = window.senzaSDKImplementation.alarmManager;
+    deviceManager = window.senzaSDKImplementation.deviceManager;
+    platformManager = window.senzaSDKImplementation.platformManager;
+    messageManager = window.senzaSDKImplementation.messageManager;
+    ShakaPlayerImplementation = window.senzaSDKImplementation.ShakaPlayer;
+    shakaImplementation = window.senzaSDKImplementation.shaka;
+}
+
+/**
+ * @deprecated use lifecycle.connectReason instead
+ * Returns the reason the ui has been loaded
+ **/
+export function getConnectReason() {
+    return lifecycle.connectReason;
+}
+
+/**
+ * @deprecated use lifecycle.triggerEvent instead
+ * Returns the event that triggered the reloading of the ui after ui has been released
+ **/
+export function getTriggerEvent() {
+    return lifecycle.triggerEvent;
+}
+
+/**
+ * @deprecated use platformManager.setTimezone instead.
+ * @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
+ */
+export function setTimezone(timezone) {
+    // STOP DO NOT CHANGE THIS FUNCTION AS IT IS DEPRECATED!!!!
+    if (window.cefQuery) {
+        const request = { message: JSON.stringify({ type: "setTimeZone", timezone }), waitForResponse: false, target: "UI-Streamer" };
+        window.cefQuery({
+            request: JSON.stringify(request),
+            persistent: false,
+            onSuccess: () => {
+                sdkLogger.log("timezome is successfully set to", timezone);
+            },
+            onFailure: (code, msg) => {
+                sdkLogger.error(`error occurred setting timezone to ${timezone}: ${code} ${msg}`);
+            }
         });
     }
-    sdkLogger.warn("getClientAssertion is not supported if NOT running e2e");
 }
 
+/**
+ * @deprecated use deviceManager.deviceInfo instead.
+ * Returns the device information, including device id, connection id, community, tenant and client ip
+ * */
+export function getDeviceInfo() {
+    // STOP DO NOT CHANGE THIS FUNCTION AS IT IS DEPRECATED!!!!
+    if (isRunningE2E()) {
+        return {
+            deviceId: deviceManager.deviceInfo.deviceId,
+            connectionId: deviceManager.deviceInfo.connectionId,
+            community: deviceManager.deviceInfo.community,
+            tenant: deviceManager.deviceInfo.tenant,
+            clientIp: deviceManager.deviceInfo.clientIp
+        };
+    }
+    sdkLogger.log("getDeviceInfo running locally, returning dummy info");
+    return {
+        deviceId: "123456789",
+        connectionId: "dummy",
+        community: "LocalDev",
+        tenant: "XXXXXX",
+        clientIp: "0.0.0.0"
+    };
+}
+
+export { lifecycle, remotePlayer, alarmManager, deviceManager, platformManager, messageManager, ShakaPlayerImplementation as ShakaPlayer, shakaImplementation as shaka, showSequence, initSequence };
+
 // Assign the senza library to the old name (hs) for backward compatibility
 import * as senzaSDK from "./api.js";
 if (typeof window !== "undefined") {