react-native-ble-mesh 1.0.1

package/src/service/audio/session/VoiceMessage.js

@@ -0,0 +1,378 @@
+'use strict';
+
+/**
+ * @fileoverview Voice message recording and playback
+ * @module audio/session/VoiceMessage
+ */
+
+const EventEmitter = require('../../../utils/EventEmitter');
+const AudioError = require('../../../errors/AudioError');
+const { VOICE_MESSAGE_CONFIG, AUDIO_CODEC_TYPE } = require('../../../constants/audio');
+const FrameBuffer = require('../buffer/FrameBuffer');
+
+/**
+ * Voice message header size
+ * @constant {number}
+ */
+const VOICE_MESSAGE_HEADER_SIZE = VOICE_MESSAGE_CONFIG.HEADER_SIZE;
+
+/**
+ * Voice message magic bytes
+ * @constant {Uint8Array}
+ */
+const VOICE_MESSAGE_MAGIC = new Uint8Array([0x56, 0x4D, 0x53, 0x47]); // 'VMSG'
+
+/**
+ * Voice message for store-and-forward audio
+ * @class VoiceMessage
+ */
+class VoiceMessage {
+  /**
+   * Creates a VoiceMessage from recorded frames
+   * @param {Object} options - Message options
+   * @param {FrameBuffer} options.frames - Recorded frames
+   * @param {Object} options.metadata - Recording metadata
+   * @param {Uint8Array} options.senderId - Sender ID (32 bytes)
+   */
+  constructor(options) {
+    const { frames, metadata, senderId } = options;
+
+    /** @private */
+    this._frames = frames;
+    /** @private */
+    this._metadata = {
+      version: 1,
+      codec: metadata.codec || AUDIO_CODEC_TYPE.LC3,
+      sampleRate: metadata.sampleRate || 16000,
+      bitRate: metadata.bitRate || 24000,
+      frameMs: metadata.frameMs || 10,
+      channels: metadata.channels || 1,
+      createdAt: metadata.createdAt || Date.now()
+    };
+    /** @private */
+    this._senderId = senderId || new Uint8Array(32);
+    /** @private */
+    this._playbackPosition = 0;
+  }
+
+  /**
+   * Starts recording a new voice message
+   * @param {Object} options - Recording options
+   * @param {LC3Codec} options.codec - Initialized codec
+   * @param {Uint8Array} options.senderId - Sender ID
+   * @returns {VoiceMessageRecorder}
+   */
+  static startRecording(options) {
+    // eslint-disable-next-line no-use-before-define
+    return new VoiceMessageRecorder(options);
+  }
+
+  /**
+   * Creates a VoiceMessage from serialized data
+   * @param {Uint8Array} data - Serialized voice message
+   * @returns {VoiceMessage}
+   */
+  static fromSerialized(data) {
+    if (data.length < VOICE_MESSAGE_HEADER_SIZE) {
+      throw AudioError.decodingFailed({ reason: 'Voice message too short' });
+    }
+
+    // Verify magic
+    for (let i = 0; i < 4; i++) {
+      if (data[i] !== VOICE_MESSAGE_MAGIC[i]) {
+        throw AudioError.decodingFailed({ reason: 'Invalid voice message magic' });
+      }
+    }
+
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+    const metadata = {
+      version: data[4],
+      codec: data[5],
+      sampleRate: view.getUint16(6, false),
+      bitRate: view.getUint16(8, false),
+      frameMs: data[10] / 10,
+      channels: data[11],
+      totalFrames: view.getUint32(12, false),
+      durationMs: view.getUint32(16, false),
+      createdAt: view.getUint32(20, false) * 1000
+    };
+
+    const senderId = data.slice(24, 56);
+    const frameData = data.slice(VOICE_MESSAGE_HEADER_SIZE);
+    const frames = FrameBuffer.deserialize(frameData);
+
+    return new VoiceMessage({ frames, metadata, senderId });
+  }
+
+  /**
+   * Serializes the voice message
+   * @returns {Uint8Array}
+   */
+  serialize() {
+    const frameData = this._frames.serialize();
+    const totalLen = VOICE_MESSAGE_HEADER_SIZE + frameData.length;
+    const result = new Uint8Array(totalLen);
+    const view = new DataView(result.buffer);
+
+    // Header
+    result.set(VOICE_MESSAGE_MAGIC, 0);
+    result[4] = this._metadata.version;
+    result[5] = this._metadata.codec;
+    view.setUint16(6, this._metadata.sampleRate, false);
+    view.setUint16(8, this._metadata.bitRate, false);
+    result[10] = Math.round(this._metadata.frameMs * 10);
+    result[11] = this._metadata.channels;
+    view.setUint32(12, this._frames.getFrameCount(), false);
+    view.setUint32(16, this.getDurationMs(), false);
+    view.setUint32(20, Math.floor(this._metadata.createdAt / 1000), false);
+    result.set(this._senderId.slice(0, 32), 24);
+
+    // Frame data
+    result.set(frameData, VOICE_MESSAGE_HEADER_SIZE);
+
+    return result;
+  }
+
+  /**
+   * Returns duration in milliseconds
+   * @returns {number}
+   */
+  getDurationMs() {
+    return this._frames.getDurationMs(this._metadata.frameMs);
+  }
+
+  /**
+   * Returns total size in bytes
+   * @returns {number}
+   */
+  getSize() {
+    return VOICE_MESSAGE_HEADER_SIZE + this._frames.getTotalBytes();
+  }
+
+  /**
+   * Returns frame count
+   * @returns {number}
+   */
+  getFrameCount() {
+    return this._frames.getFrameCount();
+  }
+
+  /**
+   * Returns metadata
+   * @returns {Object}
+   */
+  getMetadata() {
+    return {
+      ...this._metadata,
+      frameCount: this._frames.getFrameCount(),
+      durationMs: this.getDurationMs(),
+      size: this.getSize()
+    };
+  }
+
+  /**
+   * Returns sender ID
+   * @returns {Uint8Array}
+   */
+  getSenderId() {
+    return this._senderId;
+  }
+
+  /**
+   * Gets frame at index for playback
+   * @param {number} index - Frame index
+   * @returns {Uint8Array|null}
+   */
+  getFrame(index) {
+    return this._frames.getFrame(index);
+  }
+
+  /**
+   * Gets next frame for playback
+   * @returns {{frame: Uint8Array, index: number, done: boolean}|null}
+   */
+  getNextFrame() {
+    if (this._playbackPosition >= this._frames.getFrameCount()) {
+      return { frame: null, index: this._playbackPosition, done: true };
+    }
+
+    const frame = this._frames.getFrame(this._playbackPosition);
+    const index = this._playbackPosition;
+    this._playbackPosition++;
+
+    return { frame, index, done: false };
+  }
+
+  /**
+   * Seeks to position in milliseconds
+   * @param {number} positionMs - Position in ms
+   */
+  seek(positionMs) {
+    const frameIndex = Math.floor(positionMs / this._metadata.frameMs);
+    this._playbackPosition = Math.max(0, Math.min(frameIndex, this._frames.getFrameCount()));
+  }
+
+  /**
+   * Resets playback position
+   */
+  resetPlayback() {
+    this._playbackPosition = 0;
+  }
+
+  /**
+   * Returns current playback position in ms
+   * @returns {number}
+   */
+  getPlaybackPositionMs() {
+    return this._playbackPosition * this._metadata.frameMs;
+  }
+}
+
+/**
+ * Voice message recorder
+ * @class VoiceMessageRecorder
+ * @extends EventEmitter
+ */
+class VoiceMessageRecorder extends EventEmitter {
+  /**
+   * Creates a new recorder
+   * @param {Object} options - Recorder options
+   * @param {LC3Codec} options.codec - Initialized codec
+   * @param {Uint8Array} options.senderId - Sender ID
+   */
+  constructor(options) {
+    super();
+
+    const { codec, senderId } = options;
+
+    if (!codec || !codec.isInitialized()) {
+      throw AudioError.codecInitFailed({ reason: 'Codec must be initialized' });
+    }
+
+    /** @private */
+    this._codec = codec;
+    /** @private */
+    this._senderId = senderId || new Uint8Array(32);
+    /** @private */
+    this._frames = new FrameBuffer();
+    /** @private */
+    this._encoder = null;
+    /** @private */
+    this._startTime = Date.now();
+    /** @private */
+    this._cancelled = false;
+    /** @private */
+    this._config = codec.getConfig();
+
+    // Lazy load encoder
+    const LC3Encoder = require('../codec/LC3Encoder');
+    this._encoder = new LC3Encoder(codec);
+  }
+
+  /**
+   * Pushes PCM samples to recording
+   * @param {Int16Array} samples - PCM audio samples
+   * @returns {Promise<void>}
+   */
+  async pushSamples(samples) {
+    if (this._cancelled) { return; }
+
+    const frames = await this._encoder.pushSamples(samples);
+
+    for (const frame of frames) {
+      const added = this._frames.push(frame);
+
+      if (!added) {
+        this.emit('limit-warning', {
+          type: 'size',
+          current: this._frames.getTotalBytes(),
+          max: VOICE_MESSAGE_CONFIG.MAX_SIZE_BYTES
+        });
+        return;
+      }
+
+      this.emit('frame', {
+        index: this._frames.getFrameCount(),
+        durationMs: this.getDurationMs()
+      });
+    }
+
+    // Check duration limit
+    if (this.getDurationMs() >= VOICE_MESSAGE_CONFIG.MAX_DURATION_SEC * 1000) {
+      this.emit('limit-warning', {
+        type: 'duration',
+        current: this.getDurationMs(),
+        max: VOICE_MESSAGE_CONFIG.MAX_DURATION_SEC * 1000
+      });
+    }
+  }
+
+  /**
+   * Stops recording and returns voice message
+   * @returns {Promise<VoiceMessage>}
+   */
+  async stop() {
+    if (this._cancelled) {
+      throw AudioError.fromCode('EA00', { reason: 'Recording cancelled' });
+    }
+
+    // Flush remaining samples
+    const frames = await this._encoder.flush();
+    for (const frame of frames) {
+      this._frames.push(frame);
+    }
+
+    return new VoiceMessage({
+      frames: this._frames,
+      metadata: {
+        codec: AUDIO_CODEC_TYPE.LC3,
+        sampleRate: this._config.sampleRate,
+        bitRate: this._config.bitRate,
+        frameMs: this._config.frameMs,
+        channels: this._config.channels,
+        createdAt: this._startTime
+      },
+      senderId: this._senderId
+    });
+  }
+
+  /**
+   * Cancels recording
+   */
+  cancel() {
+    this._cancelled = true;
+    this._frames.clear();
+  }
+
+  /**
+   * Returns current duration in ms
+   * @returns {number}
+   */
+  getDurationMs() {
+    return this._frames.getDurationMs(this._config.frameMs);
+  }
+
+  /**
+   * Returns current size in bytes
+   * @returns {number}
+   */
+  getSize() {
+    return this._frames.getTotalBytes();
+  }
+
+  /**
+   * Returns recording status
+   * @returns {boolean}
+   */
+  isRecording() {
+    return !this._cancelled;
+  }
+}
+
+module.exports = {
+  VoiceMessage,
+  VoiceMessageRecorder,
+  VOICE_MESSAGE_HEADER_SIZE,
+  VOICE_MESSAGE_MAGIC
+};

package/src/service/audio/session/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * @fileoverview Audio session module exports
+ * @module audio/session
+ */
+
+const { VoiceMessage, VoiceMessageRecorder, VOICE_MESSAGE_HEADER_SIZE } = require('./VoiceMessage');
+const AudioSession = require('./AudioSession');
+
+module.exports = {
+  VoiceMessage,
+  VoiceMessageRecorder,
+  AudioSession,
+  VOICE_MESSAGE_HEADER_SIZE
+};

package/src/service/audio/transport/AudioFragmenter.js

@@ -0,0 +1,260 @@
+'use strict';
+
+/**
+ * @fileoverview Audio-specific fragmentation for voice messages
+ * @module audio/transport/AudioFragmenter
+ */
+
+const EventEmitter = require('../../../utils/EventEmitter');
+const { MESSAGE_TYPE } = require('../../../constants/protocol');
+const { VOICE_MESSAGE_CONFIG } = require('../../../constants/audio');
+
+/**
+ * Fragments voice message data for BLE transport
+ * @class AudioFragmenter
+ */
+class AudioFragmenter {
+  /**
+   * Fragments voice message data
+   * @param {Uint8Array} voiceData - Serialized voice message
+   * @param {Object} metadata - Voice message metadata
+   * @param {string} metadata.messageId - Unique message ID
+   * @param {number} [chunkSize] - Chunk size (default from config)
+   * @returns {Uint8Array[]} Array of fragments
+   */
+  static fragment(voiceData, metadata, chunkSize = VOICE_MESSAGE_CONFIG.CHUNK_SIZE) {
+    const { messageId } = metadata;
+    const messageIdBytes = this._stringToBytes(messageId, 16);
+    const totalChunks = Math.ceil(voiceData.length / chunkSize);
+    const fragments = [];
+
+    for (let i = 0; i < totalChunks; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, voiceData.length);
+      const chunk = voiceData.slice(start, end);
+
+      let type;
+      if (i === 0) {
+        type = MESSAGE_TYPE.VOICE_MESSAGE_START;
+      } else if (i === totalChunks - 1) {
+        type = MESSAGE_TYPE.VOICE_MESSAGE_END;
+      } else {
+        type = MESSAGE_TYPE.VOICE_MESSAGE_DATA;
+      }
+
+      // Fragment format: [type(1)][messageId(16)][index(2)][total(2)][totalSize(4)][data...]
+      const headerSize = type === MESSAGE_TYPE.VOICE_MESSAGE_START ? 25 : 21;
+      const fragment = new Uint8Array(headerSize + chunk.length);
+      const view = new DataView(fragment.buffer);
+
+      fragment[0] = type;
+      fragment.set(messageIdBytes, 1);
+      view.setUint16(17, i, false);
+      view.setUint16(19, totalChunks, false);
+
+      if (type === MESSAGE_TYPE.VOICE_MESSAGE_START) {
+        view.setUint32(21, voiceData.length, false);
+        fragment.set(chunk, 25);
+      } else {
+        fragment.set(chunk, 21);
+      }
+
+      fragments.push(fragment);
+    }
+
+    return fragments;
+  }
+
+  /**
+   * Returns fragment count for data size
+   * @param {number} dataSize - Data size in bytes
+   * @param {number} [chunkSize] - Chunk size
+   * @returns {number}
+   */
+  static getFragmentCount(dataSize, chunkSize = VOICE_MESSAGE_CONFIG.CHUNK_SIZE) {
+    return Math.ceil(dataSize / chunkSize);
+  }
+
+  /**
+   * Converts string to fixed-length bytes
+   * @private
+   */
+  static _stringToBytes(str, length) {
+    const bytes = new Uint8Array(length);
+    const encoder = new TextEncoder();
+    const encoded = encoder.encode(str.slice(0, length));
+    bytes.set(encoded.slice(0, length));
+    return bytes;
+  }
+}
+
+/**
+ * Assembles fragmented voice messages
+ * @class AudioAssembler
+ * @extends EventEmitter
+ */
+class AudioAssembler extends EventEmitter {
+  /**
+   * Creates a new AudioAssembler
+   * @param {Object} [options] - Assembler options
+   * @param {number} [options.timeout=120000] - Assembly timeout in ms
+   */
+  constructor(options = {}) {
+    super();
+
+    /** @private */
+    this._timeout = options.timeout || VOICE_MESSAGE_CONFIG.TIMEOUT_MS;
+    /** @private */
+    this._pending = new Map(); // messageId -> { fragments, totalSize, receivedSize, timer }
+  }
+
+  /**
+   * Adds a fragment to assembly
+   * @param {Uint8Array} fragment - Fragment data
+   * @returns {Uint8Array|null} Complete voice data or null
+   */
+  addFragment(fragment) {
+    const type = fragment[0];
+    const messageId = this._bytesToString(fragment.slice(1, 17));
+    const view = new DataView(fragment.buffer, fragment.byteOffset, fragment.byteLength);
+    const index = view.getUint16(17, false);
+    const total = view.getUint16(19, false);
+
+    let chunkData;
+    let totalSize = 0;
+
+    if (type === MESSAGE_TYPE.VOICE_MESSAGE_START) {
+      totalSize = view.getUint32(21, false);
+      chunkData = fragment.slice(25);
+    } else {
+      chunkData = fragment.slice(21);
+    }
+
+    // Initialize pending entry
+    if (!this._pending.has(messageId)) {
+      if (type !== MESSAGE_TYPE.VOICE_MESSAGE_START) {
+        // Missed the start fragment
+        return null;
+      }
+
+      this._pending.set(messageId, {
+        fragments: new Map(),
+        totalSize,
+        total,
+        receivedSize: 0,
+        timer: setTimeout(() => this._handleTimeout(messageId), this._timeout)
+      });
+    }
+
+    const entry = this._pending.get(messageId);
+
+    // Store fragment
+    if (!entry.fragments.has(index)) {
+      entry.fragments.set(index, chunkData);
+      entry.receivedSize += chunkData.length;
+
+      this.emit('progress', {
+        messageId,
+        received: entry.fragments.size,
+        total: entry.total,
+        progress: entry.fragments.size / entry.total
+      });
+    }
+
+    // Check if complete
+    if (entry.fragments.size === entry.total) {
+      return this._assemble(messageId);
+    }
+
+    return null;
+  }
+
+  /**
+   * Assembles complete voice message
+   * @private
+   */
+  _assemble(messageId) {
+    const entry = this._pending.get(messageId);
+    if (!entry) { return null; }
+
+    clearTimeout(entry.timer);
+
+    // Combine fragments in order
+    const result = new Uint8Array(entry.totalSize);
+    let offset = 0;
+
+    for (let i = 0; i < entry.total; i++) {
+      const chunk = entry.fragments.get(i);
+      if (chunk) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+    }
+
+    this._pending.delete(messageId);
+    this.emit('complete', { messageId, size: result.length });
+
+    return result;
+  }
+
+  /**
+   * Handles assembly timeout
+   * @private
+   */
+  _handleTimeout(messageId) {
+    this._pending.delete(messageId);
+    this.emit('timeout', { messageId });
+  }
+
+  /**
+   * Gets assembly progress
+   * @param {string} messageId - Message ID
+   * @returns {Object|null}
+   */
+  getProgress(messageId) {
+    const entry = this._pending.get(messageId);
+    if (!entry) { return null; }
+
+    return {
+      received: entry.fragments.size,
+      total: entry.total,
+      progress: entry.fragments.size / entry.total,
+      receivedBytes: entry.receivedSize,
+      totalBytes: entry.totalSize
+    };
+  }
+
+  /**
+   * Aborts assembly of a message
+   * @param {string} messageId - Message ID
+   */
+  abort(messageId) {
+    const entry = this._pending.get(messageId);
+    if (entry) {
+      clearTimeout(entry.timer);
+      this._pending.delete(messageId);
+    }
+  }
+
+  /**
+   * Cleans up expired entries
+   */
+  cleanup() {
+    // Timeouts are handled automatically
+  }
+
+  /**
+   * Converts bytes to string
+   * @private
+   */
+  _bytesToString(bytes) {
+    const decoder = new TextDecoder();
+    const nullIndex = bytes.indexOf(0);
+    return decoder.decode(nullIndex >= 0 ? bytes.slice(0, nullIndex) : bytes);
+  }
+}
+
+module.exports = {
+  AudioFragmenter,
+  AudioAssembler
+};