react-native-ble-mesh 1.1.1 → 2.1.0

package/src/transport/WiFiDirectTransport.js

@@ -0,0 +1,296 @@
+'use strict';
+
+/**
+ * @fileoverview Wi-Fi Direct transport for high-bandwidth mesh communication
+ * @module transport/WiFiDirectTransport
+ *
+ * Provides ~250Mbps throughput and ~200m range via Wi-Fi Direct (P2P).
+ * Requires: react-native-wifi-p2p (optional peer dependency)
+ */
+
+const Transport = require('./Transport');
+const { ConnectionError } = require('../errors');
+
+/**
+ * Wi-Fi Direct transport states
+ * @constant {Object}
+ */
+const WIFI_DIRECT_STATE = Object.freeze({
+  AVAILABLE: 'available',
+  UNAVAILABLE: 'unavailable',
+  DISCOVERING: 'discovering',
+  CONNECTED: 'connected'
+});
+
+/**
+ * Wi-Fi Direct transport implementation.
+ * Uses react-native-wifi-p2p for peer discovery and data transfer.
+ *
+ * @class WiFiDirectTransport
+ * @extends Transport
+ */
+class WiFiDirectTransport extends Transport {
+  /**
+   * @param {Object} [options={}]
+   * @param {Object} [options.wifiP2p] - Injected react-native-wifi-p2p module
+   * @param {number} [options.port=8988] - Server port for socket communication
+   * @param {number} [options.connectTimeoutMs=15000] - Connection timeout
+   * @param {number} [options.maxPeers=4] - Max simultaneous Wi-Fi Direct peers
+   */
+  constructor(options = {}) {
+    super({ maxPeers: options.maxPeers || 4, ...options });
+
+    this._wifiP2p = options.wifiP2p || null;
+    this._port = options.port || 8988;
+    this._connectTimeoutMs = options.connectTimeoutMs || 15000;
+    this._isDiscovering = false;
+    this._isGroupOwner = false;
+    this._groupInfo = null;
+    this._subscriptions = [];
+  }
+
+  /**
+   * Whether discovery is active
+   * @returns {boolean}
+   */
+  get isDiscovering() {
+    return this._isDiscovering;
+  }
+
+  /**
+   * Whether this device is the Wi-Fi Direct group owner
+   * @returns {boolean}
+   */
+  get isGroupOwner() {
+    return this._isGroupOwner;
+  }
+
+  /**
+   * Starts the Wi-Fi Direct transport
+   * @returns {Promise<void>}
+   */
+  async start() {
+    if (this.isRunning) { return; }
+    this._setState(Transport.STATE.STARTING);
+
+    try {
+      const p2p = this._getWifiP2p();
+      await p2p.initialize();
+
+      // Check if Wi-Fi Direct is supported
+      const isAvailable = await p2p.isSuccessfulInitialize();
+      if (!isAvailable) {
+        throw new ConnectionError('Wi-Fi Direct is not available on this device', 'E100');
+      }
+
+      this._setState(Transport.STATE.RUNNING);
+    } catch (error) {
+      this._setState(Transport.STATE.ERROR);
+      throw error;
+    }
+  }
+
+  /**
+   * Stops the Wi-Fi Direct transport
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    if (this._state === Transport.STATE.STOPPED) { return; }
+    this._setState(Transport.STATE.STOPPING);
+
+    try {
+      if (this._isDiscovering) {
+        await this.stopDiscovery();
+      }
+
+      const p2p = this._getWifiP2p();
+
+      // Disconnect from group
+      try {
+        await p2p.removeGroup();
+      } catch (e) {
+        // Ignore — may not be in a group
+      }
+
+      // Cleanup subscriptions
+      this._subscriptions.forEach(sub => {
+        if (sub && typeof sub.remove === 'function') { sub.remove(); }
+      });
+      this._subscriptions = [];
+
+      this._peers.clear();
+    } finally {
+      this._setState(Transport.STATE.STOPPED);
+    }
+  }
+
+  /**
+   * Starts discovering nearby Wi-Fi Direct devices
+   * @returns {Promise<void>}
+   */
+  async startDiscovery() {
+    if (!this.isRunning || this._isDiscovering) { return; }
+
+    const p2p = this._getWifiP2p();
+    await p2p.discoverPeers();
+    this._isDiscovering = true;
+    this.emit('discoveryStarted');
+  }
+
+  /**
+   * Stops device discovery
+   * @returns {Promise<void>}
+   */
+  async stopDiscovery() {
+    if (!this._isDiscovering) { return; }
+
+    const p2p = this._getWifiP2p();
+    try {
+      await p2p.stopDiscoveringPeers();
+    } catch (e) {
+      // Ignore
+    }
+    this._isDiscovering = false;
+    this.emit('discoveryStopped');
+  }
+
+  /**
+   * Connects to a Wi-Fi Direct peer
+   * @param {string} peerId - Device address
+   * @returns {Promise<void>}
+   */
+  async connectToPeer(peerId) {
+    if (!this.isRunning) {
+      throw new Error('Transport is not running');
+    }
+    if (this._peers.has(peerId)) {
+      throw ConnectionError.fromCode('E206', peerId);
+    }
+    if (!this.canAcceptPeer()) {
+      throw ConnectionError.fromCode('E203', peerId);
+    }
+
+    const p2p = this._getWifiP2p();
+
+    try {
+      await p2p.connect(peerId);
+
+      const connectionInfo = await p2p.getConnectionInfo();
+      this._isGroupOwner = connectionInfo.isGroupOwner || false;
+      this._groupInfo = connectionInfo;
+
+      this._peers.set(peerId, {
+        peerId,
+        connectedAt: Date.now(),
+        isGroupOwner: this._isGroupOwner,
+        groupOwnerAddress: connectionInfo.groupOwnerAddress
+      });
+
+      this.emit('peerConnected', { peerId, transport: 'wifi-direct' });
+    } catch (error) {
+      throw ConnectionError.connectionFailed(peerId, { cause: error.message });
+    }
+  }
+
+  /**
+   * Disconnects from a peer
+   * @param {string} peerId
+   * @returns {Promise<void>}
+   */
+  async disconnectFromPeer(peerId) {
+    if (!this._peers.has(peerId)) { return; }
+
+    const p2p = this._getWifiP2p();
+    try {
+      await p2p.removeGroup();
+    } catch (e) {
+      // Ignore
+    }
+
+    this._peers.delete(peerId);
+    this.emit('peerDisconnected', { peerId, reason: 'user_request' });
+  }
+
+  /**
+   * Sends data to a peer via Wi-Fi Direct socket
+   * @param {string} peerId - Target peer
+   * @param {Uint8Array} data - Data to send
+   * @returns {Promise<void>}
+   */
+  async send(peerId, data) {
+    if (!this.isRunning) { throw new Error('Transport is not running'); }
+    if (!this._peers.has(peerId)) {
+      throw ConnectionError.fromCode('E207', peerId);
+    }
+
+    const p2p = this._getWifiP2p();
+    const peerInfo = this._peers.get(peerId);
+
+    // Convert Uint8Array to base64 for transfer
+    const base64 = this._uint8ArrayToBase64(data);
+
+    if (this._isGroupOwner) {
+      // Group owner sends via server socket
+      await p2p.sendMessage(base64);
+    } else {
+      // Client sends to group owner address
+      await p2p.sendMessageTo(peerInfo.groupOwnerAddress, this._port, base64);
+    }
+  }
+
+  /**
+   * Broadcasts to all connected peers
+   * @param {Uint8Array} data
+   * @returns {Promise<string[]>}
+   */
+  async broadcast(data) {
+    if (!this.isRunning) { throw new Error('Transport is not running'); }
+
+    const peerIds = this.getConnectedPeers();
+    const results = await Promise.allSettled(
+      peerIds.map(id => this.send(id, data))
+    );
+    return peerIds.filter((_, i) => results[i].status === 'fulfilled');
+  }
+
+  /**
+   * Gets available Wi-Fi Direct peers (discovered but not connected)
+   * @returns {Promise<Object[]>}
+   */
+  async getAvailablePeers() {
+    if (!this.isRunning) { return []; }
+    const p2p = this._getWifiP2p();
+    try {
+      return await p2p.getAvailablePeers();
+    } catch (e) {
+      return [];
+    }
+  }
+
+  /** @private */
+  _getWifiP2p() {
+    if (!this._wifiP2p) {
+      try {
+        this._wifiP2p = require('react-native-wifi-p2p');
+      } catch (e) {
+        throw new Error(
+          'react-native-wifi-p2p is required for WiFiDirectTransport. ' +
+          'Install: npm install react-native-wifi-p2p'
+        );
+      }
+    }
+    return this._wifiP2p;
+  }
+
+  /** @private */
+  _uint8ArrayToBase64(bytes) {
+    const chunks = [];
+    for (let i = 0; i < bytes.length; i += 8192) {
+      chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, Math.min(i + 8192, bytes.length))));
+    }
+    const binary = chunks.join('');
+    return typeof btoa !== 'undefined' ? btoa(binary) : Buffer.from(bytes).toString('base64');
+  }
+}
+
+module.exports = { WiFiDirectTransport, WIFI_DIRECT_STATE };

package/src/transport/adapters/NodeBLEAdapter.js

@@ -60,6 +60,13 @@ class NodeBLEAdapter extends BLEAdapter {
      * @private
      */
     this._scanCallback = null;
+
+    /**
+     * Disconnect callback
+     * @type {Function|null}
+     * @private
+     */
+    this._disconnectCallback = null;
   }
 
   /**
@@ -181,6 +188,18 @@ class NodeBLEAdapter extends BLEAdapter {
     // Monitor disconnection
     peripheral.once('disconnect', () => {
       this._peripherals.delete(deviceId);
+
+      // Clean up subscriptions for this device
+      for (const [key] of this._subscriptions.entries()) {
+        if (key.startsWith(`${deviceId}:`)) {
+          this._subscriptions.delete(key);
+        }
+      }
+
+      // Notify transport
+      if (this._disconnectCallback) {
+        this._disconnectCallback(deviceId);
+      }
     });
 
     return {
@@ -196,6 +215,13 @@ class NodeBLEAdapter extends BLEAdapter {
    * @returns {Promise<void>}
    */
   async disconnect(deviceId) {
+    // Clean up subscriptions first
+    for (const [key] of this._subscriptions.entries()) {
+      if (key.startsWith(`${deviceId}:`)) {
+        this._subscriptions.delete(key);
+      }
+    }
+
     const peripheral = this._peripherals.get(deviceId);
     if (peripheral) {
       await this._disconnectPeripheral(peripheral);
@@ -410,6 +436,14 @@ class NodeBLEAdapter extends BLEAdapter {
     });
   }
 
+  /**
+   * Registers a callback for device disconnection events
+   * @param {Function} callback - Callback function receiving peerId
+   */
+  onDeviceDisconnected(callback) {
+    this._disconnectCallback = callback;
+  }
+
   /**
    * Ensures the adapter is initialized
    * @throws {Error} If not initialized

package/src/transport/adapters/RNBLEAdapter.js

@@ -40,6 +40,13 @@ class RNBLEAdapter extends BLEAdapter {
      */
     this._BleManager = options.BleManager || null;
 
+    /**
+     * iOS state restoration identifier
+     * @type {string|null}
+     * @private
+     */
+    this._restoreIdentifier = options.restoreIdentifier || null;
+
     /**
      * Connected devices map
      * @type {Map<string, Object>}
@@ -67,6 +74,13 @@ class RNBLEAdapter extends BLEAdapter {
      * @private
      */
     this._stateSubscription = null;
+
+    /**
+     * Disconnect callback
+     * @type {Function|null}
+     * @private
+     */
+    this._disconnectCallback = null;
   }
 
   /**
@@ -91,7 +105,19 @@ class RNBLEAdapter extends BLEAdapter {
       }
     }
 
-    this._manager = new this._BleManager();
+    const managerOptions = {};
+    if (this._restoreIdentifier) {
+      managerOptions.restoreStateIdentifier = this._restoreIdentifier;
+      managerOptions.restoreStateFunction = (restoredState) => {
+        // Re-populate devices from restored state
+        if (restoredState && restoredState.connectedPeripherals) {
+          for (const peripheral of restoredState.connectedPeripherals) {
+            this._devices.set(peripheral.id, peripheral);
+          }
+        }
+      };
+    }
+    this._manager = new this._BleManager(managerOptions);
 
     // Subscribe to state changes
     this._stateSubscription = this._manager.onStateChange((state) => {
@@ -187,6 +213,19 @@ class RNBLEAdapter extends BLEAdapter {
     // Monitor disconnection
     device.onDisconnected(() => {
       this._devices.delete(deviceId);
+
+      // Clean up subscriptions for this device
+      for (const [key, subscription] of this._subscriptions.entries()) {
+        if (key.startsWith(`${deviceId}:`)) {
+          subscription.remove();
+          this._subscriptions.delete(key);
+        }
+      }
+
+      // Notify transport
+      if (this._disconnectCallback) {
+        this._disconnectCallback(deviceId);
+      }
     });
 
     return {
@@ -202,6 +241,14 @@ class RNBLEAdapter extends BLEAdapter {
    * @returns {Promise<void>}
    */
   async disconnect(deviceId) {
+    // Clean up subscriptions first
+    for (const [key, subscription] of this._subscriptions.entries()) {
+      if (key.startsWith(`${deviceId}:`)) {
+        subscription.remove();
+        this._subscriptions.delete(key);
+      }
+    }
+
     const device = this._devices.get(deviceId);
     if (device) {
       await this._manager.cancelDeviceConnection(deviceId);
@@ -284,6 +331,14 @@ class RNBLEAdapter extends BLEAdapter {
     return stateMap[state] || BLEAdapter.STATE.UNKNOWN;
   }
 
+  /**
+   * Registers a callback for device disconnection events
+   * @param {Function} callback - Callback function receiving peerId
+   */
+  onDeviceDisconnected(callback) {
+    this._disconnectCallback = callback;
+  }
+
   /**
    * Ensures the adapter is initialized
    * @throws {Error} If not initialized

package/src/transport/index.js

@@ -8,6 +8,8 @@
 const Transport = require('./Transport');
 const MockTransport = require('./MockTransport');
 const BLETransport = require('./BLETransport');
+const { WiFiDirectTransport, WIFI_DIRECT_STATE } = require('./WiFiDirectTransport');
+const { MultiTransport, STRATEGY: MULTI_TRANSPORT_STRATEGY } = require('./MultiTransport');
 
 // React Native compatible adapters (from adapters subdirectory)
 const BLEAdapter = require('./adapters/BLEAdapter');
@@ -17,6 +19,10 @@ module.exports = {
   Transport,
   MockTransport,
   BLETransport,
+  WiFiDirectTransport,
+  WIFI_DIRECT_STATE,
+  MultiTransport,
+  MULTI_TRANSPORT_STRATEGY,
   BLEAdapter,
   RNBLEAdapter,
 

package/src/utils/EventEmitter.js

@@ -116,10 +116,11 @@ class EventEmitter {
       return false;
     }
 
-    const listeners = this._events.get(event).slice();
-    const toRemove = [];
+    const listeners = this._events.get(event);
+    const hasOnce = listeners.some(e => e.once);
+    const iterList = hasOnce ? listeners.slice() : listeners;
 
-    for (const entry of listeners) {
+    for (const entry of iterList) {
       try {
         entry.listener.apply(this, args);
       } catch (error) {
@@ -130,15 +131,11 @@ class EventEmitter {
           console.error('Error in error handler:', error);
         }
       }
-
-      if (entry.once) {
-        toRemove.push(entry);
-      }
     }
 
     // Remove one-time listeners
-    if (toRemove.length > 0) {
-      const remaining = this._events.get(event).filter(e => !toRemove.includes(e));
+    if (hasOnce) {
+      const remaining = listeners.filter(e => !e.once);
       if (remaining.length === 0) {
         this._events.delete(event);
       } else {

package/src/utils/bytes.js

@@ -11,9 +11,16 @@
  * @returns {Uint8Array} Concatenated array
  */
 function concat(...arrays) {
-  // Filter out undefined/null and calculate total length
-  const validArrays = arrays.filter(arr => arr !== null && arr !== undefined);
-  const totalLength = validArrays.reduce((sum, arr) => sum + arr.length, 0);
+  // Single-pass: filter out undefined/null and calculate total length
+  const validArrays = [];
+  let totalLength = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const arr = arrays[i];
+    if (arr !== null && arr !== undefined) {
+      validArrays.push(arr);
+      totalLength += arr.length;
+    }
+  }
 
   const result = new Uint8Array(totalLength);
   let offset = 0;
@@ -119,10 +126,7 @@ function xor(a, b) {
  * @returns {Uint8Array} The filled array (same reference)
  */
 function fill(array, value) {
-  const byte = value & 0xff;
-  for (let i = 0; i < array.length; i++) {
-    array[i] = byte;
-  }
+  array.fill(value & 0xff);
   return array;
 }
 
@@ -132,9 +136,7 @@ function fill(array, value) {
  * @returns {Uint8Array} Copy of the array
  */
 function copy(array) {
-  const result = new Uint8Array(array.length);
-  result.set(array);
-  return result;
+  return array.slice();
 }
 
 /**