@robdobsn/raftjs 1.1.1 → 1.3.1

package/src/{RaftChannelWebBLE.ts → RaftChannelBLE.web.ts}

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
-// RaftChannelWebBLE
+// RaftChannelBLE
 // Part of RaftJS
 //
 // Rob Dobson & Chris Greening 2020-2024
@@ -15,7 +15,7 @@ import RaftMsgHandler from "./RaftMsgHandler";
 import { ConnectorOptions } from "./RaftSystemType";
 import RaftUtils from "./RaftUtils";
 
-export default class RaftChannelWebBLE implements RaftChannel {
+export default class RaftChannelBLE implements RaftChannel {
   // BLE UUIDS
   public static ServiceUUID = "aa76677e-9cfd-4626-a510-0d305be57c8d";
   public static CmdUUID = "aa76677e-9cfd-4626-a510-0d305be57c8e";
@@ -66,7 +66,10 @@ export default class RaftChannelWebBLE implements RaftChannel {
 
   // RICREST command before disconnect
   ricRestCmdBeforeDisconnect(): string | null {
-    return "blerestart";
+    // NT: Sending blerestart *before* disconnecting results in timeout issues as the device is no longer connected when we try to actually disconnect
+    // suggested fix: allow callaback command to be sent after disconnect on the fw side 
+    // return "blerestart";
+    return null;
   }
 
   // isEnabled
@@ -96,7 +99,7 @@ export default class RaftChannelWebBLE implements RaftChannel {
   // Disconnection event
   onDisconnected(event: Event): void {
     const device = event.target as BluetoothDevice;
-    RaftLog.debug(`RaftChannelWebBLE.onDisconnected ${device.name}`);
+    RaftLog.debug(`RaftChannelBLE.onDisconnected ${device.name}`);
     if (this._bleDevice) {
       this._bleDevice.removeEventListener(
         "gattserverdisconnected",
@@ -126,7 +129,7 @@ export default class RaftChannelWebBLE implements RaftChannel {
           const connTimeoutMs = _connectorOptions.connTimeoutMs || 5000;
           await RaftUtils.withTimeout(connTimeoutMs, this._bleDevice.gatt.connect());
           RaftLog.debug(
-            `RaftChannelWebBLE.connect - ${
+            `RaftChannelBLE.connect - ${
               this._bleDevice.gatt.connected ? "OK" : "FAILED"
             } attempt ${connRetry+1} connection to device ${this._bleDevice.name}`
           );
@@ -140,32 +143,32 @@ export default class RaftChannelWebBLE implements RaftChannel {
             try {
 
               const service = await this._bleDevice.gatt.getPrimaryService(
-                RaftChannelWebBLE.ServiceUUID
+                RaftChannelBLE.ServiceUUID
               );
               RaftLog.debug(
-               `RaftChannelWebBLE.connect - found service: ${service.uuid}`
+               `RaftChannelBLE.connect - found service: ${service.uuid}`
               );
 
               try {
                 // Get Tx and Rx characteristics
                 this._characteristicTx = await service.getCharacteristic(
-                  RaftChannelWebBLE.CmdUUID
+                  RaftChannelBLE.CmdUUID
                 );
                 RaftLog.debug(
-                  `RaftChannelWebBLE.connect - found char ${this._characteristicTx.uuid}`
+                  `RaftChannelBLE.connect - found char ${this._characteristicTx.uuid}`
                 );
                 this._characteristicRx = await service.getCharacteristic(
-                  RaftChannelWebBLE.RespUUID
+                  RaftChannelBLE.RespUUID
                 );
                 RaftLog.debug(
-                   `RaftChannelWebBLE.connect - found char ${this._characteristicRx.uuid}`
+                   `RaftChannelBLE.connect - found char ${this._characteristicRx.uuid}`
                 );
 
                 // Notifications of received messages
                 try {
                   await this._characteristicRx.startNotifications();
                   RaftLog.debug(
-                    "RaftChannelWebBLE.connect - notifications started"
+                    "RaftChannelBLE.connect - notifications started"
                   );
                   this._characteristicRx.addEventListener(
                     "characteristicvaluechanged", 
@@ -173,12 +176,12 @@ export default class RaftChannelWebBLE implements RaftChannel {
                   );
                 } catch (error) {
                   RaftLog.debug(
-                    "RaftChannelWebBLE.connnect - addEventListener failed " + error
+                    "RaftChannelBLE.connnect - addEventListener failed " + error
                   );
                 }
 
                 // Connected ok
-                RaftLog.debug(`RaftChannelWebBLE.connect ${this._bleDevice.name}`);
+                RaftLog.debug(`RaftChannelBLE.connect ${this._bleDevice.name}`);
 
                 // Add disconnect listener
                 this._eventListenerFn = this.onDisconnected.bind(this);
@@ -192,24 +195,24 @@ export default class RaftChannelWebBLE implements RaftChannel {
                 return true;
               } catch (error) {
                 RaftLog.error(
-                  `RaftChannelWebBLE.connect - cannot find characteristic: ${error}`
+                  `RaftChannelBLE.connect - cannot find characteristic: ${error}`
                 );
               }
             } catch (error) {
               if (connRetry === this._maxConnRetries - 1) {
                 RaftLog.error(
-                  `RaftChannelWebBLE.connect - cannot get primary service ${error} - attempt #${connRetry+1} - giving up`
+                  `RaftChannelBLE.connect - cannot get primary service ${error} - attempt #${connRetry+1} - giving up`
                 );
               } else {
                 RaftLog.debug(
-                   `RaftChannelWebBLE.connect - cannot get primary service - attempt #${connRetry+1} ${error}`
+                   `RaftChannelBLE.connect - cannot get primary service - attempt #${connRetry+1} ${error}`
                 );
               }
             }
           }
         }
       } catch (error: unknown) {
-        RaftLog.warn(`RaftChannelWebBLE.connect - cannot connect ${error}`);
+        RaftLog.warn(`RaftChannelBLE.connect - cannot connect ${error}`);
       }
 
       // Disconnect
@@ -221,7 +224,7 @@ export default class RaftChannelWebBLE implements RaftChannel {
         try {
           await this._bleDevice.gatt.disconnect();
         } catch (error) {
-          RaftLog.warn(`RaftChannelWebBLE.connect - cannot disconnect ${error}`);
+          RaftLog.warn(`RaftChannelBLE.connect - cannot disconnect ${error}`);
         }
       }
     }
@@ -233,10 +236,10 @@ export default class RaftChannelWebBLE implements RaftChannel {
   async disconnect(): Promise<void> {
     if (this._bleDevice && this._bleDevice.gatt) {
       try {
-        RaftLog.debug(`RaftChannelWebBLE.disconnect GATT`);
+        RaftLog.debug(`RaftChannelBLE.disconnect GATT`);
         await this._bleDevice.gatt.disconnect();
       } catch (error) {
-        RaftLog.debug(`RaftChannelWebBLE.disconnect ${error}`);
+        RaftLog.debug(`RaftChannelBLE.disconnect ${error}`);
       }
     }
   }
@@ -263,7 +266,7 @@ export default class RaftChannelWebBLE implements RaftChannel {
         try {
           this._raftMsgHandler.handleNewRxMsg(msg);
         } catch (error) {
-          RaftLog.debug(`RaftChannelWebBLE.onMsgRx ${error}`);
+          RaftLog.debug(`RaftChannelBLE.onMsgRx ${error}`);
         }
       }
     }
@@ -302,7 +305,7 @@ export default class RaftChannelWebBLE implements RaftChannel {
       } catch (error) {
         if (retryIdx === this.maxRetries - 1) {
           RaftLog.info(
-            `RaftChannelWebBLE.sendTxMsg ${error} retried ${retryIdx} times`
+            `RaftChannelBLE.sendTxMsg ${error} retried ${retryIdx} times`
           );
         }
       }

package/src/RaftChannelBLEFactory.ts

@@ -0,0 +1,13 @@
+/**
+ * @description
+ * This file is used to create a new instance of the RaftChannelBLE class.
+ * RaftChannelBLE exists in 2 files: RaftChannelBLE.native.ts and RaftChannelBLE.web.ts
+ * each of these files contains the same class but with different implementations (native and web).
+ * The import statement at the top of the file will import the correct implementation based on the platform 
+ * (depending on the build configuration).
+ */
+import RaftChannelBLE from './RaftChannelBLE';
+
+export function createBLEChannel() {
+  return RaftChannelBLE;
+}

package/src/RaftChannelBLEScanner.native.ts

@@ -0,0 +1,185 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RICBLEScanner
+// Communications Connector for RIC V2
+//
+// RIC V2
+// Rob Dobson 2022
+// (C) Robotical 2022
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+import {
+  BleManager,
+  Device,
+  BleError,
+} from 'react-native-ble-plx';
+import { DiscoveredRIC } from './RaftTypes';
+import RaftLog from './RaftLog';
+import { RaftConnEvent, RaftConnEventFn } from './RaftConnEvents';
+
+export default class RICBLEScanner {
+
+  // BleManager
+  _bleManager: BleManager;
+
+  // Services to scan for
+  _uuidsOfServicesToScanFor: Array<string> = [];
+
+  // Scanned devices found on BLE
+  _discoveredRICs: DiscoveredRIC[] = [];
+  static _scanInProgress = false;
+
+  // Time to scan for
+  _discoveryTimeMs = 10000;
+
+  // Event callback
+  _eventCallback: RaftConnEventFn;
+
+  constructor(bleManager: BleManager, uuidsOfServicesToScanFor: Array<string>, eventCallback: RaftConnEventFn) {
+    this._bleManager = bleManager;
+    this._uuidsOfServicesToScanFor = uuidsOfServicesToScanFor;
+    this._eventCallback = eventCallback;
+  }
+
+  // Get discovered RICs
+  getDiscoveredRICs(): DiscoveredRIC[] {
+    return this._discoveredRICs;
+  }
+
+  // Check is a scan is in progress
+  isScanInProgress(): boolean {
+    return RICBLEScanner._scanInProgress;
+  }
+
+  async scanningStart(): Promise<boolean> {
+
+    // Handle discovery
+    RaftLog.debug('Starting Scanning...');
+
+    // Clear list
+    this._discoveredRICs = [];
+
+    // Disconnect any connections
+    RICBLEScanner._scanInProgress = true;
+
+    // Start scan
+    try {
+      this._bleManager.startDeviceScan(
+        this._uuidsOfServicesToScanFor,
+        { allowDuplicates: true },
+        (error: BleError | null, device: Device | null) => {
+          // RaftLog.debug(`discoveryFoundCB error ${error}`);
+          this._discoveryFoundCB(error, device);
+        },
+      );
+    } catch (e) {
+      RaftLog.warn(`Error starting scan ${e}`);
+      return false;
+    }
+
+    // Set a time limit
+    this._discoverySetTimeLimit(this._discoveryTimeMs);
+    return true;
+  }
+
+  scanningStop(): void {
+
+    RaftLog.debug('scanningStop');
+
+    // Emit finished if we were scanning
+    RaftLog.debug(`IS SCANNING IN PROGRESS: ${RICBLEScanner._scanInProgress}`);
+    if (RICBLEScanner._scanInProgress) {
+      RaftLog.debug(`sending BLE_SCANNING_FINISHED event`);
+      this._eventCallback(RaftConnEvent.BLE_SCANNING_FINISHED, { discoveredRICs: this._discoveredRICs });
+    }
+
+    // Cancel scanning
+    this._bleManager.stopDeviceScan();
+    RICBLEScanner._scanInProgress = false;
+  }
+
+  // Callback from BLE-PLX library on device discovered
+  _discoveryFoundCB(
+    error: BleError | null,
+    scannedDevice: Device | null,
+  ): void {
+    if (error) {
+      //RaftLog.warn(`⚠️ Scan Error >> ${error.toString()}`);
+      RaftLog.warn(`⚠️ Scan Error >> ${JSON.stringify(error)}`);
+      // Event if we were scanning
+      if (RICBLEScanner._scanInProgress) {
+        this._eventCallback(RaftConnEvent.BLE_SCANNING_FINISHED, {
+          discoveredRICs: this._discoveredRICs,
+        });
+        RICBLEScanner._scanInProgress = false;
+      }
+      return;
+    }
+
+    // See if already in the list
+    const ricAlreadyFound = this._discoveredRICs.find(
+      item => item.id === scannedDevice!.id,
+    );
+
+    RaftLog.debug(`✅ Scanning... >> ${scannedDevice}`);
+
+    if (ricAlreadyFound) {
+      // update the rssi value if it's not 127
+      if (scannedDevice!.rssi !== null && scannedDevice!.rssi !== 127) {
+        ricAlreadyFound._rssi = scannedDevice!.rssi;
+        this._eventCallback(RaftConnEvent.BLE_DEVICE_FOUND, {
+          discoveredRIC: ricAlreadyFound
+        });
+      }
+      return;
+    }
+
+    if (scannedDevice !== null) {
+      if (!scannedDevice.localName) {
+        // if the name of the device is null, don't add this device
+        // the first time round. Second time this device comes up
+        // will have all the needed info
+        return;
+      }
+      const newDiscoveredRic = new DiscoveredRIC(
+        scannedDevice.localName !== null ? scannedDevice.localName : '',
+        scannedDevice.name !== null ? scannedDevice.name : '',
+        scannedDevice.id,
+        scannedDevice.rssi !== null ? scannedDevice.rssi : -150,
+      );
+      this._discoveredRICs.push(newDiscoveredRic);
+      // send the newly found ric to the state so it can pop-up on the front-end
+      this._eventCallback(RaftConnEvent.BLE_DEVICE_FOUND, {
+        discoveredRIC: newDiscoveredRic
+      });
+    }
+    RaftLog.debug(`🤖 Scanned RICs >> ${this._discoveredRICs}`);
+  }
+
+  // Time-limit on device scanning
+  _discoverySetTimeLimit(timeLimitMs: number) {
+    setTimeout(() => {
+      // Stop scanning
+      this._bleManager.stopDeviceScan();
+
+      // Check we were scanning
+      if (RICBLEScanner._scanInProgress) {
+        // Sort by signal strength
+        // this._discoveredRICs.sort((a, b) => {
+        //   return b!.rssi! - a!.rssi!;
+        // });
+
+        // Debug
+        const msg = `🤖 ${this._discoveredRICs.length} RICs found! Choose one to connect`;
+        RaftLog.debug(msg);
+
+        // Finished event
+        this._eventCallback(RaftConnEvent.BLE_SCANNING_FINISHED, {
+          discoveredRICs: this._discoveredRICs,
+        });
+      }
+      RICBLEScanner._scanInProgress = false;
+    }, timeLimitMs);
+  }
+}

package/src/RaftChannelWebSerial.ts

@@ -13,6 +13,7 @@ import RaftMsgHandler from "./RaftMsgHandler";
 import RaftLog from "./RaftLog";
 import { RaftConnEvent, RaftConnEventFn } from "./RaftConnEvents";
 import { ConnectorOptions } from "./RaftSystemType";
+import { TextDecoder } from 'text-encoding';
 
 type TWebParityType = 'none' | 'even' | 'odd';
 type TWebFlowControlType = 'none' | 'hardware';

package/src/RaftConnEvents.ts

@@ -21,7 +21,13 @@ export enum RaftConnEvent {
     CONN_GETTING_INFO,
     CONN_GOT_INFO,
     CONN_BLUETOOTH_STATE,
-    CONN_STREAMING_ISSUE
+    CONN_STREAMING_ISSUE,
+
+    // PHONE_BLE_ONLY
+    BLE_SCANNING_STARTED,
+    BLE_DEVICE_FOUND,
+    BLE_SCANNING_FINISHED,
+    BLE_BLUETOOTH_STATE,
 }
 
 export const RaftConnEventNames = {
@@ -38,9 +44,15 @@ export const RaftConnEventNames = {
     [RaftConnEvent.CONN_GOT_INFO]: 'GOT_INFO',
     [RaftConnEvent.CONN_BLUETOOTH_STATE]: 'BLUETOOTH_STATE',
     [RaftConnEvent.CONN_STREAMING_ISSUE]: 'STREAMING_ISSUE',
+
+    // PHONE_BLE_ONLY
+    [RaftConnEvent.BLE_SCANNING_STARTED]: 'BLE_SCANNING_STARTED',
+    [RaftConnEvent.BLE_DEVICE_FOUND]: 'BLE_DEVICE_FOUND',
+    [RaftConnEvent.BLE_SCANNING_FINISHED]: 'BLE_SCANNING_FINISHED',
+    [RaftConnEvent.BLE_BLUETOOTH_STATE]: 'BLE_BLUETOOTH_STATE',
 };
   
 export type RaftConnEventFn = (
   eventType: RaftConnEvent,
-  data?: string[] | string | null,
+  data?: any | string[] | string | null,
 ) => void;

package/src/RaftConnector.ts

@@ -9,7 +9,6 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 import RaftChannel from "./RaftChannel";
-import RaftChannelWebBLE from "./RaftChannelWebBLE";
 import RaftMsgHandler, { RaftMsgResultCode } from "./RaftMsgHandler";
 import RaftChannelWebSocket from "./RaftChannelWebSocket";
 import RaftChannelWebSerial from "./RaftChannelWebSerial";
@@ -23,6 +22,8 @@ import { RaftConnEvent, RaftConnEventNames } from "./RaftConnEvents";
 import { RaftGetSystemTypeCBType, RaftSystemType } from "./RaftSystemType";
 import { RaftUpdateEvent, RaftUpdateEventNames } from "./RaftUpdateEvents";
 import RaftUpdateManager from "./RaftUpdateManager";
+import { createBLEChannel } from "./RaftChannelBLEFactory";
+
 
 export default class RaftConnector {
 
@@ -155,10 +156,10 @@ export default class RaftConnector {
     return this._channelConnMethod;
   }
 
-    /**
-   * Get connection locator
-   * @returns string | object - connection locator
-   * */
+  /**
+ * Get connection locator
+ * @returns string | object - connection locator
+ * */
   getConnLocator(): any | null {
     return this._raftChannel ? this._raftChannel.getConnectedLocator() : null;
   }
@@ -204,51 +205,27 @@ export default class RaftConnector {
   }
 
   /**
-   * Connect to a Raft application
-   *
-   * @param {string} method - can be "WebBLE", "WebSocket" or "WebSerial"
-   * @param {string | object} locator - either a string (WebSocket URL or serial port) or an object (WebBLE)
-   * @returns Promise<boolean>
-   *
+   * Initialize the Raft channel
    */
-  async connect(method: string, locator: string | object): Promise<boolean> {
-
-    // Ensure disconnected
-    try {
-      await this.disconnect();
-    } catch (err) {
-      RaftLog.error('RaftConnector.connect - error: ' + err);
-      // Ignore
-    }
-
-    // Check connection method
-    let connMethod = "";
-    if (method === 'WebBLE' && typeof locator === 'object' && locator !== null) {
-
-      // Create channel
-      this._raftChannel = new RaftChannelWebBLE();
-      connMethod = 'WebBLE';
-
-    } else if (((method === 'WebSocket') || (method === 'wifi')) && (typeof locator === 'string')) {
-
-      // Create channel
+  async initializeChannel(method: string): Promise<boolean> {
+    // Initialize raft channel
+    if (method === 'WebBLE' || method === 'PhoneBLE') {
+      const RaftChannelBLE = createBLEChannel();
+      this._raftChannel = new RaftChannelBLE();
+      this._channelConnMethod = method;
+    } else if (method === 'WebSocket' || method === 'wifi') {
       this._raftChannel = new RaftChannelWebSocket();
-      connMethod = 'WebSocket';
-    } else if (((method === 'WebSerial'))) {
+      this._channelConnMethod = 'WebSocket';
+    } else if (method === 'WebSerial') {
       this._raftChannel = new RaftChannelWebSerial();
-      connMethod = 'WebSerial';
+      this._channelConnMethod = 'WebSerial';
+    } else {
+      RaftLog.error('Unknown method: ' + method);
+      return false;
     }
 
-    RaftLog.debug(`connecting with connMethod ${connMethod}`);
-
     // Check channel established
-    let connOk = false;
     if (this._raftChannel !== null) {
-
-      // Connection method and locator
-      this._channelConnMethod = connMethod;
-      this._channelConnLocator = locator;
-
       // Set message handler
       this._raftChannel.setMsgHandler(this._raftMsgHandler);
       this._raftChannel.setOnConnEvent(this.onConnEvent.bind(this));
@@ -257,62 +234,79 @@ export default class RaftConnector {
       this._raftMsgHandler.registerForResults(this);
       this._raftMsgHandler.registerMsgSender(this._raftChannel);
 
-      // Connect
-      try {
+      return true;
+    } else {
+      this._channelConnMethod = "";
+      return false;
+    }
+  }
+
+  /**
+   * Connect to a Raft device
+   *
+   * @param {string | object} locator - either a string (WebSocket URL or serial port) or an object (WebBLE)
+   * @returns Promise<boolean>
+   *
+   */
+  async connect(locator: string | object): Promise<boolean> {
+    if (!this._raftChannel) {
+      RaftLog.error('Raft channel is not initialized.');
+      return false;
+    }
 
-        // Event
-        this.onConnEvent(RaftConnEvent.CONN_CONNECTING);
+    // Store locator
+    this._channelConnLocator = locator;
 
-        // Connect
-        connOk = await this._connectToChannel();
-      } catch (err) {
-        RaftLog.error('RaftConnector.connect - error: ' + err);
-      }
+    // Connect
+    let connOk = false;
+    try {
+      // Event
+      this.onConnEvent(RaftConnEvent.CONN_CONNECTING);
 
-      // Check ok
-      if (connOk) {
+      // Connect
+      connOk = await this._connectToChannel();
+    } catch (err) {
+      RaftLog.error('RaftConnector.connect - error: ' + err);
+    }
 
+    if (connOk) {
+      // Get system type
+      if (this._getSystemTypeCB) {
         // Get system type
-        if (this._getSystemTypeCB) {
-          // Get system type
-          this._systemType = await this._getSystemTypeCB(this._raftSystemUtils);
+        this._systemType = await this._getSystemTypeCB(this._raftSystemUtils);
 
-          // Set defaults
-          if (this._systemType) {
-            this._raftSystemUtils.setDefaultWiFiHostname(this._systemType.defaultWiFiHostname);
-          }
-        }
-
-        // Setup system type
+        // Set defaults
         if (this._systemType) {
-          this._systemType.setup(this._raftSystemUtils, this._onEventFn);
-        }
-
-        // Check if subscription required
-        if (this._systemType &&
-          this._systemType.subscribeForUpdates &&
-          this._raftChannel.requiresSubscription()) {
-          try {
-            // Subscription
-            await this._systemType.subscribeForUpdates(this._raftSystemUtils, true);
-            RaftLog.info(`connect subscribed for updates`);
-          } catch (error: unknown) {
-            RaftLog.warn(`connect subscribe for updates failed ${error}`)
-          }
+          this._raftSystemUtils.setDefaultWiFiHostname(this._systemType.defaultWiFiHostname);
         }
+      }
 
-        // Send connected event
-        this.onConnEvent(RaftConnEvent.CONN_CONNECTED);
+      // Setup system type
+      if (this._systemType) {
+        this._systemType.setup(this._raftSystemUtils, this._onEventFn);
+      }
 
-      } else {
-        // Failed Event
-        this.onConnEvent(RaftConnEvent.CONN_CONNECTION_FAILED);
+      // Check if subscription required
+      if (this._systemType &&
+        this._systemType.subscribeForUpdates &&
+        this._raftChannel.requiresSubscription()) {
+        try {
+          // Subscription
+          await this._systemType.subscribeForUpdates(this._raftSystemUtils, true);
+          RaftLog.info(`connect subscribed for updates`);
+        } catch (error: unknown) {
+          RaftLog.warn(`connect subscribe for updates failed ${error}`)
+        }
       }
 
+      // Send connected event
+      this.onConnEvent(RaftConnEvent.CONN_CONNECTED);
+
+    } else {
+      // Failed Event
+      this.onConnEvent(RaftConnEvent.CONN_CONNECTION_FAILED);
       // configure file handler
       this.configureFileHandler(this._raftChannel.fhFileBlockSize(), this._raftChannel.fhBatchAckSize());
-    } else {
-      this._channelConnMethod = "";
     }
 
     return connOk;
@@ -565,7 +559,6 @@ export default class RaftConnector {
    * @returns void
    */
   onConnEvent(eventEnum: RaftConnEvent, data: object | string | null | undefined = undefined): void {
-
     // Handle information clearing on disconnect
     switch (eventEnum) {
       case RaftConnEvent.CONN_DISCONNECTED:
@@ -598,7 +591,6 @@ export default class RaftConnector {
         }
         break;
     }
-
     // Notify
     if (this._onEventFn) {
       this._onEventFn("conn", eventEnum, RaftConnEventNames[eventEnum], data);
@@ -741,5 +733,5 @@ export default class RaftConnector {
       firmwareBaseURL,
       this._raftChannel
     );
-  }  
+  }
 }

package/src/RaftDeviceInfo.ts

@@ -90,15 +90,9 @@ export interface DeviceTypeInfoRecs {
     [devType: string]: DeviceTypeInfo;
 }
 
-export interface DeviceTypeInfoTestJsonRec {
-    addresses?: string;
-    devInfoJson: DeviceTypeInfo;
-}
-
-export interface DeviceTypeInfoTestJsonElem {
-    [devType: string]: DeviceTypeInfoTestJsonRec;
-}
-
-export interface DeviceTypeInfoTestJsonFile {
-    devTypes: DeviceTypeInfoTestJsonElem;
-}
+export type RaftDevTypeInfoResponse = {
+    req: string;
+    rslt: string;
+    devinfo: DeviceTypeInfo;
+  };
+