react-native-ble-mesh 1.0.1

package/src/service/text/message/TextMessage.js

@@ -0,0 +1,296 @@
+'use strict';
+
+/**
+ * @fileoverview Text message class for text-based messaging
+ * @module service/text/message/TextMessage
+ */
+
+const { generateUUID } = require('../../../utils');
+
+/**
+ * Text message for private, broadcast, and channel messaging
+ * @class TextMessage
+ */
+class TextMessage {
+  /**
+   * Creates a new TextMessage
+   * @param {Object} options - Message options
+   * @param {string} [options.id] - Message ID
+   * @param {string} options.content - Message content
+   * @param {string} [options.senderId] - Sender peer ID
+   * @param {string} [options.recipientId] - Recipient peer ID (for private messages)
+   * @param {string} [options.channelId] - Channel ID (for channel messages)
+   * @param {number} [options.timestamp] - Message timestamp
+   * @param {boolean} [options.isRead] - Whether message has been read
+   */
+  constructor(options) {
+    const { id, content, senderId, recipientId, channelId, timestamp, isRead } = options;
+
+    /** @private */
+    this._id = id || generateUUID();
+    /** @private */
+    this._content = content || '';
+    /** @private */
+    this._senderId = senderId || null;
+    /** @private */
+    this._recipientId = recipientId || null;
+    /** @private */
+    this._channelId = channelId || null;
+    /** @private */
+    this._timestamp = timestamp || Date.now();
+    /** @private */
+    this._isRead = isRead || false;
+  }
+
+  /**
+   * Creates a TextMessage from a string
+   * @param {string} content - Message content
+   * @param {Object} [options] - Additional options
+   * @returns {TextMessage}
+   */
+  static fromString(content, options = {}) {
+    return new TextMessage({ content, ...options });
+  }
+
+  /**
+   * Creates a TextMessage from serialized data
+   * @param {Uint8Array} data - Serialized message data
+   * @returns {TextMessage}
+   */
+  static fromSerialized(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+    // Read header - version is at data[0] (reserved for future use)
+    const flags = data[1];
+    const timestamp = Number(view.getBigUint64(2, false));
+    const contentLength = view.getUint16(10, false);
+
+    let offset = 12;
+
+    // Read sender ID if present
+    let senderId = null;
+    if (flags & 0x01) {
+      senderId = new TextDecoder().decode(data.slice(offset, offset + 36));
+      offset += 36;
+    }
+
+    // Read recipient ID if present
+    let recipientId = null;
+    if (flags & 0x02) {
+      recipientId = new TextDecoder().decode(data.slice(offset, offset + 36));
+      offset += 36;
+    }
+
+    // Read channel ID if present
+    let channelId = null;
+    if (flags & 0x04) {
+      const channelIdLength = data[offset];
+      offset += 1;
+      channelId = new TextDecoder().decode(data.slice(offset, offset + channelIdLength));
+      offset += channelIdLength;
+    }
+
+    // Read message ID
+    const messageIdLength = data[offset];
+    offset += 1;
+    const id = new TextDecoder().decode(data.slice(offset, offset + messageIdLength));
+    offset += messageIdLength;
+
+    // Read content
+    const content = new TextDecoder().decode(data.slice(offset, offset + contentLength));
+
+    return new TextMessage({
+      id,
+      content,
+      senderId,
+      recipientId,
+      channelId,
+      timestamp,
+      isRead: (flags & 0x08) !== 0
+    });
+  }
+
+  /**
+   * Returns the message ID
+   * @returns {string}
+   */
+  getId() {
+    return this._id;
+  }
+
+  /**
+   * Returns the message content
+   * @returns {string}
+   */
+  getContent() {
+    return this._content;
+  }
+
+  /**
+   * Returns the message content as bytes
+   * @returns {Uint8Array}
+   */
+  getContentBytes() {
+    return new TextEncoder().encode(this._content);
+  }
+
+  /**
+   * Returns the sender ID
+   * @returns {string|null}
+   */
+  getSenderId() {
+    return this._senderId;
+  }
+
+  /**
+   * Returns the recipient ID
+   * @returns {string|null}
+   */
+  getRecipientId() {
+    return this._recipientId;
+  }
+
+  /**
+   * Returns the channel ID
+   * @returns {string|null}
+   */
+  getChannelId() {
+    return this._channelId;
+  }
+
+  /**
+   * Returns the message timestamp
+   * @returns {number}
+   */
+  getTimestamp() {
+    return this._timestamp;
+  }
+
+  /**
+   * Returns whether the message has been read
+   * @returns {boolean}
+   */
+  isRead() {
+    return this._isRead;
+  }
+
+  /**
+   * Marks the message as read
+   */
+  markAsRead() {
+    this._isRead = true;
+  }
+
+  /**
+   * Serializes the message to bytes
+   * @returns {Uint8Array}
+   */
+  serialize() {
+    const contentBytes = this.getContentBytes();
+    const idBytes = new TextEncoder().encode(this._id);
+
+    // Calculate flags
+    let flags = 0;
+    if (this._senderId) { flags |= 0x01; }
+    if (this._recipientId) { flags |= 0x02; }
+    if (this._channelId) { flags |= 0x04; }
+    if (this._isRead) { flags |= 0x08; }
+
+    // Calculate size
+    let size = 12 + 1 + idBytes.length + contentBytes.length; // header + id length + id + content
+    if (this._senderId) { size += 36; }
+    if (this._recipientId) { size += 36; }
+    if (this._channelId) {
+      const channelIdBytes = new TextEncoder().encode(this._channelId);
+      size += 1 + channelIdBytes.length;
+    }
+
+    const result = new Uint8Array(size);
+    const view = new DataView(result.buffer);
+
+    // Write header
+    result[0] = 1; // version
+    result[1] = flags;
+    view.setBigUint64(2, BigInt(this._timestamp), false);
+    view.setUint16(10, contentBytes.length, false);
+
+    let offset = 12;
+
+    // Write sender ID if present
+    if (this._senderId) {
+      const senderBytes = new TextEncoder().encode(this._senderId.padEnd(36, '\0').slice(0, 36));
+      result.set(senderBytes, offset);
+      offset += 36;
+    }
+
+    // Write recipient ID if present
+    if (this._recipientId) {
+      const recipientBytes = new TextEncoder().encode(this._recipientId.padEnd(36, '\0').slice(0, 36));
+      result.set(recipientBytes, offset);
+      offset += 36;
+    }
+
+    // Write channel ID if present
+    if (this._channelId) {
+      const channelIdBytes = new TextEncoder().encode(this._channelId);
+      result[offset] = channelIdBytes.length;
+      offset += 1;
+      result.set(channelIdBytes, offset);
+      offset += channelIdBytes.length;
+    }
+
+    // Write message ID
+    result[offset] = idBytes.length;
+    offset += 1;
+    result.set(idBytes, offset);
+    offset += idBytes.length;
+
+    // Write content
+    result.set(contentBytes, offset);
+
+    return result;
+  }
+
+  /**
+   * Returns message metadata
+   * @returns {Object}
+   */
+  getMetadata() {
+    return {
+      id: this._id,
+      senderId: this._senderId,
+      recipientId: this._recipientId,
+      channelId: this._channelId,
+      timestamp: this._timestamp,
+      isRead: this._isRead,
+      contentLength: this._content.length
+    };
+  }
+
+  /**
+   * Converts to JSON representation
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      id: this._id,
+      content: this._content,
+      senderId: this._senderId,
+      recipientId: this._recipientId,
+      channelId: this._channelId,
+      timestamp: this._timestamp,
+      isRead: this._isRead
+    };
+  }
+
+  /**
+   * Creates a TextMessage from JSON
+   * @param {Object} json - JSON object
+   * @returns {TextMessage}
+   */
+  static fromJSON(json) {
+    return new TextMessage(json);
+  }
+}
+
+module.exports = TextMessage;

package/src/service/text/message/TextSerializer.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * @fileoverview Text message serialization helpers
+ * @module service/text/message/TextSerializer
+ */
+
+/**
+ * Text header flags
+ * @constant {Object}
+ */
+const TEXT_HEADER_FLAGS = Object.freeze({
+  HAS_SENDER: 0x01,
+  HAS_RECIPIENT: 0x02,
+  HAS_CHANNEL: 0x04,
+  IS_READ: 0x08,
+  IS_COMPRESSED: 0x10,
+  REQUIRES_ACK: 0x20
+});
+
+/**
+ * Text header size (fixed portion)
+ * @constant {number}
+ */
+const TEXT_HEADER_SIZE = 12;
+
+/**
+ * Serializes text content to bytes
+ * @param {string} content - Text content
+ * @returns {Uint8Array}
+ */
+function serializeTextPayload(content) {
+  return new TextEncoder().encode(content);
+}
+
+/**
+ * Deserializes bytes to text content
+ * @param {Uint8Array} data - Serialized data
+ * @returns {string}
+ */
+function deserializeTextPayload(data) {
+  return new TextDecoder().decode(data);
+}
+
+/**
+ * Creates a text message header
+ * @param {Object} options - Header options
+ * @param {number} [options.version=1] - Protocol version
+ * @param {number} [options.type] - Message type
+ * @param {number} [options.timestamp] - Message timestamp
+ * @param {number} [options.payloadLength] - Payload length
+ * @param {boolean} [options.hasSender] - Has sender ID
+ * @param {boolean} [options.hasRecipient] - Has recipient ID
+ * @param {boolean} [options.hasChannel] - Has channel ID
+ * @param {boolean} [options.isRead] - Is read
+ * @param {boolean} [options.requiresAck] - Requires acknowledgment
+ * @returns {Uint8Array}
+ */
+function createTextHeader(options) {
+  const {
+    version = 1,
+    type = 0x01,
+    timestamp = Date.now(),
+    payloadLength = 0,
+    hasSender = false,
+    hasRecipient = false,
+    hasChannel = false,
+    isRead = false,
+    requiresAck = false
+  } = options;
+
+  const header = new Uint8Array(TEXT_HEADER_SIZE);
+  const view = new DataView(header.buffer);
+
+  // Calculate flags
+  let flags = 0;
+  if (hasSender) { flags |= TEXT_HEADER_FLAGS.HAS_SENDER; }
+  if (hasRecipient) { flags |= TEXT_HEADER_FLAGS.HAS_RECIPIENT; }
+  if (hasChannel) { flags |= TEXT_HEADER_FLAGS.HAS_CHANNEL; }
+  if (isRead) { flags |= TEXT_HEADER_FLAGS.IS_READ; }
+  if (requiresAck) { flags |= TEXT_HEADER_FLAGS.REQUIRES_ACK; }
+
+  header[0] = version;
+  header[1] = type;
+  header[2] = flags;
+  header[3] = 0; // reserved
+  view.setUint32(4, Math.floor(timestamp / 1000), false); // seconds since epoch
+  view.setUint16(8, timestamp % 1000, false); // milliseconds
+  view.setUint16(10, payloadLength, false);
+
+  return header;
+}
+
+/**
+ * Parses a text message header
+ * @param {Uint8Array} data - Header data
+ * @returns {Object}
+ */
+function parseTextHeader(data) {
+  if (data.length < TEXT_HEADER_SIZE) {
+    throw new Error('Invalid header: too short');
+  }
+
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+  const version = data[0];
+  const type = data[1];
+  const flags = data[2];
+  const timestampSec = view.getUint32(4, false);
+  const timestampMs = view.getUint16(8, false);
+  const payloadLength = view.getUint16(10, false);
+
+  return {
+    version,
+    type,
+    flags,
+    timestamp: timestampSec * 1000 + timestampMs,
+    payloadLength,
+    hasSender: (flags & TEXT_HEADER_FLAGS.HAS_SENDER) !== 0,
+    hasRecipient: (flags & TEXT_HEADER_FLAGS.HAS_RECIPIENT) !== 0,
+    hasChannel: (flags & TEXT_HEADER_FLAGS.HAS_CHANNEL) !== 0,
+    isRead: (flags & TEXT_HEADER_FLAGS.IS_READ) !== 0,
+    requiresAck: (flags & TEXT_HEADER_FLAGS.REQUIRES_ACK) !== 0
+  };
+}
+
+/**
+ * Serializes a string with length prefix
+ * @param {string} str - String to serialize
+ * @param {number} [maxLength=255] - Maximum length
+ * @returns {Uint8Array}
+ */
+function serializeString(str, maxLength = 255) {
+  const bytes = new TextEncoder().encode(str);
+  const truncated = bytes.slice(0, maxLength);
+  const result = new Uint8Array(1 + truncated.length);
+  result[0] = truncated.length;
+  result.set(truncated, 1);
+  return result;
+}
+
+/**
+ * Deserializes a length-prefixed string
+ * @param {Uint8Array} data - Serialized data
+ * @param {number} [offset=0] - Starting offset
+ * @returns {{ value: string, bytesRead: number }}
+ */
+function deserializeString(data, offset = 0) {
+  const length = data[offset];
+  const bytes = data.slice(offset + 1, offset + 1 + length);
+  const value = new TextDecoder().decode(bytes);
+  return { value, bytesRead: 1 + length };
+}
+
+module.exports = {
+  TEXT_HEADER_FLAGS,
+  TEXT_HEADER_SIZE,
+  serializeTextPayload,
+  deserializeTextPayload,
+  createTextHeader,
+  parseTextHeader,
+  serializeString,
+  deserializeString
+};

package/src/service/text/message/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * @fileoverview Text message module exports
+ * @module service/text/message
+ */
+
+const TextMessage = require('./TextMessage');
+const TextSerializer = require('./TextSerializer');
+
+module.exports = {
+  TextMessage,
+  ...TextSerializer
+};