ota-hub-reactjs 0.0.13 → 0.0.15

package/dist/base/device-whisperer.d.ts

@@ -27,7 +27,6 @@ export type DeviceConnectionState = {
 export declare function createDefaultInitialDeviceState<T extends DeviceConnectionState>(uuid: string, props?: any): T;
 export type DeviceWhispererProps<T extends DeviceConnectionState> = {
     createInitialConnectionState?: (uuid: string) => Partial<T>;
-    connectOn?: boolean;
 };
 export declare function MultiDeviceWhisperer<T extends DeviceConnectionState>({ createInitialConnectionState, }?: DeviceWhispererProps<T>): {
     connections: T[];

package/dist/transport_layers/esp32-device-whisperer.js

@@ -256,7 +256,7 @@ export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
         const port = await navigator.serial.requestPort({
             filters: [{ usbVendorId: 0x303a }]
         });
-        return await base.addConnection({
+        const return_uuid = await base.addConnection({
             uuid,
             propCreator: (id) => {
                 const props = propCreator?.(id);
@@ -271,6 +271,10 @@ export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
                 };
             }
         });
+        const conn = base.getConnection(return_uuid);
+        if (conn?.autoConnect)
+            await connect(return_uuid);
+        return return_uuid;
     };
     const removeConnection = async (uuid) => {
         try {

package/dist/transport_layers/mqtt-device-whisperer.d.ts

@@ -3,7 +3,7 @@ export type MQTTConnectionState = DeviceConnectionState & {
     pingFunction?: (props?: any) => void;
     touchHeartbeat?: () => void;
 };
-export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTConnectionState>({ serverUrl, uuidFromMessage, subTopicFromUuid, pubTopicFromUuid, serverPort, clientId, username, password, autoConnect, ...props }: {
+export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTConnectionState>({ serverUrl, uuidFromMessage, subTopicFromUuid, pubTopicFromUuid, serverPort, clientId, username, password, serverAutoConnect, serverConnectOn, ...props }: {
     serverUrl: string;
     uuidFromMessage: (topic: string, payload: Buffer<ArrayBufferLike>) => string;
     subTopicFromUuid?: (uuid: string) => string;
@@ -12,7 +12,8 @@ export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTC
     clientId?: string;
     username?: string;
     password?: string;
-    autoConnect?: boolean;
+    serverAutoConnect?: boolean;
+    serverConnectOn?: boolean;
 } & DeviceWhispererProps<AppOrMessageLayer>): {
     addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string | undefined>;
     removeConnection: (uuid: string) => Promise<void>;

package/dist/transport_layers/mqtt-device-whisperer.js

@@ -1,7 +1,7 @@
 import { useEffect, useRef } from "react";
 import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
 import mqtt from "mqtt";
-export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicFromUuid = undefined, pubTopicFromUuid = undefined, serverPort = 8883, clientId = undefined, username = undefined, password = undefined, autoConnect = true, ...props }) {
+export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicFromUuid = undefined, pubTopicFromUuid = undefined, serverPort = 8883, clientId = undefined, username = undefined, password = undefined, serverAutoConnect = true, serverConnectOn = false, ...props }) {
     const base = MultiDeviceWhisperer(props);
     const clientRef = useRef(null);
     const isUnmountedRef = useRef(false);
@@ -211,7 +211,9 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         // Delete this adding connections item
         addingConnections.current.delete(uuid);
         // Connect immediately
-        connect(uuid);
+        const conn = base.getConnection(uuid);
+        if (conn?.autoConnect)
+            await connect(uuid);
         return uuid;
     };
     const removeConnection = async (uuid) => {
@@ -228,11 +230,11 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         }
     };
     useEffect(() => {
-        if (!(autoConnect || props.connectOn))
+        if (!(serverAutoConnect || serverConnectOn))
             return;
         const cleanup = connectToMQTTServer();
         return cleanup;
-    }, [serverUrl, props.connectOn]);
+    }, [serverUrl, serverConnectOn]);
     return {
         ...base,
         addConnection,

package/dist/transport_layers/serial-device-whisperer.d.ts

@@ -1,7 +1,8 @@
 import { DeviceConnectionState, AddConnectionProps } from "../base/device-whisperer.js";
 export declare class UsbTransport {
     device: USBDevice;
-    interfaceNumber: number;
+    controlInterface: number;
+    dataInterface: number;
     endpointIn: number;
     endpointOut: number;
     private static readonly SET_LINE_CODING;

package/dist/transport_layers/serial-device-whisperer.js

@@ -14,7 +14,8 @@ import { useEffect } from "react";
 // usb-transport.ts
 export class UsbTransport {
     constructor(device) {
-        this.interfaceNumber = 0;
+        this.controlInterface = 0;
+        this.dataInterface = 1;
         this.endpointIn = 0;
         this.endpointOut = 0;
         this.device = device;
@@ -27,25 +28,40 @@ export class UsbTransport {
         if (this.device.configuration === null) {
             await this.device.selectConfiguration(1);
         }
-        // Find the CDC Data interface (usually class 10) or just the first one with Bulk endpoints
         const interfaces = this.device.configuration?.interfaces || [];
-        let targetInterface;
-        for (const iface of interfaces) {
+        let ctrlIface;
+        let dataIface;
+        dataIface = interfaces.find(iface => {
             const endpoints = iface.alternate.endpoints;
-            const hasIn = endpoints.some(e => e.direction === 'in' && e.type === 'bulk');
-            const hasOut = endpoints.some(e => e.direction === 'out' && e.type === 'bulk');
-            if (hasIn && hasOut) {
-                targetInterface = iface;
-                break;
+            return endpoints.some(e => e.direction === 'in' && e.type === 'bulk') &&
+                endpoints.some(e => e.direction === 'out' && e.type === 'bulk');
+        });
+        if (dataIface) {
+            this.dataInterface = dataIface.interfaceNumber;
+            ctrlIface = interfaces.find(i => i.interfaceNumber === this.dataInterface - 1)
+                || interfaces.find(i => i.alternate.interfaceClass === 2);
+            this.controlInterface = ctrlIface ? ctrlIface.interfaceNumber : this.dataInterface;
+        }
+        if (!dataIface) {
+            throw new Error("No serial-compatible Bulk interface found.");
+        }
+        // Note: On Android, if the OS has claimed Interface 0, this first call will fail.
+        try {
+            if (this.controlInterface !== this.dataInterface) {
+                await this.device.claimInterface(this.controlInterface);
             }
         }
-        if (!targetInterface) {
-            throw new Error("No serial-compatible interface found on device.");
+        catch (e) {
+            console.warn("Could not claim Control Interface (OS locked?). Proceeding to Data...", e);
+            // We continue, but setSignals might fail later.
+        }
+        try {
+            await this.device.claimInterface(this.dataInterface);
+        }
+        catch (e) {
+            throw new Error(`Failed to claim Data Interface. Android OS has locked the device driver. Try using a 'Vendor Specific' USB Class device or a native Serial App workaround.`);
         }
-        this.interfaceNumber = targetInterface.interfaceNumber;
-        await this.device.claimInterface(this.interfaceNumber);
-        // Map endpoints
-        const endpoints = targetInterface.alternate.endpoints;
+        const endpoints = dataIface.alternate.endpoints;
         this.endpointIn = endpoints.find(e => e.direction === 'in' && e.type === 'bulk').endpointNumber;
         this.endpointOut = endpoints.find(e => e.direction === 'out' && e.type === 'bulk').endpointNumber;
         await this.setBaudRate(baudRate);
@@ -57,7 +73,6 @@ export class UsbTransport {
     async write(data) {
         if (!this.device.opened)
             return;
-        // Cast to 'unknown' then 'BufferSource' to satisfy the strict type definition
         await this.device.transferOut(this.endpointOut, data);
     }
     /**
@@ -85,14 +100,13 @@ export class UsbTransport {
     async setSignals({ dtr, rts }) {
         if (!this.device.opened)
             return;
-        // CDC-ACM: DTR is bit 0, RTS is bit 1
         const value = (Number(dtr) | (Number(rts) << 1));
         await this.device.controlTransferOut({
             requestType: 'class',
             recipient: 'interface',
             request: UsbTransport.SET_CONTROL_LINE_STATE,
             value: value,
-            index: this.interfaceNumber
+            index: this.controlInterface
         });
     }
     async setBaudRate(baud) {
@@ -102,20 +116,31 @@ export class UsbTransport {
         // 4 bytes: baud (LE), 1 byte: stop bits, 1 byte: parity, 1 byte: data bits
         const buffer = new ArrayBuffer(7);
         const view = new DataView(buffer);
-        view.setUint32(0, baud, true); // Little Endian
-        view.setUint8(4, 0); // 1 stop bit
-        view.setUint8(5, 0); // No parity
-        view.setUint8(6, 8); // 8 data bits
+        view.setUint32(0, baud, true);
+        view.setUint8(4, 0);
+        view.setUint8(5, 0);
+        view.setUint8(6, 8);
         await this.device.controlTransferOut({
             requestType: 'class',
             recipient: 'interface',
             request: UsbTransport.SET_LINE_CODING,
             value: 0,
-            index: this.interfaceNumber
+            index: this.controlInterface
         }, buffer);
     }
     async disconnect() {
         if (this.device.opened) {
+            // Release both
+            try {
+                await this.device.releaseInterface(this.dataInterface);
+            }
+            catch (e) { }
+            if (this.controlInterface !== this.dataInterface) {
+                try {
+                    await this.device.releaseInterface(this.controlInterface);
+                }
+                catch (e) { }
+            }
             await this.device.close();
         }
     }
@@ -292,7 +317,7 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
             const device = await navigator.usb.requestDevice({
                 filters: []
             });
-            return await base.addConnection({
+            const return_uuid = await base.addConnection({
                 uuid,
                 propCreator: (id) => {
                     const props = propCreator?.(id);
@@ -308,6 +333,10 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
                     };
                 }
             });
+            const conn = base.getConnection(return_uuid);
+            if (conn?.autoConnect)
+                await connect(return_uuid);
+            return return_uuid;
         }
         catch (e) {
             console.log("User cancelled or no device selected");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ota-hub-reactjs",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "ReactJS tools for building web apps to flash MCU devices such as esp32, brought to you by OTA Hub.",
   "type": "module",
   "main": "dist/index.js",