senza-sdk 4.2.64-70c0747.0 → 4.2.64

package/src/api.js

@@ -1,11 +1,19 @@
-import { sdkLogger, noop } from "./interface/utils.js";
+import { getFCID, sdkLogger } from "./utils";
 import pack from "../package.json";
-import { Lifecycle, RemotePlayer, DeviceManager, PlatformManager, AlarmManager, MessageManager, ShakaPlayer, shaka, showSequence, initSequence } from "./interface/api.js";
-
+import { sessionInfo } from "./SessionInfo";
 const { version } = pack;
+import { initSequence, showSequence } from "./devSequence.js";
+import { lifecycle } from "./lifecycle";
+import { alarmManager } from "./alarmManager";
 
 let authToken;
 
+const API_VERSION = "1.0";
+
+typeof document !== "undefined" && document.addEventListener("keydown", (event) => {
+    sdkLogger.log(`Got ${event.key} key`);
+});
+
 /** @namespace auth
  *@example
  * import { auth } from "senza-sdk";
@@ -23,87 +31,334 @@ export const auth = {
 };
 
 /**
- *  Should be called once to init the library
- * @example
+ * @deprecated use lifecycle.ConnectReason instead.
+ * @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
+ */
+export const 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"
+});
+
+import { remotePlayer } from "./remotePlayer";
+export { remotePlayer };
+
+/** Should be called once to init the library
+ *@example
  * import { init } from "senza-sdk";
  * await init();
  **/
 export async function init() {
-    sdkLogger.log(`init interface ${version}`);
-    if (window.senzaSDKImplementation) {
-        await window.senzaSDKImplementation.init(version, showSequence, initSequence);
+    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);
+        }
+
     } else {
-        noop("init");
+        authToken = getPlatformInfo().sessionInfo?.settings?.webUI?.backendHeaders?.Authorization;
+        sdkLogger.log(`authToken dummy: token = ${authToken}`);
     }
+
     // 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 (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"
+    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"
+                        }
                     }
+                },
+                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);
             },
-            homeSessionInfo: {
-                tenantId: "XXXXXX",
-                community: "LocalDev"
+            onFailure: (code, msg) => {
+                sdkLogger.error(`error occurred setting timezone to ${timezone}: ${code} ${msg}`);
             }
-        }
-    };
+        });
+    }
 }
 
 async function getToken() {
-    if (window.senzaSDKImplementation) {
-        return window.senzaSDKImplementation.auth.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 });
+        });
     }
     return Promise.resolve(authToken);
 }
 
 function forceTokenUpdate() {
     authToken = null;
-    if (window.senzaSDKImplementation) {
-        return window.senzaSDKImplementation.auth.forceTokenUpdate();
-    }
-    sdkLogger.error("forceTokenUpdate: window.cefQuery is undefined");
 
+    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");
+    }
 }
 
 /** 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.senzaSDKImplementation);
+    return !!(typeof window !== "undefined" && window.cefQuery);
 }
 
 /** Call this API once after application startup, when the ui is ready to accept keys/events */
 export function uiReady() {
-    if (window.senzaSDKImplementation) {
-        return window.senzaSDKImplementation.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");
     }
-    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";
@@ -114,12 +369,10 @@ export function uiReady() {
  * @property {string}  envInfo.sdkVersion      - the version of the SDK
  */
 export const envInfo = {
-    remoteBrowserIp: window?.diagnostics?.()?.podIP || "127.0.0.1",
-    sdkVersion: version,
-    sdkBackendVersion: window?.senzaSDKImplementation?.version || "N/A"
+    remoteBrowserIp: window.diagnostics ? window.diagnostics().podIP : "127.0.0.1",
+    sdkVersion: version
 };
 
-
 /**
  * The function receives a license response and passes it to platform.
  * @param {number} statusCode status code that was received from the license server
@@ -130,10 +383,31 @@ export const envInfo = {
  * In case of error licenseResponse is of type @type {string}
  */
 export function writeLicenseResponse(statusCode, licenseResponse, fcid, sessionId) {
-    if (window?.senzaSDKImplementation) {
-        return window.senzaSDKImplementation.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}`);
+            }
+        });
     }
-    sdkLogger.error("writeLicenseResponse: window.cefQuery is undefined");
+
 }
 
 export class ClientAssertionError extends Error {
@@ -164,141 +438,34 @@ export class ClientAssertionError extends Error {
  * }
  */
 export function getClientAssertion() {
-    if (window?.senzaSDKImplementation) {
-        return window.senzaSDKImplementation.auth.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"));
+                    }
+
+                },
+                onFailure: (code, msg) => {
+                    sdkLogger.log(`client_assertion request failed: ${code} ${msg}`);
+                    reject(new ClientAssertionError(code, msg));
+                }
+            });
+        });
     }
     sdkLogger.warn("getClientAssertion is not supported if NOT running e2e");
 }
 
-/**
- * @module
- * @type {Lifecycle}
- * @example
- * import { lifecycle } from "senza-sdk";
- *
- * @return {Lifecycle} pointer to the Lifecycle singleton
- */
-let lifecycle;
-
-/**
- * @module
- * @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
- * @type {AlarmManager}
- * @example
- * import { alarmManager } from "senza-sdk";
- *
- * @return {AlarmManager} pointer to the AlarmManager singleton
- */
-let alarmManager;
-
-/**
- * @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
- */
-let deviceManager;
-
-
-/**
- * @module
- * @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
- * @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
- * @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
- * @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 {
-    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;
-}
-
-
-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") {

package/src/{interface/devSequence.js → devSequence.js}

@@ -204,6 +204,7 @@ const setupSequence = (components, items) => {
     };
     methodInject(components, inject, (name) => name.startsWith("_") || name.startsWith("get"));
     handleKeys(items);
+    playersEvents(components, items);
     sdkLogger.log("Sequence initialized.");
 };
 
@@ -257,3 +258,37 @@ export const showSequence = (visible = true) => {
     }
     container.style.visibility = visible ? "visible" : "hidden";
 };
+function playersEvents(components, items) {
+    components.remotePlayer.addEventListener("videoelementattached", () => {
+        const video = components.remotePlayer._videoElement;
+        if (video && !video._devSequenceRateChangeHandler) {
+            video._devSequenceRateChangeHandler = () => {
+                items.push({
+                    component: "localPlayer",
+                    id: "ratechange=" + video.playbackRate,
+                    time: performance.now() - currentTime
+                });
+            };
+            video.addEventListener("ratechange", video._devSequenceRateChangeHandler);
+        }
+
+        if (video && !video._devSequencePlayingHandler) {
+            video._devSequencePlayingHandler = () => {
+                items.push({
+                    component: "localPlayer",
+                    id: "playing event",
+                    time: performance.now() - currentTime
+                });
+            };
+            video.addEventListener("playing", video._devSequencePlayingHandler);
+        }
+    });
+    components.remotePlayer.addEventListener("playing", () => {
+        items.push({
+            component: "remotePlayer",
+            id: "playing event",
+            time: performance.now() - currentTime
+        });
+    });
+}
+