senza-sdk 4.4.5 → 4.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.4.5",
+    "version": "4.4.7",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -34,7 +34,7 @@
         "eslint-plugin-jest": "^28.11.0",
         "globals": "^16.0.0",
         "jest": "^30.2.0",
-        "jest-environment-jsdom" : "^30.2.0",
+        "jest-environment-jsdom": "^30.2.0",
         "jsdoc-to-markdown": "^7.1.1",
         "webpack": "^5.72.1",
         "webpack-cli": "^5.1.4"

package/src/implementation/deviceManager.js

@@ -1,4 +1,4 @@
-import { DeviceManager as DeviceManagerInterface } from "../interface/deviceManager";
+import { DeviceManager as DeviceManagerInterface} from "../interface/deviceManager";
 import { getFCID, sdkLogger, getRestResponse } from "./utils";
 import { sessionInfo } from "./SessionInfo";
 
@@ -9,6 +9,186 @@ let wifi_status_last_update = 0;
 const WIFI_STATUS_CACHE_SECONDS = 5;
 const FACTORY_RESET_TIMEOUT_SECONDS = 5;
 
+const byteSize = str => new Blob([str]).size;
+
+/**
+ *  MessageChannel is not extended from the interface as its objects are only instantiated internally.
+ *  The implementation here needs to match the interface definition which exists purely for documentation.
+ */
+class MessageChannel extends EventTarget {
+    constructor(deviceManager, channelType) {
+        super();
+        switch (channelType) {
+        case deviceManager.DeviceMessageChannelType.SZE_HOST_APP:
+            this._type = deviceManager.DeviceMessageChannelType.SZE_HOST_APP;
+            this._description = "Message channel for bidirectional communication with the Senza Embedded device's host application";
+            this._capabilities = {
+                send: true,
+                receive: true,
+                dataTypes: ["string"],
+                maxMessageSize: 60 * 1024 // 60KB - to account for SCTP default max message size of 64Kb minus the wrapping object overhead
+            };
+            break;
+        case deviceManager.DeviceMessageChannelType.USB_SERIAL:
+            this._type = deviceManager.DeviceMessageChannelType.USB_SERIAL;
+            this._description = "Message channel for sending messages to the device's USB serial interface";
+            this._capabilities = {
+                send: true,
+                receive: false,
+                dataTypes: ["string"],
+                maxMessageSize: 60 * 1024 // 60KB
+            };
+            break;
+        default:
+            throw new Error("Invalid channel type");
+        }
+
+        this._open = true;
+        this._manager = deviceManager;
+    }
+
+    /**
+     * Calls EventTarget's addEventListener after checking if channel is open
+     */
+    addEventListener(type, callback) {
+        if (!this._open) throw new Error("Channel is closed");
+        EventTarget.prototype.addEventListener.call(this, type, callback);
+    }
+
+    /**
+     * Calls EventTarget's removeEventListener after checking if channel is open
+     */
+    removeEventListener(type, callback) {
+        if (!this._open) throw new Error("Channel is closed");
+        EventTarget.prototype.removeEventListener.call(this, type, callback);
+    }
+
+    /**
+     * Marks channel as closed and not usable anymore. Also removes it from the DeviceManager's createdChannels map.
+     */
+    dispose() {
+        if (!this._open) throw new Error("Channel is closed");
+        this._open = false;
+        if (this._manager && typeof this._manager._removeChannel === "function") {
+            this._manager._removeChannel(this._type);
+        }
+    }
+
+    /**
+     * Get the type of this message channel.
+     * @returns {DeviceMessageChannelType} The channel type
+     */
+    get type() {
+        if (!this._open) throw new Error("Channel is closed");
+        return this._type;
+    }
+
+    /**
+     * Get the description of this message channel.
+     * @returns {string} The channel description
+     */
+    get description() {
+        if (!this._open) throw new Error("Channel is closed");
+        return this._description;
+    }
+
+    /**
+     * Get the capabilities of this message channel.
+     * @returns {Object} The capabilities object containing send/receive flags, supported data types, etc.
+     */
+    get capabilities() {
+        if (!this._open) throw new Error("Channel is closed");
+        return this._capabilities;
+    }
+
+    /**
+     * @private
+     * Performs checks to see if a message can be sent through this channel.
+     * @param {*} message The message to check
+     */
+    _checkMessageBeforeSend(message) {
+        if (!this._open) throw new Error("Channel is closed");
+        if (typeof window === "undefined" || typeof window.cefQuery !== "function") {
+            throw new Error("cefQuery is not available");
+        }
+        if (typeof message !== "string" && !(message instanceof String)) {
+            throw new Error("message must be a string");
+        }
+        // Enforce maxMessageSize limit
+        const maxSize = this.capabilities.maxMessageSize;
+        const messageSize = byteSize(message);
+        if (messageSize > maxSize) {
+            throw new Error(`Message size (${messageSize} bytes) exceeds maximum allowed size (${maxSize} bytes)`);
+        }
+    }
+}
+
+/**
+ * Senza Embedded Host App Message Channel
+ */
+class SzeHostAppMessageChannel extends MessageChannel {
+    _docListener = (e) => {
+        const logger = sdkLogger.withFields({ "FCID": e?.detail?.fcid });
+        logger.log("Got hs/deviceMsgSzeHostApp", JSON.stringify(e?.detail));
+
+        const event = new Event("message");
+        event.message = e?.detail?.message || "";
+        this.dispatchEvent(event);
+    };
+
+    constructor(deviceManager) {
+        super(deviceManager, deviceManager.DeviceMessageChannelType.SZE_HOST_APP);
+        // Listen for device host app to web app messages and forward to EventTarget listeners
+        if (typeof document !== "undefined") {
+            document.addEventListener("hs/deviceMsgSzeHostApp", this._docListener);
+        }
+    }
+
+    async sendMessage(message) {
+        this._checkMessageBeforeSend(message);
+        const tc_message = { type: "deviceMsgSzeHostApp", message: message };
+        const request = {
+            target: "TC",
+            waitForResponse: false,
+            message: JSON.stringify(tc_message)
+        };
+        return new Promise((resolve, reject) => {
+            window.cefQuery({
+                request: JSON.stringify(request),
+                persistent: false,
+                onSuccess: () => {
+                    resolve();
+                },
+                onFailure: (code, msg) => {
+                    reject(new Error(`Request failed: ${code} ${msg}`));
+                }
+            });
+        });
+    }
+
+    dispose() {
+        if (typeof document !== "undefined") {
+            document.removeEventListener("hs/deviceMsgSzeHostApp", this._docListener);
+        }
+        super.dispose();
+    }
+}
+
+/**
+ * USB Serial Message Channel implementation
+ */
+class UsbSerialMessageChannel extends MessageChannel {
+    constructor(deviceManager) {
+        super(deviceManager, deviceManager.DeviceMessageChannelType.USB_SERIAL);
+    }
+
+    async sendMessage(message) {
+        this._checkMessageBeforeSend(message);
+        // Use the existing sendDataToDevice functionality
+        return getDeviceManagerInstance().sendDataToDevice(message);
+    }
+}
+
 async function getWifiApData() {
     // Wi-Fi access point data is static, so it needs to be retrieved only once
     if (!wifi_ap_data) {
@@ -38,6 +218,13 @@ class DeviceManager extends DeviceManagerInterface {
 
     constructor() {
         super();
+        this.availableMessageChannels = [
+            // Future enhancement: add available channels based on cfg or some device info
+            this.DeviceMessageChannelType.SZE_HOST_APP,
+            this.DeviceMessageChannelType.USB_SERIAL
+        ];
+        // Track created channels in a map to enforce one-per-type limit, i.e. only one SZE_HOST_APP channel at a time
+        this.createdChannels = new Map();
     }
 
     get deviceInfo() {
@@ -202,10 +389,67 @@ class DeviceManager extends DeviceManagerInterface {
         await Promise.all([getWifiApData(), getWifiStatus()]);
         return { ...wifi_ap_data, ...wifi_status };
     }
+
+    /**
+     * Returns a list of available message channels for the device.
+     * @returns {DeviceMessageChannelType[]} An array of DeviceMessageChannelType values representing the available message channels.
+     */
+    getAvailableMessageChannels() {
+        return this.availableMessageChannels || [];
+    }
+
+    /**
+     * Create a message channel of the specified type.
+     * Only one channel of each type can be created at a time.
+     * @param {DeviceMessageChannelType} type The type of message channel to create.
+     * @returns {MessageChannel} A MessageChannel object representing the created message channel.
+     * @throws {Error} If the specified type is not supported or already exists.
+     */
+    createMessageChannel(type) {
+        const channelType = this.availableMessageChannels.find(c => c === type);
+        const availableTypes = this.availableMessageChannels.join(", ");
+        if (!channelType) {
+            throw new Error(`Unsupported channel type: ${type}. Available types: ${availableTypes}`);
+        }
+        // Check if a channel of this type already exists
+        if (this.createdChannels.has(type)) {
+            throw new Error(`A message channel of type '${type}' already exists. Only one channel per type is allowed.`);
+        }
+        // Create channel implementation based on type
+        let channel;
+        if (type === this.DeviceMessageChannelType.SZE_HOST_APP) {
+            channel = new SzeHostAppMessageChannel(this);
+        } else if (type === this.DeviceMessageChannelType.USB_SERIAL) {
+            channel = new UsbSerialMessageChannel(this);
+        }
+        // else channel type is unsupported, but is already checked above
+
+        this.createdChannels.set(type, channel);
+        return channel;
+    }
+
+    /**
+     * Remove a message channel of the specified type.
+     * @private
+     * @param {DeviceMessageChannelType} type The type of message channel to remove.
+     */
+    _removeChannel(type) {
+        if (!this.createdChannels || !this.createdChannels.has(type)) {
+            throw new Error(`No channel of type '${type}' exists.`);
+        }
+        this.createdChannels.delete(type);
+    }
 }
 
-/**
+// Create the singleton instance
+const deviceManagerInstance = new DeviceManager();
+
+// Function to get the singleton instance (for forward reference)
+function getDeviceManagerInstance() {
+    return deviceManagerInstance;
+}
 
+/**
  * @module
  * @example
  * import { deviceManager } from "senza-sdk";
@@ -214,6 +458,13 @@ class DeviceManager extends DeviceManagerInterface {
  * await deviceManager.clearWifi();
  * deviceManager.reboot();
  *
+ * // Message channels
+ * const channels = deviceManager.getAvailableMessageChannels();
+ * const channel = deviceManager.createMessageChannel(deviceManager.DeviceMessageChannelType.SZE_HOST_APP);
+ * channel.addEventListener('message', (event) => {
+ *     console.log(`Received: ${event.message}`);
+ * });
+ *
  * @return {DeviceManager} pointer to the DeviceManager singleton
  */
-export const deviceManager = new DeviceManager();
+export const deviceManager = deviceManagerInstance;