react-native-ble-mesh 1.0.1

package/src/service/text/broadcast/BroadcastManager.js

@@ -0,0 +1,222 @@
+'use strict';
+
+/**
+ * @fileoverview Broadcast message handling
+ * @module service/text/broadcast/BroadcastManager
+ */
+
+const EventEmitter = require('events');
+const TextMessage = require('../message/TextMessage');
+
+/**
+ * Broadcast configuration
+ * @constant {Object}
+ */
+const BROADCAST_CONFIG = Object.freeze({
+  MAX_MESSAGE_SIZE: 1000,
+  MAX_RECENT_BROADCASTS: 100,
+  DEDUP_WINDOW_MS: 5 * 60 * 1000 // 5 minutes
+});
+
+/**
+ * Manages broadcast message handling
+ * @class BroadcastManager
+ * @extends EventEmitter
+ */
+class BroadcastManager extends EventEmitter {
+  /**
+   * Creates a new BroadcastManager
+   * @param {Object} [options] - Manager options
+   * @param {number} [options.maxRecentBroadcasts] - Max broadcasts to keep
+   * @param {number} [options.dedupWindowMs] - Deduplication window
+   */
+  constructor(options = {}) {
+    super();
+
+    /** @private */
+    this._maxRecentBroadcasts = options.maxRecentBroadcasts || BROADCAST_CONFIG.MAX_RECENT_BROADCASTS;
+    /** @private */
+    this._dedupWindowMs = options.dedupWindowMs || BROADCAST_CONFIG.DEDUP_WINDOW_MS;
+    /** @private */
+    this._recentBroadcasts = [];
+    /** @private */
+    this._seenMessageIds = new Map(); // messageId -> timestamp
+    /** @private */
+    this._senderId = null;
+    /** @private */
+    this._sendCallback = null;
+  }
+
+  /**
+   * Initializes the broadcast manager
+   * @param {Object} options - Init options
+   * @param {string} options.senderId - Local sender ID
+   * @param {Function} options.sendCallback - Callback to send broadcast
+   */
+  initialize(options) {
+    this._senderId = options.senderId;
+    this._sendCallback = options.sendCallback;
+  }
+
+  /**
+   * Sends a broadcast message
+   * @param {string} content - Message content
+   * @returns {string} Message ID
+   */
+  broadcast(content) {
+    if (content.length > BROADCAST_CONFIG.MAX_MESSAGE_SIZE) {
+      throw new Error(`Broadcast message too large (max ${BROADCAST_CONFIG.MAX_MESSAGE_SIZE} bytes)`);
+    }
+
+    const message = TextMessage.fromString(content, {
+      senderId: this._senderId
+    });
+
+    const messageId = message.getId();
+
+    // Mark as seen to avoid echo
+    this._seenMessageIds.set(messageId, Date.now());
+
+    // Add to recent broadcasts
+    this._addToRecent(message);
+
+    // Send via callback
+    if (this._sendCallback) {
+      this._sendCallback(message);
+    }
+
+    this.emit('broadcast-sent', {
+      messageId,
+      content,
+      timestamp: message.getTimestamp()
+    });
+
+    return messageId;
+  }
+
+  /**
+   * Handles an incoming broadcast message
+   * @param {string} peerId - Sender peer ID
+   * @param {Uint8Array} payload - Message payload
+   */
+  handleIncomingBroadcast(peerId, payload) {
+    let message;
+
+    // Try to deserialize
+    try {
+      if (payload instanceof Uint8Array) {
+        message = TextMessage.fromSerialized(payload);
+      } else if (typeof payload === 'string') {
+        message = TextMessage.fromString(payload, { senderId: peerId });
+      } else {
+        return;
+      }
+    } catch {
+      // If deserialization fails, treat as plain text
+      const content = typeof payload === 'string'
+        ? payload
+        : new TextDecoder().decode(payload);
+      message = TextMessage.fromString(content, { senderId: peerId });
+    }
+
+    const messageId = message.getId();
+
+    // Check for duplicate
+    if (this._isDuplicate(messageId)) {
+      return;
+    }
+
+    // Mark as seen
+    this._seenMessageIds.set(messageId, Date.now());
+
+    // Add to recent broadcasts
+    this._addToRecent(message);
+
+    this.emit('broadcast-received', {
+      messageId,
+      peerId,
+      content: message.getContent(),
+      timestamp: message.getTimestamp(),
+      message
+    });
+  }
+
+  /**
+   * Gets recent broadcasts
+   * @param {number} [limit] - Maximum number to return
+   * @returns {TextMessage[]}
+   */
+  getRecentBroadcasts(limit) {
+    const broadcasts = [...this._recentBroadcasts];
+    if (limit && limit > 0) {
+      return broadcasts.slice(-limit);
+    }
+    return broadcasts;
+  }
+
+  /**
+   * Clears all broadcast data
+   */
+  clear() {
+    this._recentBroadcasts = [];
+    this._seenMessageIds.clear();
+  }
+
+  /**
+   * Gets broadcast statistics
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      recentCount: this._recentBroadcasts.length,
+      seenCount: this._seenMessageIds.size
+    };
+  }
+
+  /**
+   * Cleans up old dedup entries
+   */
+  cleanup() {
+    const now = Date.now();
+    const cutoff = now - this._dedupWindowMs;
+
+    for (const [messageId, timestamp] of this._seenMessageIds) {
+      if (timestamp < cutoff) {
+        this._seenMessageIds.delete(messageId);
+      }
+    }
+  }
+
+  /**
+   * Checks if a message is a duplicate
+   * @private
+   * @param {string} messageId - Message ID
+   * @returns {boolean}
+   */
+  _isDuplicate(messageId) {
+    const seenAt = this._seenMessageIds.get(messageId);
+    if (!seenAt) { return false; }
+
+    // Check if within dedup window
+    const age = Date.now() - seenAt;
+    return age < this._dedupWindowMs;
+  }
+
+  /**
+   * Adds a message to recent broadcasts
+   * @private
+   * @param {TextMessage} message - Message to add
+   */
+  _addToRecent(message) {
+    this._recentBroadcasts.push(message);
+
+    // Trim if over limit
+    while (this._recentBroadcasts.length > this._maxRecentBroadcasts) {
+      this._recentBroadcasts.shift();
+    }
+  }
+}
+
+BroadcastManager.CONFIG = BROADCAST_CONFIG;
+
+module.exports = BroadcastManager;

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

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * @fileoverview Broadcast module exports
+ * @module service/text/broadcast
+ */
+
+const BroadcastManager = require('./BroadcastManager');
+
+module.exports = {
+  BroadcastManager
+};

package/src/service/text/channel/Channel.js

@@ -0,0 +1,226 @@
+'use strict';
+
+/**
+ * @fileoverview Channel class for group messaging
+ * @module service/text/channel/Channel
+ */
+
+/**
+ * Represents a communication channel for group messaging
+ * @class Channel
+ */
+class Channel {
+  /**
+   * Creates a new Channel
+   * @param {Object} options - Channel options
+   * @param {string} options.id - Channel ID
+   * @param {string} [options.name] - Channel display name
+   * @param {string} [options.password] - Channel password (hashed)
+   * @param {number} [options.createdAt] - Creation timestamp
+   */
+  constructor(options) {
+    const { id, name, password, createdAt } = options;
+
+    if (!id || typeof id !== 'string') {
+      throw new Error('Channel ID is required');
+    }
+
+    /** @private */
+    this._id = id;
+    /** @private */
+    this._name = name || id;
+    /** @private */
+    this._passwordHash = password ? this._hashPassword(password) : null;
+    /** @private */
+    this._members = new Set();
+    /** @private */
+    this._createdAt = createdAt || Date.now();
+    /** @private */
+    this._joinedAt = Date.now();
+  }
+
+  /**
+   * Returns the channel ID
+   * @returns {string}
+   */
+  getId() {
+    return this._id;
+  }
+
+  /**
+   * Returns the channel name
+   * @returns {string}
+   */
+  getName() {
+    return this._name;
+  }
+
+  /**
+   * Sets the channel name
+   * @param {string} name - New channel name
+   */
+  setName(name) {
+    this._name = name;
+  }
+
+  /**
+   * Returns channel member peer IDs
+   * @returns {string[]}
+   */
+  getMembers() {
+    return Array.from(this._members);
+  }
+
+  /**
+   * Returns the number of members
+   * @returns {number}
+   */
+  getMemberCount() {
+    return this._members.size;
+  }
+
+  /**
+   * Adds a member to the channel
+   * @param {string} peerId - Peer ID to add
+   * @returns {boolean} True if member was added (not already present)
+   */
+  addMember(peerId) {
+    if (this._members.has(peerId)) {
+      return false;
+    }
+    this._members.add(peerId);
+    return true;
+  }
+
+  /**
+   * Removes a member from the channel
+   * @param {string} peerId - Peer ID to remove
+   * @returns {boolean} True if member was removed
+   */
+  removeMember(peerId) {
+    return this._members.delete(peerId);
+  }
+
+  /**
+   * Checks if a peer is a member
+   * @param {string} peerId - Peer ID to check
+   * @returns {boolean}
+   */
+  hasMember(peerId) {
+    return this._members.has(peerId);
+  }
+
+  /**
+   * Returns whether the channel is password protected
+   * @returns {boolean}
+   */
+  isPasswordProtected() {
+    return this._passwordHash !== null;
+  }
+
+  /**
+   * Validates a password against the channel password
+   * @param {string} password - Password to validate
+   * @returns {boolean}
+   */
+  validatePassword(password) {
+    if (!this._passwordHash) {
+      return true;
+    }
+    const hash = this._hashPassword(password);
+    return this._constantTimeEqual(this._passwordHash, hash);
+  }
+
+  /**
+   * Sets a new password for the channel
+   * @param {string|null} password - New password or null to remove
+   */
+  setPassword(password) {
+    this._passwordHash = password ? this._hashPassword(password) : null;
+  }
+
+  /**
+   * Returns the creation timestamp
+   * @returns {number}
+   */
+  getCreatedAt() {
+    return this._createdAt;
+  }
+
+  /**
+   * Returns the joined timestamp
+   * @returns {number}
+   */
+  getJoinedAt() {
+    return this._joinedAt;
+  }
+
+  /**
+   * Converts to JSON representation
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      id: this._id,
+      name: this._name,
+      memberCount: this._members.size,
+      members: Array.from(this._members),
+      isPasswordProtected: this.isPasswordProtected(),
+      createdAt: this._createdAt,
+      joinedAt: this._joinedAt
+    };
+  }
+
+  /**
+   * Creates a Channel from JSON
+   * @param {Object} json - JSON object
+   * @returns {Channel}
+   */
+  static fromJSON(json) {
+    const channel = new Channel({
+      id: json.id,
+      name: json.name,
+      createdAt: json.createdAt
+    });
+
+    if (json.members) {
+      json.members.forEach(peerId => channel.addMember(peerId));
+    }
+
+    channel._joinedAt = json.joinedAt || Date.now();
+    return channel;
+  }
+
+  /**
+   * Simple password hash function
+   * @private
+   * @param {string} password - Password to hash
+   * @returns {Uint8Array}
+   */
+  _hashPassword(password) {
+    const data = new TextEncoder().encode(password);
+    const hash = new Uint8Array(32);
+    for (let i = 0; i < data.length; i++) {
+      hash[i % 32] ^= data[i];
+    }
+    return hash;
+  }
+
+  /**
+   * Constant-time comparison
+   * @private
+   * @param {Uint8Array} a - First array
+   * @param {Uint8Array} b - Second array
+   * @returns {boolean}
+   */
+  _constantTimeEqual(a, b) {
+    if (a.length !== b.length) { return false; }
+    let diff = 0;
+    for (let i = 0; i < a.length; i++) {
+      diff |= a[i] ^ b[i];
+    }
+    return diff === 0;
+  }
+}
+
+module.exports = Channel;

package/src/service/text/channel/ChannelManager.js

@@ -0,0 +1,171 @@
+'use strict';
+
+/**
+ * @fileoverview Channel subscription management for group messaging
+ * @module service/text/channel/ChannelManager
+ */
+
+const EventEmitter = require('events');
+const { MeshError } = require('../../../errors');
+const { EVENTS, ERROR_CODE } = require('../../../constants');
+const Channel = require('./Channel');
+
+/**
+ * Manages channel subscriptions and channel-based messaging.
+ * @class ChannelManager
+ * @extends EventEmitter
+ */
+class ChannelManager extends EventEmitter {
+  constructor() {
+    super();
+    /** @private */
+    this._channels = new Map();
+  }
+
+  /**
+   * Joins a channel
+   * @param {string} channelId - Channel ID
+   * @param {string} [password] - Optional password
+   * @returns {Channel}
+   */
+  joinChannel(channelId, password) {
+    if (!channelId || typeof channelId !== 'string') {
+      throw new MeshError('Invalid channel ID', ERROR_CODE.E801);
+    }
+    if (this._channels.has(channelId)) {
+      throw new MeshError('Already joined this channel', ERROR_CODE.E601);
+    }
+
+    const channel = new Channel({
+      id: channelId,
+      name: channelId,
+      password: password || null
+    });
+
+    this._channels.set(channelId, channel);
+    this.emit(EVENTS.CHANNEL_JOINED, { channelId, channel: channel.toJSON() });
+    return channel;
+  }
+
+  /**
+   * Leaves a channel
+   * @param {string} channelId - Channel ID
+   */
+  leaveChannel(channelId) {
+    if (!this._channels.has(channelId)) {
+      throw new MeshError('Not a member of this channel', ERROR_CODE.E602);
+    }
+    const channel = this._channels.get(channelId);
+    this._channels.delete(channelId);
+    this.emit(EVENTS.CHANNEL_LEFT, { channelId, memberCount: channel.getMemberCount() });
+  }
+
+  /**
+   * Gets all joined channels
+   * @returns {Object[]}
+   */
+  getChannels() {
+    return Array.from(this._channels.values()).map(c => c.toJSON());
+  }
+
+  /**
+   * Gets a specific channel
+   * @param {string} channelId - Channel ID
+   * @returns {Channel|undefined}
+   */
+  getChannel(channelId) {
+    return this._channels.get(channelId);
+  }
+
+  /**
+   * Checks if in a channel
+   * @param {string} channelId - Channel ID
+   * @returns {boolean}
+   */
+  isInChannel(channelId) {
+    return this._channels.has(channelId);
+  }
+
+  /**
+   * Gets members of a channel
+   * @param {string} channelId - Channel ID
+   * @returns {string[]}
+   */
+  getChannelMembers(channelId) {
+    const channel = this._channels.get(channelId);
+    return channel ? channel.getMembers() : [];
+  }
+
+  /**
+   * Adds a member to a channel
+   * @param {string} channelId - Channel ID
+   * @param {string} peerId - Peer ID
+   */
+  addMember(channelId, peerId) {
+    const channel = this._channels.get(channelId);
+    if (channel && channel.addMember(peerId)) {
+      this.emit(EVENTS.CHANNEL_MEMBER_JOINED, { channelId, peerId });
+    }
+  }
+
+  /**
+   * Removes a member from a channel
+   * @param {string} channelId - Channel ID
+   * @param {string} peerId - Peer ID
+   */
+  removeMember(channelId, peerId) {
+    const channel = this._channels.get(channelId);
+    if (channel && channel.removeMember(peerId)) {
+      this.emit(EVENTS.CHANNEL_MEMBER_LEFT, { channelId, peerId });
+    }
+  }
+
+  /**
+   * Handles an incoming channel message
+   * @param {Object} message - Message data
+   */
+  handleChannelMessage(message) {
+    const { channelId, senderId, content, timestamp } = message;
+    if (!this._channels.has(channelId)) { return; }
+
+    const channel = this._channels.get(channelId);
+    if (senderId && !channel.hasMember(senderId)) {
+      channel.addMember(senderId);
+      this.emit(EVENTS.CHANNEL_MEMBER_JOINED, { channelId, peerId: senderId });
+    }
+    const ts = timestamp || Date.now();
+    this.emit(EVENTS.CHANNEL_MESSAGE, { channelId, senderId, content, timestamp: ts });
+  }
+
+  /**
+   * Verifies a channel password
+   * @param {string} channelId - Channel ID
+   * @param {string} password - Password to verify
+   * @returns {boolean}
+   */
+  verifyPassword(channelId, password) {
+    const channel = this._channels.get(channelId);
+    if (!channel) { return false; }
+    return channel.validatePassword(password);
+  }
+
+  /**
+   * Clears all channels
+   */
+  clear() {
+    this._channels.clear();
+  }
+
+  /**
+   * Gets channel statistics
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      channelCount: this._channels.size,
+      totalMembers: Array.from(this._channels.values()).reduce((s, c) => s + c.getMemberCount(), 0)
+    };
+  }
+}
+
+module.exports = ChannelManager;

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

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * @fileoverview Channel module exports
+ * @module service/text/channel
+ */
+
+const Channel = require('./Channel');
+const ChannelManager = require('./ChannelManager');
+
+module.exports = {
+  Channel,
+  ChannelManager
+};

package/src/service/text/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * @fileoverview Text messaging module exports
+ * @module service/text
+ */
+
+const TextManager = require('./TextManager');
+const message = require('./message');
+const channel = require('./channel');
+const broadcast = require('./broadcast');
+
+module.exports = {
+  // Main service
+  TextManager,
+
+  // Message
+  TextMessage: message.TextMessage,
+
+  // Channel
+  Channel: channel.Channel,
+  ChannelManager: channel.ChannelManager,
+
+  // Broadcast
+  BroadcastManager: broadcast.BroadcastManager,
+
+  // Submodules for advanced usage
+  message,
+  channel,
+  broadcast
+};