@robotical/raftjs 1.4.7 → 2.0.4

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

@@ -8,77 +8,124 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+type FormatInstruction = 
+    | { kind: "endian"; littleEndian: boolean }
+    | { kind: "spec"; code: string; repeat: number };
+
+function parseFormatInstructions(format: string): FormatInstruction[] {
+    const instructions: FormatInstruction[] = [];
+    let idx = 0;
+
+    while (idx < format.length) {
+
+        const char = format[idx];
+
+        // Endianness specifiers
+        if (char === "<" || char === ">") {
+            instructions.push({ kind: "endian", littleEndian: char === "<" });
+            idx++;
+            continue;
+        }
+
+        // Ignore whitespace
+        if (/\s/.test(char)) {
+            idx++;
+            continue;
+        }
+
+        // Attribute code
+        const code = char;
+        idx++;
+
+        // Check for repeat count using [N] syntax
+        let repeat = 1;
+        if (idx < format.length && format[idx] === "[") {
+            const endIdx = format.indexOf("]", idx + 1);
+            if (endIdx === -1) {
+                throw new Error(`Invalid format string: missing closing ] in "${format}"`);
+            }
+            const repeatStr = format.slice(idx + 1, endIdx);
+            repeat = parseInt(repeatStr, 10);
+            if (!Number.isFinite(repeat) || repeat <= 0) {
+                throw new Error(`Invalid repeat count "${repeatStr}" in format string "${format}"`);
+            }
+            idx = endIdx + 1;
+        }
+
+        instructions.push({ kind: "spec", code, repeat });
+    }
+
+    return instructions;
+}
+
 export function structUnpack(format: string, data: Uint8Array): number[] {
     const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     const results: number[] = [];
     let offset = 0;
     let littleEndian = false;
 
-    for (const char of format) {
-        switch (char) {
-            case "<":
-                littleEndian = true;
-                break;
-            case ">":
-                littleEndian = false;
-                break;
-            case "x": // Padding byte
-                offset += 1;
-                break;
-            case "c": // Char
-                results.push(view.getUint8(offset));
-                offset += 1;
-                break;
-            case "b": // Signed 8-bit integer
-                results.push(view.getInt8(offset));
-                offset += 1;
-                break;
-            case "B": // Unsigned 8-bit integer
-                results.push(view.getUint8(offset));
-                offset += 1;
-                break;
-            case "h": // Signed 16-bit integer
-                results.push(view.getInt16(offset, littleEndian));
-                offset += 2;
-                break;
-            case "H": // Unsigned 16-bit integer (big-endian)
-                results.push(view.getUint16(offset, littleEndian));
-                offset += 2;
-                break;
-            case "i": // Signed 32-bit integer (big-endian)
-                results.push(view.getInt32(offset, littleEndian));
-                offset += 4;
-                break;
-            case "I": // Unsigned 32-bit integer (big-endian)
-                results.push(view.getUint32(offset, littleEndian));
-                offset += 4;
-                break;
-            case "l": // Signed 32-bit integer (big-endian)
-                results.push(view.getInt32(offset, littleEndian));
-                offset += 4;
-                break;
-            case "L": // Unsigned 32-bit integer (big-endian)
-                results.push(view.getUint32(offset, littleEndian));
-                offset += 4;
-                break;
-            // case "q": // Signed 64-bit integer (big-endian)
-            //     results.push(view.getBigInt64(offset, littleEndian));
-            //     offset += 8;
-            //     break;
-            // case "Q": // Unsigned 64-bit integer (big-endian)
-            //     results.push(view.getBigUint64(offset, littleEndian));
-            //     offset += 8;
-            //     break;
-            case "f": // 32-bit float (big-endian)
-                results.push(view.getFloat32(offset, littleEndian));
-                offset += 4;
-                break;
-            case "d": // 64-bit float (big-endian)
-                results.push(view.getFloat64(offset, littleEndian));
-                offset += 8;
-                break;
-            default:
-                throw new Error(`Unknown format character: ${char}`);
+    const instructions = parseFormatInstructions(format);
+
+    for (const instruction of instructions) {
+        if (instruction.kind === "endian") {
+            littleEndian = instruction.littleEndian;
+            continue;
+        }
+
+        const { code, repeat } = instruction;
+
+        for (let count = 0; count < repeat; count++) {
+            switch (code) {
+                case "x": // Padding byte
+                    offset += 1;
+                    break;
+                case "c": // Char
+                case "B": // Unsigned 8-bit integer
+                case "?": // Boolean (stored as uint8)
+                    results.push(view.getUint8(offset));
+                    offset += 1;
+                    break;
+                case "b": // Signed 8-bit integer
+                    results.push(view.getInt8(offset));
+                    offset += 1;
+                    break;
+                case "h": // Signed 16-bit integer
+                    results.push(view.getInt16(offset, littleEndian));
+                    offset += 2;
+                    break;
+                case "H": // Unsigned 16-bit integer
+                    results.push(view.getUint16(offset, littleEndian));
+                    offset += 2;
+                    break;
+                case "i": // Signed 32-bit integer
+                case "l": // Signed 32-bit integer
+                    results.push(view.getInt32(offset, littleEndian));
+                    offset += 4;
+                    break;
+                case "I": // Unsigned 32-bit integer
+                case "L": // Unsigned 32-bit integer
+                    results.push(view.getUint32(offset, littleEndian));
+                    offset += 4;
+                    break;
+                // case "q": // Signed 64-bit integer
+                //     results.push(Number(view.getBigInt64(offset, littleEndian)));
+                //     offset += 8;
+                //     break;
+                // case "Q": // Unsigned 64-bit integer
+                //     results.push(Number(view.getBigUint64(offset, littleEndian)));
+                //     offset += 8;
+                //     break;
+                case "f": // 32-bit float
+                    results.push(view.getFloat32(offset, littleEndian));
+                    offset += 4;
+                    break;
+                case "d": // 64-bit float
+                    results.push(view.getFloat64(offset, littleEndian));
+                    offset += 8;
+                    break;
+                default:
+                    throw new Error(`Unknown format character: ${code}`);
+            }
         }
     }
 
@@ -87,42 +134,49 @@ export function structUnpack(format: string, data: Uint8Array): number[] {
 
 export function structSizeOf(format: string): number {
     let size = 0;
-    for (const char of format) {
-        switch (char) {
-            case "<":
-            case ">":
-                break;
+    const instructions = parseFormatInstructions(format);
+
+    for (const instruction of instructions) {
+        if (instruction.kind === "endian") {
+            continue;
+        }
+
+        const { code, repeat } = instruction;
+        let unitSize: number;
+
+        switch (code) {
             case "x": // Padding byte
-                size += 1;
-                break;
             case "c": // Char
             case "b": // Signed 8-bit integer
             case "B": // Unsigned 8-bit integer
-                size += 1;
+            case "?": // Boolean (uint8)
+                unitSize = 1;
                 break;
             case "h": // Signed 16-bit integer
             case "H": // Unsigned 16-bit integer
-                size += 2;
+                unitSize = 2;
                 break;
             case "i": // Signed 32-bit integer
             case "I": // Unsigned 32-bit integer
             case "l": // Signed 32-bit integer
             case "L": // Unsigned 32-bit integer
-                size += 4;
+                unitSize = 4;
                 break;
             // case "q": // Signed 64-bit integer
             // case "Q": // Unsigned 64-bit integer
-            //     size += 8;
+            //     unitSize = 8;
             //     break;
             case "f": // 32-bit float
-                size += 4;
+                unitSize = 4;
                 break;
             case "d": // 64-bit float
-                size += 8;
+                unitSize = 8;
                 break;
             default:
-                throw new Error(`Unknown format character: ${char}`);
+                throw new Error(`Unknown format character: ${code}`);
         }
+
+        size += unitSize * repeat;
     }
     return size;
 }
@@ -134,74 +188,93 @@ export function structPack(format: string, values: number[]): Uint8Array {
     let offset = 0;
     let littleEndian = false;
 
-    let valIdx = 0;
-    for (let i = 0; i < format.length; i++) {
-        const char = format[i];
-        const value = values[valIdx];
-        switch (char) {
-            case "<":
-                littleEndian = true;
-                break;
-            case ">":
-                littleEndian = false;
-                break;
-            case "x": // Padding byte
-                offset += 1;
-                break;
-            case "c": // Char
-                view.setInt8(offset, value);
-                offset += 1;
-                break;
-            case "b": // Signed 8-bit integer
-                view.setInt8(offset, value);
-                offset += 1;
-                break;
-            case "B": // Unsigned 8-bit integer
-                view.setUint8(offset, value);
-                offset += 1;
-                break;
-            case "h": // Signed 16-bit integer
-                view.setInt16(offset, value, littleEndian);
-                offset += 2;
-                break;
-            case "H": // Unsigned 16-bit integer
-                view.setUint16(offset, value, littleEndian);
-                offset += 2;
-                break;
-            case "i": // Signed 32-bit integer
-                view.setInt32(offset, value, littleEndian);
-                offset += 4;
-                break;
-            case "I": // Unsigned 32-bit integer
-                view.setUint32(offset, value, littleEndian);
-                offset += 4;
-                break;
-            case "l": // Signed 32-bit integer
-                view.setInt32(offset, value, littleEndian);
-                offset += 4;
-                break;
-            case "L": // Unsigned 32-bit integer
-                view.setUint32(offset, value, littleEndian);
-                offset += 4;
-                break;
-            // case "q": // Signed 64-bit integer
-            //     view.setBigInt64(offset, BigInt(value), littleEndian);
-            //     offset += 8;
-            //     break;
-            // case "Q": // Unsigned 64-bit integer
-            //     view.setBigUint64(offset, BigInt(value), littleEndian);
-            //     offset += 8;
-            //     break;
-            case "f": // 32-bit float
-                view.setFloat32(offset, value, littleEndian);
-                offset += 4;
-                break;
-            case "d": // 64-bit float
-                view.setFloat64(offset, value, littleEndian);
-                offset += 8;
-                break;
-            default:
-                throw new Error(`Unknown format character: ${char}`);
+    const instructions = parseFormatInstructions(format);
+    let valueIdx = 0;
+
+    for (const instruction of instructions) {
+        if (instruction.kind === "endian") {
+            littleEndian = instruction.littleEndian;
+            continue;
+        }
+
+        const { code, repeat } = instruction;
+
+        for (let count = 0; count < repeat; count++) {
+            switch (code) {
+                case "x": // Padding byte
+                    offset += 1;
+                    break;
+                case "c": // Char
+                case "b": // Signed 8-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setInt8(offset, values[valueIdx++]);
+                    offset += 1;
+                    break;
+                case "B": // Unsigned 8-bit integer
+                case "?": // Boolean (uint8)
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setUint8(offset, values[valueIdx++]);
+                    offset += 1;
+                    break;
+                case "h": // Signed 16-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setInt16(offset, values[valueIdx++], littleEndian);
+                    offset += 2;
+                    break;
+                case "H": // Unsigned 16-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setUint16(offset, values[valueIdx++], littleEndian);
+                    offset += 2;
+                    break;
+                case "i": // Signed 32-bit integer
+                case "l": // Signed 32-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setInt32(offset, values[valueIdx++], littleEndian);
+                    offset += 4;
+                    break;
+                case "I": // Unsigned 32-bit integer
+                case "L": // Unsigned 32-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setUint32(offset, values[valueIdx++], littleEndian);
+                    offset += 4;
+                    break;
+                // case "q": // Signed 64-bit integer
+                //     view.setBigInt64(offset, BigInt(values[valueIdx++]), littleEndian);
+                //     offset += 8;
+                //     break;
+                // case "Q": // Unsigned 64-bit integer
+                //     view.setBigUint64(offset, BigInt(values[valueIdx++]), littleEndian);
+                //     offset += 8;
+                //     break;
+                case "f": // 32-bit float
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setFloat32(offset, values[valueIdx++], littleEndian);
+                    offset += 4;
+                    break;
+                case "d": // 64-bit float
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setFloat64(offset, values[valueIdx++], littleEndian);
+                    offset += 8;
+                    break;
+                default:
+                    throw new Error(`Unknown format character: ${code}`);
+            }
         }
     }
 

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;
+  }
 }