@robotical/raftjs 1.4.6 → 2.0.3

package/src/RaftMsgHandler.ts

@@ -60,6 +60,8 @@ export interface RaftMessageSender {
     msg: Uint8Array,
     sendWithResponse: boolean,
   ): Promise<boolean>;
+  sendTxMsgRaw(msg: string): boolean;
+  sendTxMsgRawAndWaitForReply<T>(msgPayload: Uint8Array): T;
 }
 
 export default class RaftMsgHandler {
@@ -87,6 +89,9 @@ export default class RaftMsgHandler {
   // RaftMiniHDLC - handles part of RICSerial protocol
   private _miniHDLC: RaftMiniHDLC;
 
+  // Raw message mode
+  private _rawMsgMode = false;
+
   // Constructor
   constructor(commsStats: RaftCommsStats) {
     this._commsStats = commsStats;
@@ -120,6 +125,22 @@ export default class RaftMsgHandler {
     // RaftLog.verbose(`handleNewRxMsg len ${rxMsg.length} ${RaftUtils.bufferToHex(rxMsg)}`)
   }
 
+  // This is currently only for testing and simulated channels
+  handleNewRxMsgRaw(rxMsg: Uint8Array, rxMsgType: RaftCommsMsgTypeCode, rxMsgNum: number, rxMsgTimeMs: number): void {
+    // Check message types
+    if (rxMsgType == RaftCommsMsgTypeCode.MSG_TYPE_RESPONSE) {
+      // Convert raw Uint8Array to string assuming UTF-8
+      const restStr = new TextDecoder('utf-8').decode(rxMsg);
+      this._handleResponseMessages(restStr, rxMsgNum);
+    } else if (rxMsgType == RaftCommsMsgTypeCode.MSG_TYPE_REPORT) {
+      // Convert raw Uint8Array to string assuming UTF-8
+      const restStr = new TextDecoder('utf-8').decode(rxMsg);
+      this._handleReportMessages(restStr);
+    } else {
+      this._msgResultHandler?.onRxOtherMsgType(rxMsg, rxMsgTimeMs);
+    }
+  }
+
   reportMsgCallbacksSet(callbackName: string, callback: (report: RaftReportMsg) => Promise<void>): void {
     this._reportMsgCallbacks.set(callbackName, callback);
   }
@@ -128,6 +149,11 @@ export default class RaftMsgHandler {
     this._reportMsgCallbacks.delete(callbackName);
   }
 
+  setRawMsgMode(isRawMode: boolean): void {
+    this._rawMsgMode = isRawMode;
+    RaftLog.debug(`setRawMsgMode ${isRawMode}`);
+  }
+
   _onHDLCFrameDecode(rxMsg: Uint8Array, frameTimeMs: number): void {
     // Add to stats
     this._commsStats.msgRx();
@@ -336,6 +362,11 @@ export default class RaftMsgHandler {
       return false;
     }
 
+    // Check for raw message mode (used for testing and simulated channels)
+    if (this._rawMsgMode) {
+      return this._msgSender.sendTxMsgRaw(cmdStr);
+    }
+
     // Put cmdStr into buffer
     const cmdBytes = new Uint8Array(cmdStr.length + 1);
     RaftUtils.addStringToBuffer(cmdBytes, cmdStr, 0);
@@ -406,6 +437,11 @@ export default class RaftMsgHandler {
       throw new Error('sendMsgAndWaitForReply failed no sender');
     }
 
+    // Check for raw message mode (used for testing and simulated channels)
+    if (this._rawMsgMode) {
+      return this._msgSender.sendTxMsgRawAndWaitForReply(msgPayload);
+    }
+
     // Frame the message
     let framedMsg = this.frameCommsMsg(msgPayload, msgDirection, msgProtocol, true);
 

package/src/RaftStreamHandler.ts

@@ -15,6 +15,7 @@ import { RaftOKFail, RaftStreamStartResp, RaftStreamType } from './RaftTypes';
 import RaftConnector from './RaftConnector';
 import { RaftConnEvent } from './RaftConnEvents';
 import { RICRESTElemCode } from './RaftProtocolDefs'
+import RaftUtils from './RaftUtils';
 
 export default class RaftStreamHandler {
 
@@ -49,7 +50,7 @@ export default class RaftStreamHandler {
 
   private _isStreaming = false;
   private _isPaused = false;
-  private _streamBuffer = new Uint8Array();
+  private _streamBuffer: Uint8Array<ArrayBuffer> = new Uint8Array();
   private _audioDuration = 0;
   private _audioByteRate = 0;
   private _streamPos = 0;
@@ -67,11 +68,11 @@ export default class RaftStreamHandler {
     this.onSoktoMsg = this.onSoktoMsg.bind(this);
   }
 
-  setNumBlocksWithoutPause(numBlocks: number){
+  setNumBlocksWithoutPause(numBlocks: number) {
     this._numBlocksWithoutPause = numBlocks;
   }
 
-  setLegacySoktoMode(legacyMode: boolean){
+  setLegacySoktoMode(legacyMode: boolean) {
     RaftLog.debug(`Setting legacy sokto mode to ${legacyMode}`);
     this._legacySoktoMode = legacyMode;
   }
@@ -83,7 +84,7 @@ export default class RaftStreamHandler {
 
     // TODO - if clearExisting is not set, form a queue
     if (this._streamIsStarting || this._lastStreamStartTime > (Date.now() - 500)) {
-      RaftLog.error(`Unable to start sound, too soon since last request`);
+      RaftLog.warn(`Unable to start sound, too soon since last request`);
       return;
     }
 
@@ -94,9 +95,9 @@ export default class RaftStreamHandler {
     this._soktoReceived = false;
     this._soktoPos = 0;
     this._streamPos = 0;
-    this._streamBuffer = streamContents;
+    this._streamBuffer = RaftUtils.toArrayBufferView(streamContents);
     this._audioDuration = audioDuration;
-    this._audioByteRate = (streamContents.length / audioDuration)*1000;
+    this._audioByteRate = (streamContents.length / audioDuration) * 1000;
 
     this.clearFinishPointTimeout();
 
@@ -104,12 +105,12 @@ export default class RaftStreamHandler {
       (result: boolean) => {
         this._isPaused = false;
         this._streamIsStarting = false;
-        if (!result){
-          RaftLog.error(`Unable to start stream. ufStart message send failed`);
+        if (!result) {
+          RaftLog.warn(`Unable to start stream. ufStart message send failed`);
           return;
         }
         //this.streamingPerformanceChecker();
-        if (!this._isStreaming){
+        if (!this._isStreaming) {
           this._isStreaming = true;
           this._sendStreamBuffer();
         }
@@ -127,7 +128,7 @@ export default class RaftStreamHandler {
     return this._streamIsStarting;
   }
 
- 
+
   clearFinishPointTimeout() {
     if (this.soundFinishPoint) {
       clearTimeout(this.soundFinishPoint);
@@ -172,7 +173,7 @@ export default class RaftStreamHandler {
         RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
       );
     } catch (err) {
-      RaftLog.error(`sendStreamStartMsg error ${err}`);
+      RaftLog.warn(`sendStreamStartMsg error ${err}`);
       return false;
     }
 
@@ -191,11 +192,11 @@ export default class RaftStreamHandler {
     return true;
   }
 
-  get maxBlockSize () {
+  get maxBlockSize() {
     return this._maxBlockSize;
   }
 
-  set maxBlockSize (maxBlockSize: number) {
+  set maxBlockSize(maxBlockSize: number) {
     this._maxBlockSize = maxBlockSize;
     this.DEFAULT_MAX_BLOCK_SIZE = maxBlockSize;
   }
@@ -220,43 +221,43 @@ export default class RaftStreamHandler {
         RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
       );
     } catch (err) {
-      RaftLog.error(`sendStreamEndMsg error ${err}`);
+      RaftLog.warn(`sendStreamEndMsg error ${err}`);
       return false;
     }
     return streamEndResp.rslt === 'ok';
   }
 
-/*
-  private async _sendAudioStopMsg(): Promise<RaftOKFail> {
-    const cmdMsg = `{"cmdName":"audio/stop"}`;
-
-    // Debug
-    RaftLog.debug(`sendAudioStopMsg ${cmdMsg}`);
-
-    // Send
-    return this._msgHandler.sendRICREST<RaftOKFail>(
-      cmdMsg,
-      RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
-    );
-  }
-
-
-  private async _sendStreamCancelMsg(): Promise<RaftOKFail> {
-    // File cancel command message
-    const cmdMsg = `{"cmdName":"ufCancel","reqStr":"ufCancel","streamID":${this._streamID}}`;
-
-    // Debug
-    RaftLog.debug(`sendStreamCancelMsg ${cmdMsg}`);
-
-    // Send
-    return this._msgHandler.sendRICREST<RaftOKFail>(
-      cmdMsg,
-      RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
-    );
-  }
-*/
+  /*
+    private async _sendAudioStopMsg(): Promise<RaftOKFail> {
+      const cmdMsg = `{"cmdName":"audio/stop"}`;
+  
+      // Debug
+      RaftLog.debug(`sendAudioStopMsg ${cmdMsg}`);
+  
+      // Send
+      return this._msgHandler.sendRICREST<RaftOKFail>(
+        cmdMsg,
+        RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
+      );
+    }
+  
+  
+    private async _sendStreamCancelMsg(): Promise<RaftOKFail> {
+      // File cancel command message
+      const cmdMsg = `{"cmdName":"ufCancel","reqStr":"ufCancel","streamID":${this._streamID}}`;
+  
+      // Debug
+      RaftLog.debug(`sendStreamCancelMsg ${cmdMsg}`);
+  
+      // Send
+      return this._msgHandler.sendRICREST<RaftOKFail>(
+        cmdMsg,
+        RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
+      );
+    }
+  */
 
-private async _sendStreamBuffer(): Promise<boolean> {
+  private async _sendStreamBuffer(): Promise<boolean> {
     const streamStartTime = Date.now();
 
     // Check streamID is valid
@@ -267,7 +268,7 @@ private async _sendStreamBuffer(): Promise<boolean> {
     let blockNum = 0;
     // Send stream blocks
     while (this._soktoPos < this._streamBuffer.length || this._isPaused) {
-      if (this._isPaused){
+      if (this._isPaused) {
         await new Promise((resolve) => setTimeout(resolve, 5));
         continue;
       }
@@ -301,8 +302,8 @@ private async _sendStreamBuffer(): Promise<boolean> {
         this._streamPos += blockSize;
         blockNum += 1;
 
-        if (this._audioByteRate && blockNum > this._numBlocksWithoutPause){
-          const pauseTime = ((blockSize / this._audioByteRate)*1000) - 10;
+        if (this._audioByteRate && blockNum > this._numBlocksWithoutPause) {
+          const pauseTime = ((blockSize / this._audioByteRate) * 1000) - 10;
           RaftLog.verbose(`Pausing for ${pauseTime} ms between audio packets. Bit rate ${this._audioByteRate * 8}`)
           await new Promise((resolve) => setTimeout(resolve, pauseTime));
         }

package/src/RaftStruct.ts

@@ -134,7 +134,7 @@ export function structPack(format: string, values: number[]): Uint8Array {
     let offset = 0;
     let littleEndian = false;
 
-    let valIdx = 0;
+    const valIdx = 0;
     for (let i = 0; i < format.length; i++) {
         const char = format[i];
         const value = values[valIdx];

package/src/RaftSysTypeManager.ts

@@ -53,8 +53,35 @@ export default class RaftSysTypeManager {
     const serviceUUIDs = new Set<string>();
     this._sysTypes.forEach((factory) => {
       const sysType = factory();
+      if (!sysType.BLEServiceUUIDs) {
+        return;
+      }
       sysType.BLEServiceUUIDs.forEach((uuid) => serviceUUIDs.add(uuid));
     });
     return Array.from(serviceUUIDs);
   }
+
+  // Get a list of all device name prefixes to filter on
+  getAllNamePrefixes(): string[] {
+    const deviceNames = new Set<string>();
+    this._sysTypes.forEach((factory) => {
+      const sysType = factory();
+      if (!sysType.BLEDeviceNames) {
+        return;
+      }
+      sysType.BLEDeviceNames.forEach((name) => deviceNames.add(name));
+    });
+    return Array.from(deviceNames);
+  }
+
+  // Find the system type for a given BLE device name prefix
+  getSystemTypeByBLENamePrefix(name: string): RaftSystemType | null {
+    for (const factory of this._sysTypes.values()) {
+      const sysType = factory();
+      if (sysType.BLEDeviceNames && sysType.BLEDeviceNames.some((prefix) => name.startsWith(prefix))) {
+        return sysType;
+      }
+    }
+    return null;
+  }
 }

package/src/RaftSystemType.ts

@@ -15,18 +15,20 @@ export interface ConnectorOptions {
 
 export interface RaftSystemType {
   nameForDialogs: string;
-  defaultWiFiHostname: string;
-  BLEServiceUUIDs: string[];
-  BLECmdUUID: string;
-  BLERespUUID: string;
-  firmwareDestName: string;
-  normalFileDestName: string;
+  defaultWiFiHostname?: string;
+  BLEServiceUUIDs?: string[];
+  BLECmdUUID?: string;
+  BLERespUUID?: string;
+  BLEDeviceNames?: string[];
+  firmwareDestName?: string;
+  normalFileDestName?: string;
   connectorOptions: ConnectorOptions;
   setup: (systemUtils: RaftSystemUtils, onEvent: RaftEventFn | null) => void;
   subscribeForUpdates: RaftSubscribeForUpdatesCBType | null;
   stateIsInvalid: RaftStateIsInvalidCBType | null;
   rxOtherMsgType: RaftRxOtherMsgType | null;
-  deviceMgrIF: RaftDeviceMgrIF;
+  deviceMgrIF?: RaftDeviceMgrIF;
+  nonRaftTypeCode?: string;
 }
 
 export type RaftGetSystemTypeCBType = (systemUtils: RaftSystemUtils) => Promise<RaftSystemType | null>;

package/src/RaftSystemUtils.ts

@@ -61,7 +61,9 @@ export default class RaftSystemUtils {
    * @param defaultWiFiHostname
    */
   setDefaultWiFiHostname(defaultWiFiHostname: string) {
-    this._defaultWiFiHostname = defaultWiFiHostname;
+    if (defaultWiFiHostname) {
+      this._defaultWiFiHostname = defaultWiFiHostname;
+    }
   }
   
   /**

package/src/RaftUpdateManager.ts

@@ -762,9 +762,9 @@ export default class RICUpdateManager {
   ): Promise<boolean> {
 
     // Get the destination
-    let fileDest = this._systemType ? this._systemType.normalFileDestName : "fs";
+    let fileDest = this._systemType && this._systemType.normalFileDestName ? this._systemType.normalFileDestName : "fs";
     if (fileType === RaftFileSendType.FIRMWARE_UPDATE) {
-      fileDest = this._systemType ? this._systemType.firmwareDestName : "fw";
+      fileDest = this._systemType && this._systemType.firmwareDestName ? this._systemType.firmwareDestName : "fw";
     }
     return await this._raftFileHandler.fileSend(
       fileName,

package/src/RaftUtils.ts

@@ -29,7 +29,7 @@ export default class RaftUtils {
   ): void {
     // Check valid
     if (buffer.length < startPos + strToAdd.length + 1) {
-      RaftLog.error("addStringToBuffer buffer too short");
+      RaftLog.warn("addStringToBuffer buffer too short");
       return;
     }
     let curPos = startPos;
@@ -471,7 +471,7 @@ export default class RaftUtils {
       return v1 === v2;
     } catch (e) {
       // one of the two versions is invalid, return false
-      RaftLog.error(`isVersionEqual - invalid version ${v1} or ${v2} ${e}`);
+      RaftLog.warn(`isVersionEqual - invalid version ${v1} or ${v2} ${e}`);
       return false;
     }
   }
@@ -481,14 +481,34 @@ export default class RaftUtils {
     const timeout = new Promise((_, reject) => {
       id = setTimeout(() => {
         clearTimeout(id);
-        reject('Timed out in '+ ms + 'ms.')
+        reject('Timed out in ' + ms + 'ms.')
       }, ms)
     })
-  
+
     return Promise.race([
       promise,
       timeout
     ])
   }
-  
+
+  static toBufferSource(u8: Uint8Array<ArrayBufferLike>): BufferSource {
+    if (u8.buffer instanceof ArrayBuffer) {
+      // Respect byteOffset/byteLength
+      return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
+    }
+    // e.g., SharedArrayBuffer -> copy into a real ArrayBuffer
+    const ab = new ArrayBuffer(u8.byteLength);
+    new Uint8Array(ab).set(u8);
+    return ab;
+  }
+  static toArrayBufferView(u8: Uint8Array<ArrayBufferLike>): Uint8Array<ArrayBuffer> {
+    if (u8.buffer instanceof ArrayBuffer) {
+      // keep the same bytes/offset/length, but the return type is now locked to ArrayBuffer
+      return new Uint8Array(u8.buffer, u8.byteOffset, u8.byteLength);
+    }
+    // e.g., SharedArrayBuffer → copy into a real ArrayBuffer
+    const ab = new ArrayBuffer(u8.byteLength);
+    new Uint8Array(ab).set(u8);
+    return new Uint8Array(ab);
+  }
 }

package/src/main.ts

@@ -16,6 +16,7 @@ export { default as RaftCommsStats } from './RaftCommsStats';
 export { default as RaftConnector } from './RaftConnector';
 export { default as RaftChannel } from './RaftChannel';
 export { default as RaftChannelWebSocket } from './RaftChannelWebSocket';
+export { default as RaftChannelSimulated } from './RaftChannelSimulated';
 export { default as RaftFileHandler } from './RaftFileHandler';
 export { default as RaftLog } from './RaftLog';
 export { default as RaftMiniHDLC } from './RaftMiniHDLC';
@@ -34,3 +35,4 @@ export * from './RaftConnEvents';
 export * from './RaftUpdateEvents';
 export * from "./RaftProtocolDefs";
 export * from "./RaftDeviceStates";
+export * from "./RaftDeviceInfo";