senza-sdk 4.2.64-70c0747.0 → 4.2.65-4527e57.0

package/src/implementation/api.js

@@ -1,367 +0,0 @@
-import { getFCID, sdkLogger, getVersion } from "./utils.js";
-import { sessionInfo } from "./SessionInfo.js";
-import { lifecycle } from "./lifecycle.js";
-import { alarmManager } from "./alarmManager.js";
-
-let authToken;
-
-const API_VERSION = "1.0";
-let interfaceVersion;
-
-typeof document !== "undefined" && document.addEventListener("keydown", (event) => {
-    sdkLogger.log(`Got ${event.key} key`);
-});
-
-/** @namespace auth
- *@example
- * import { auth } from "senza-sdk";
- **/
-export const auth = {
-
-    /** Should be called upon startup and be embedded in future requests */
-    getToken,
-
-    /** Should be called upon '401' event (unauthorized) */
-    forceTokenUpdate,
-
-    getClientAssertion
-
-};
-
-import { remotePlayer } from "./remotePlayer.js";
-export { remotePlayer };
-
-/** Should be called once to init the library
- *@example
- * import { init } from "senza-sdk";
- * await init();
- **/
-export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFunc) {
-    interfaceVersion = interfaceApiVersion;
-    sdkLogger.addfields({ interfaceVersion });
-    sdkLogger.log(`init. Interface version: ${interfaceVersion}. Implementation version: ${getVersion()}`);
-
-    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) {
-            initSequenceFunc({ lifecycle, remotePlayer });
-            showSequenceFunc(true);
-        }
-
-    } else {
-        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.");
-    };
-
-
-}
-
-// 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"
-                        }
-                    }
-                },
-                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 });
-        });
-    }
-    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");
-    }
-}
-
-/** 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);
-}
-
-/** 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");
-    }
-}
-
-export { lifecycle } from "./lifecycle.js";
-export { deviceManager } from "./deviceManager.js";
-export { platformManager } from "./platformManager.js";
-export { alarmManager };
-export { messageManager } from "./messageManager.js";
-export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
-
-import "./devHelper.js";
-
-/**
- * The function receives a license response and passes it to platform.
- * @param {number} statusCode status code that was received from the license server
- * @param {ArrayBuffer|string} licenseResponse a license response that was received from the license server to be passed to platform.
- * @param {string} fcid a fcid received with the license request
- * @param {string} sessionId a sessionId received with the license request
- * In case of success licenceResponse is of type @type {ArrayBuffer}
- * 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}`);
-            }
-        });
-    }
-
-}
-
-export class ClientAssertionError extends Error {
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-}
-
-/**
- * @typedef Token
- * @property {string} hostplatform_assertion The client assertion token.
-*/
-
-/**
- * Async function that returns the client assertion
- * @return {Promise<Token>} Promise which is resolved to a client assertion object when getClientAssertion has been successfully performed. * client assertion object contains hostplatform_assertion property which holds the client assertion token.
- * Failure to getClientAssertion for any reason, result in the promise being rejected.
- * Error status codes:
- * Status code 400 - Tenant configuration is missing
- * Status code 0 - General error
- *  @example
- * try {
- *     const client_assertion = await auth.getClientAssertion();
- *     console.log("Client assertion token is", client_assertion.hostplatform_assertion);
- * } catch (e) {
- *     console.error("getClientAssertion failed", e);
- * }
- */
-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"));
-                    }
-
-                },
-                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");
-}
-
-import * as senzaSDK from "./api.js";
-if (typeof window !== "undefined") {
-    window.senzaSDKImplementation = window.senzaSDKImplementation || senzaSDK; // this is only for testing purposes which allows us to use and test senza APIs in pipeline tests
-}

package/src/interface/alarmManager.js

@@ -1,69 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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";

package/src/interface/deviceManager.js

@@ -1,133 +0,0 @@
-import { sdkLogger, noop } from "./utils.js";
-
-const wifiInfo = {};
-
-/**
- * @class DeviceManager
- * DeviceManager is a singleton class that manages the device
- */
-export class DeviceManager extends EventTarget {
-
-    constructor() {
-        super();
-        wifiInfo.level = 0;
-        wifiInfo.quality = 0;
-        wifiInfo.ssid = "unknown";
-        wifiInfo.bssid = "unknown";
-        /**
-         * @deprecated Instead, call deviceManager.getWifiInfo() periodically
-         * @event DeviceManager#wifiInfoUpdated
-         * @example
-         * deviceManager.addEventListener("wifiInfoUpdated", () => {
-         *   console.info("Wifi info has been updated to", deviceManager.wifiInfo);
-         * });
-         *
-         */
-    }
-
-    /**
-     * @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({});
-    }
-}