@robdobsn/raftjs 1.7.1 → 1.7.3

package/src/RaftMsgTrackInfo.ts

@@ -1,51 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// RaftMsgTrackInfo
-// Part of RaftJS
-//
-// Rob Dobson & Chris Greening 2020-2024
-// (C) 2020-2024 All rights reserved
-//
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-export class RaftMsgTrackInfo {
-  static readonly MAX_MSG_NUM = 255;
-  static readonly MSG_RESPONSE_TIMEOUT_MS = 2000;
-  static readonly MSG_RETRY_COUNT = 5;
-  msgOutstanding = false;
-  msgFrame: Uint8Array = new Uint8Array();
-  msgSentMs = 0;
-  retryCount = 0;
-  withResponse = false;
-  bridgeID: number | undefined = undefined;
-  msgHandle = 0;
-  msgTimeoutMs: number | undefined = undefined;
-  resolve: unknown;
-  reject: unknown;
-
-  constructor() {
-    this.msgOutstanding = false;
-  }
-
-  set(
-    msgOutstanding: boolean,
-    msgFrame: Uint8Array,
-    withResponse: boolean,
-    bridgeID: number | undefined = undefined,
-    msgHandle: number,
-    msgTimeoutMs: number | undefined,
-    resolve: unknown,
-    reject: unknown,
-  ) {
-    this.msgOutstanding = msgOutstanding;
-    this.msgFrame = msgFrame;
-    this.retryCount = 0;
-    this.msgSentMs = Date.now();
-    this.withResponse = withResponse;
-    this.bridgeID = bridgeID;
-    this.msgHandle = msgHandle;
-    this.msgTimeoutMs = msgTimeoutMs;
-    this.resolve = resolve;
-    this.reject = reject;
-  }
-}

package/src/RaftProtocolDefs.ts

@@ -1,46 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// Raft Protocol Definitions
-// Part of RaftJS
-//
-// Rob Dobson & Chris Greening 2020-2024
-// (C) 2020-2024 All rights reserved
-//
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-// RIC Protocols
-export const RICSERIAL_MSG_NUM_POS = 0;
-export const RICSERIAL_PROTOCOL_POS = 1;
-export const RICSERIAL_PAYLOAD_POS = 2;
-export const RICREST_REST_ELEM_CODE_POS = 0;
-export const RICREST_HEADER_PAYLOAD_POS = 1;
-export const RICREST_FILEBLOCK_CHANNEL_POS = 0;
-export const RICREST_FILEBLOCK_FILEPOS_POS = 0;
-export const RICREST_FILEBLOCK_FILEPOS_POS_BYTES = 4;
-export const RICREST_FILEBLOCK_PAYLOAD_POS = 4;
-export const RICREST_BRIDGE_ID_POS = 2;
-export const RICREST_BRIDGE_PAYLOAD_POS = 3;
-
-// Protocol enums
-export enum RICRESTElemCode {
-  RICREST_ELEM_CODE_URL,
-  RICREST_ELEM_CODE_CMDRESPJSON,
-  RICREST_ELEM_CODE_BODY,
-  RICREST_ELEM_CODE_COMMAND_FRAME,
-  RICREST_ELEM_CODE_FILEBLOCK,
-}
-
-export enum RaftCommsMsgTypeCode {
-  MSG_TYPE_COMMAND,
-  MSG_TYPE_RESPONSE,
-  MSG_TYPE_PUBLISH,
-  MSG_TYPE_REPORT,
-}
-
-export enum RaftCommsMsgProtocol {
-  MSG_PROTOCOL_ROSSERIAL = 0,
-  MSG_PROTOCOL_RESERVED_1 = 1,
-  MSG_PROTOCOL_RICREST = 2,
-  MSG_PROTOCOL_BRIDGE_RICREST = 3,
-}
-

package/src/RaftStreamHandler.ts

@@ -1,328 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// RafStreamHandler
-// Part of RaftJS
-//
-// Rob Dobson & Chris Greening 2020-2024
-// (C) 2020-2024 All rights reserved
-//
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-import RaftLog from './RaftLog'
-import RaftMsgHandler from './RaftMsgHandler';
-import RaftCommsStats from './RaftCommsStats';
-import { RaftOKFail, RaftStreamStartResp, RaftStreamType } from './RaftTypes';
-import RaftConnector from './RaftConnector';
-import { RaftConnEvent } from './RaftConnEvents';
-import { RICRESTElemCode } from './RaftProtocolDefs'
-
-export default class RaftStreamHandler {
-
-  // Queue of audio stream requests
-  /*
-  private _streamAudioQueue: {
-    streamContents: Uint8Array;
-    audioDuration: number;
-  }[] = [];
-  */
-
-  // Stream state
-  private _streamID: number | null = null;
-  DEFAULT_MAX_BLOCK_SIZE = 475;
-  private _maxBlockSize: number = this.DEFAULT_MAX_BLOCK_SIZE;
-
-  // Handler of messages
-  private _msgHandler: RaftMsgHandler;
-
-  // RaftCommsStats
-  private _commsStats: RaftCommsStats;
-
-  // RaftConnector 
-  private _raftConnector: RaftConnector;
-
-  // Flow control
-  private _soktoReceived = false;
-  private _soktoPos = 0;
-
-  private _streamIsStarting = false;
-  private _lastStreamStartTime = 0;
-
-  private _isStreaming = false;
-  private _isPaused = false;
-  private _streamBuffer = new Uint8Array();
-  private _audioDuration = 0;
-  private _audioByteRate = 0;
-  private _streamPos = 0;
-  private _numBlocksWithoutPause = 15;
-  private _legacySoktoMode = false;
-
-
-  // soundFinishPoint timer
-  private soundFinishPoint: NodeJS.Timeout | null = null;
-
-  constructor(msgHandler: RaftMsgHandler, commsStats: RaftCommsStats, raftConnector: RaftConnector) {
-    this._raftConnector = raftConnector;
-    this._msgHandler = msgHandler;
-    this._commsStats = commsStats;
-    this.onSoktoMsg = this.onSoktoMsg.bind(this);
-  }
-
-  setNumBlocksWithoutPause(numBlocks: number){
-    this._numBlocksWithoutPause = numBlocks;
-  }
-
-  setLegacySoktoMode(legacyMode: boolean){
-    RaftLog.debug(`Setting legacy sokto mode to ${legacyMode}`);
-    this._legacySoktoMode = legacyMode;
-  }
-
-  // Start streaming audio
-  streamAudio(streamContents: Uint8Array, clearExisting: boolean, audioDuration: number): void {
-    if (!clearExisting)
-      RaftLog.debug(`only clearExisting = true is supported right now.`);
-
-    // 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`);
-      return;
-    }
-
-    this._isPaused = true;
-    this._streamIsStarting = true;
-    this._lastStreamStartTime = Date.now();
-
-    this._soktoReceived = false;
-    this._soktoPos = 0;
-    this._streamPos = 0;
-    this._streamBuffer = streamContents;
-    this._audioDuration = audioDuration;
-    this._audioByteRate = (streamContents.length / audioDuration)*1000;
-
-    this.clearFinishPointTimeout();
-
-    this._sendStreamStartMsg("audio.mp3", "streamaudio", RaftStreamType.REAL_TIME_STREAM, streamContents).then(
-      (result: boolean) => {
-        this._isPaused = false;
-        this._streamIsStarting = false;
-        if (!result){
-          RaftLog.error(`Unable to start stream. ufStart message send failed`);
-          return;
-        }
-        //this.streamingPerformanceChecker();
-        if (!this._isStreaming){
-          this._isStreaming = true;
-          this._sendStreamBuffer();
-        }
-
-      }
-    );
-  }
-
-  async streamCancel(): Promise<void> {
-    this._streamBuffer = new Uint8Array();
-    this.clearFinishPointTimeout();
-  }
-
-  public isStreamStarting() {
-    return this._streamIsStarting;
-  }
-
- 
-  clearFinishPointTimeout() {
-    if (this.soundFinishPoint) {
-      clearTimeout(this.soundFinishPoint);
-      this.soundFinishPoint = null;
-    }
-  }
-
-  streamingPerformanceChecker() {
-    if (this._audioDuration) {
-      this.clearFinishPointTimeout();
-      this.soundFinishPoint = setTimeout(() => {
-        // if the streaming hasn't finished before the end of the audio
-        // we can assume we are having streaming issues
-
-        // publish event in case we are having issues
-        this._raftConnector.onConnEvent(RaftConnEvent.CONN_STREAMING_ISSUE);
-
-        this.clearFinishPointTimeout();
-      }, this._audioDuration + 500);
-    }
-  }
-
-  // Send the start message
-  private async _sendStreamStartMsg(
-    streamName: string,
-    targetEndpoint: string,
-    streamTypeEnum: RaftStreamType,
-    streamContents: Uint8Array,
-  ): Promise<boolean> {
-    // Stream start command message
-    const streamType = 'rtstream';
-    const cmdMsg = `{"cmdName":"ufStart","reqStr":"ufStart","fileType":"${streamType}","fileName":"${streamName}","endpoint":"${targetEndpoint}","fileLen":${streamContents.length}}`;
-
-    // Debug
-    RaftLog.debug(`sendStreamStartMsg ${cmdMsg}`);
-
-    // Send
-    let streamStartResp = null;
-    try {
-      streamStartResp = await this._msgHandler.sendRICREST<RaftStreamStartResp>(
-        cmdMsg,
-        RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
-      );
-    } catch (err) {
-      RaftLog.error(`sendStreamStartMsg error ${err}`);
-      return false;
-    }
-
-    // Extract params
-    if (streamStartResp && (streamStartResp.rslt === 'ok')) {
-      this._streamID = streamStartResp.streamID;
-      this._maxBlockSize = streamStartResp.maxBlockSize || this.DEFAULT_MAX_BLOCK_SIZE;
-      this.streamingPerformanceChecker();
-      RaftLog.verbose(
-        `sendStreamStartMsg streamID ${this._streamID} maxBlockSize ${this._maxBlockSize} streamType ${streamTypeEnum}`,
-      );
-    } else {
-      RaftLog.warn(`sendStreamStartMsg failed ${streamStartResp ? streamStartResp.rslt : 'no response'}`);
-      return false;
-    }
-    return true;
-  }
-
-  get maxBlockSize () {
-    return this._maxBlockSize;
-  }
-
-  set maxBlockSize (maxBlockSize: number) {
-    this._maxBlockSize = maxBlockSize;
-    this.DEFAULT_MAX_BLOCK_SIZE = maxBlockSize;
-  }
-
-  private async _sendStreamEndMsg(
-    streamID: number | null,
-  ): Promise<boolean> {
-    if (streamID === null) {
-      return false;
-    }
-    // Stram end command message
-    const cmdMsg = `{"cmdName":"ufEnd","reqStr":"ufEnd","streamID":${streamID}}`;
-
-    // Debug
-    RaftLog.debug(`sendStreamEndMsg ${cmdMsg}`);
-
-    // Send
-    let streamEndResp = null;
-    try {
-      streamEndResp = await this._msgHandler.sendRICREST<RaftOKFail>(
-        cmdMsg,
-        RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
-      );
-    } catch (err) {
-      RaftLog.error(`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 _sendStreamBuffer(): Promise<boolean> {
-    const streamStartTime = Date.now();
-
-    // Check streamID is valid
-    if (this._streamID === null) {
-      return false;
-    }
-
-    let blockNum = 0;
-    // Send stream blocks
-    while (this._soktoPos < this._streamBuffer.length || this._isPaused) {
-      if (this._isPaused){
-        await new Promise((resolve) => setTimeout(resolve, 5));
-        continue;
-      }
-
-      // Check for new sokto
-      if (this._soktoReceived) {
-        if (this._legacySoktoMode)
-          this._streamPos = this._soktoPos;
-        // apart from when in legacy mode, the sokto message is now informational only, 
-        // to allow the central to slow down sending of data if it is swamping the peripheral
-        RaftLog.verbose(`sendStreamContents ${Date.now() - streamStartTime}ms soktoReceived for ${this._streamPos}`);
-        this._soktoReceived = false;
-
-        // receiving an sokto message before the completion of the stream means that the streaming is not keeping up
-        this._raftConnector.onConnEvent(RaftConnEvent.CONN_STREAMING_ISSUE);
-      }
-
-      // Send stream block
-      const blockSize = Math.min(this._streamBuffer.length - this._streamPos, this._maxBlockSize);
-      const block = this._streamBuffer.slice(this._streamPos, this._streamPos + blockSize);
-      if (block.length > 0) {
-        const sentOk = await this._msgHandler.sendStreamBlock(block, this._streamPos, this._streamID);
-        this._commsStats.recordStreamBytes(block.length);
-
-        RaftLog.verbose(
-          `sendStreamContents ${sentOk ? "OK" : "FAILED"} ${Date.now() - streamStartTime}ms pos ${this._streamPos} ${blockSize} ${block.length} ${this._soktoPos}`,
-        );
-        if (!sentOk) {
-          return false;
-        }
-        this._streamPos += blockSize;
-        blockNum += 1;
-
-        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));
-        }
-      }
-
-      // Wait to ensure we don't hog the CPU
-      await new Promise((resolve) => setTimeout(resolve, 1));
-    }
-
-    this._isStreaming = false;
-    this.clearFinishPointTimeout();
-    await this._sendStreamEndMsg(this._streamID);
-
-    return true;
-  }
-
-  onSoktoMsg(soktoPos: number) {
-    // Get how far we've progressed in file
-    this._soktoPos = soktoPos;
-    this._soktoReceived = true;
-    RaftLog.debug(`onSoktoMsg received file up to ${this._soktoPos}`);
-  }
-}

package/src/RaftStruct.ts

@@ -1,209 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// RaftStruct
-// Part of RaftJS
-//
-// Rob Dobson 2024
-// (C) 2024 All rights reserved
-//
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-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}`);
-        }
-    }
-
-    return results;
-}
-
-export function structSizeOf(format: string): number {
-    let size = 0;
-    for (const char of format) {
-        switch (char) {
-            case "<":
-            case ">":
-                break;
-            case "x": // Padding byte
-                size += 1;
-                break;
-            case "c": // Char
-            case "b": // Signed 8-bit integer
-            case "B": // Unsigned 8-bit integer
-                size += 1;
-                break;
-            case "h": // Signed 16-bit integer
-            case "H": // Unsigned 16-bit integer
-                size += 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;
-                break;
-            // case "q": // Signed 64-bit integer
-            // case "Q": // Unsigned 64-bit integer
-            //     size += 8;
-            //     break;
-            case "f": // 32-bit float
-                size += 4;
-                break;
-            case "d": // 64-bit float
-                size += 8;
-                break;
-            default:
-                throw new Error(`Unknown format character: ${char}`);
-        }
-    }
-    return size;
-}
-
-export function structPack(format: string, values: number[]): Uint8Array {
-    const size = structSizeOf(format);
-    const buffer = new ArrayBuffer(size);
-    const view = new DataView(buffer);
-    let offset = 0;
-    let littleEndian = false;
-
-    const 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}`);
-        }
-    }
-
-    return new Uint8Array(buffer);
-}

package/src/RaftSysTypeManager.ts

@@ -1,60 +0,0 @@
-import { RaftSystemType } from "./RaftSystemType";
-
-type RaftSystemTypeCreator = () => RaftSystemType;
-
-export default class RaftSysTypeManager {
-  // Singleton instance
-  private static _instance: RaftSysTypeManager;
-
-  // System type map
-  private _sysTypes: Map<string, RaftSystemTypeCreator> = new Map();
-  private _defaultSysTypeFactory: RaftSystemTypeCreator | null = null;
-
-  // Get instance (Singleton)
-  public static getInstance(): RaftSysTypeManager {
-    if (!RaftSysTypeManager._instance) {
-      RaftSysTypeManager._instance = new RaftSysTypeManager();
-    }
-    return RaftSysTypeManager._instance;
-  }
-
-  // Add a system type by name with its factory
-  public addSystemType(sysType: string, factory: RaftSystemTypeCreator): void {
-    if (this._sysTypes.has(sysType)) {
-      throw new Error(`System type '${sysType}' is already registered.`);
-    }
-    this._sysTypes.set(sysType, factory);
-  }
-
-  // Set the default system type factory
-  public addDefaultSystemType(factory: RaftSystemTypeCreator): void {
-    this._defaultSysTypeFactory = factory;
-  }
-
-  // Create a system type by name
-  public createSystemType(sysType: string): RaftSystemType | null {
-    const factory = this._sysTypes.get(sysType);
-    if (!factory) {
-      return null;
-    }
-    return factory();
-  }
-
-  // Create the default system type
-  public createDefaultSystemType(): RaftSystemType | null {
-    if (!this._defaultSysTypeFactory) {
-      return null;
-    }
-    return this._defaultSysTypeFactory();
-  }
-
-  // Get a list of all unique BLE service UUIDs
-  getAllServiceUUIDs(): string[] {
-    const serviceUUIDs = new Set<string>();
-    this._sysTypes.forEach((factory) => {
-      const sysType = factory();
-      sysType.BLEServiceUUIDs.forEach((uuid) => serviceUUIDs.add(uuid));
-    });
-    return Array.from(serviceUUIDs);
-  }
-}