react-native-ble-mesh 1.1.1 → 2.1.0

package/src/errors/MeshError.js

@@ -20,7 +20,8 @@ class MeshError extends Error {
    * @param {Object|null} [details=null] - Additional error context
    */
   constructor(message, code = 'E900', details = null) {
-    super(message);
+    const className = new.target ? new.target.name : 'MeshError';
+    super(`${className}: ${message}`);
 
     /**
      * Error name

package/src/expo/withBLEMesh.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * @fileoverview Expo config plugin for react-native-ble-mesh
+ * @module expo/withBLEMesh
+ *
+ * Automatically configures BLE permissions and background modes
+ * for iOS and Android when used with Expo.
+ *
+ * Usage in app.json:
+ * {
+ *   "expo": {
+ *     "plugins": [
+ *       ["react-native-ble-mesh", {
+ *         "bluetoothAlwaysPermission": "Chat with nearby devices via Bluetooth",
+ *         "backgroundModes": ["bluetooth-central", "bluetooth-peripheral"]
+ *       }]
+ *     ]
+ *   }
+ * }
+ */
+
+/**
+ * Default configuration
+ * @constant {Object}
+ */
+const DEFAULT_OPTIONS = {
+  /** iOS NSBluetoothAlwaysUsageDescription */
+  bluetoothAlwaysPermission: 'This app uses Bluetooth to communicate with nearby devices',
+  /** iOS UIBackgroundModes */
+  backgroundModes: ['bluetooth-central', 'bluetooth-peripheral'],
+  /** Android permissions */
+  androidPermissions: [
+    'android.permission.BLUETOOTH_SCAN',
+    'android.permission.BLUETOOTH_CONNECT',
+    'android.permission.BLUETOOTH_ADVERTISE',
+    'android.permission.ACCESS_FINE_LOCATION'
+  ]
+};
+
+/**
+ * Modifies the iOS Info.plist for BLE permissions.
+ * @param {Object} config - Expo config
+ * @param {Object} options - Plugin options
+ * @returns {Object} Modified config
+ */
+function withBLEMeshIOS(config, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+
+  if (!config.ios) { config.ios = {}; }
+  if (!config.ios.infoPlist) { config.ios.infoPlist = {}; }
+
+  // Add Bluetooth usage description
+  config.ios.infoPlist.NSBluetoothAlwaysUsageDescription = opts.bluetoothAlwaysPermission;
+  config.ios.infoPlist.NSBluetoothPeripheralUsageDescription = opts.bluetoothAlwaysPermission;
+
+  // Add background modes
+  const existingModes = config.ios.infoPlist.UIBackgroundModes || [];
+  const newModes = new Set([...existingModes, ...opts.backgroundModes]);
+  config.ios.infoPlist.UIBackgroundModes = Array.from(newModes);
+
+  return config;
+}
+
+/**
+ * Modifies the Android manifest for BLE permissions.
+ * @param {Object} config - Expo config
+ * @param {Object} options - Plugin options
+ * @returns {Object} Modified config
+ */
+function withBLEMeshAndroid(config, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+
+  if (!config.android) { config.android = {}; }
+  if (!config.android.permissions) { config.android.permissions = []; }
+
+  // Add BLE permissions (avoid duplicates)
+  const existingPerms = new Set(config.android.permissions);
+  for (const perm of opts.androidPermissions) {
+    existingPerms.add(perm);
+  }
+  config.android.permissions = Array.from(existingPerms);
+
+  return config;
+}
+
+/**
+ * Main Expo config plugin.
+ * @param {Object} config - Expo config
+ * @param {Object} [options={}] - Plugin options
+ * @returns {Object} Modified config
+ */
+function withBLEMesh(config, options = {}) {
+  config = withBLEMeshIOS(config, options);
+  config = withBLEMeshAndroid(config, options);
+  return config;
+}
+
+module.exports = withBLEMesh;
+module.exports.withBLEMeshIOS = withBLEMeshIOS;
+module.exports.withBLEMeshAndroid = withBLEMeshAndroid;
+module.exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;

package/src/hooks/AppStateManager.js

@@ -45,6 +45,8 @@ class AppStateManager {
     this._initialized = false;
     /** @private */
     this._AppState = null;
+    /** @private */
+    this._boundHandleStateChange = this._handleStateChange.bind(this);
   }
 
   /**
@@ -64,9 +66,15 @@ class AppStateManager {
       return false;
     }
 
+    // Remove old subscription before creating new one
+    if (this._subscription) {
+      this._subscription.remove();
+      this._subscription = null;
+    }
+
     this._subscription = this._AppState.addEventListener(
       'change',
-      this._handleStateChange.bind(this)
+      this._boundHandleStateChange
     );
 
     this._initialized = true;

package/src/hooks/useMesh.js

@@ -46,6 +46,9 @@ function useMesh(config = {}) {
 
   // Create mesh instance ref (persists across renders)
   const meshRef = useRef(null);
+  const mountedRef = useRef(true);
+  const stateHandlerRef = useRef(null);
+  const errorHandlerRef = useRef(null);
 
   // State
   const [state, setState] = useState('uninitialized');
@@ -64,19 +67,35 @@ function useMesh(config = {}) {
   // Initialize mesh
   const initialize = useCallback(async (transport) => {
     try {
+      if (!mountedRef.current) { return; }
       setState('initializing');
       setError(null);
 
       const mesh = getMesh();
 
+      // Remove old listeners if they exist (prevents accumulation on re-init)
+      if (stateHandlerRef.current) {
+        mesh.off('state-changed', stateHandlerRef.current);
+      }
+      if (errorHandlerRef.current) {
+        mesh.off('error', errorHandlerRef.current);
+      }
+
       // Setup state change listener
-      mesh.on('state-changed', ({ newState }) => {
-        setState(newState);
-      });
+      stateHandlerRef.current = ({ newState }) => {
+        if (mountedRef.current) {
+          setState(newState);
+        }
+      };
 
-      mesh.on('error', (err) => {
-        setError(err);
-      });
+      errorHandlerRef.current = (err) => {
+        if (mountedRef.current) {
+          setError(err);
+        }
+      };
+
+      mesh.on('state-changed', stateHandlerRef.current);
+      mesh.on('error', errorHandlerRef.current);
 
       // Initialize with storage
       await mesh.initialize({
@@ -90,8 +109,10 @@ function useMesh(config = {}) {
 
       return mesh;
     } catch (err) {
-      setState('error');
-      setError(err);
+      if (mountedRef.current) {
+        setState('error');
+        setError(err);
+      }
       throw err;
     }
   }, [getMesh, config.storage]);
@@ -102,7 +123,9 @@ function useMesh(config = {}) {
     try {
       await mesh.start(transport);
     } catch (err) {
-      setError(err);
+      if (mountedRef.current) {
+        setError(err);
+      }
       throw err;
     }
   }, [getMesh]);
@@ -114,7 +137,9 @@ function useMesh(config = {}) {
       try {
         await mesh.stop();
       } catch (err) {
-        setError(err);
+        if (mountedRef.current) {
+          setError(err);
+        }
       }
     }
   }, []);
@@ -129,16 +154,25 @@ function useMesh(config = {}) {
         // Ignore destroy errors
       }
       meshRef.current = null;
-      setState('destroyed');
+      if (mountedRef.current) {
+        setState('destroyed');
+      }
     }
   }, []);
 
   // Cleanup on unmount
   useEffect(() => {
     return () => {
+      // Immediately mark as unmounted to prevent state updates
+      mountedRef.current = false;
+
       if (meshRef.current) {
-        meshRef.current.destroy().catch(() => {});
-        meshRef.current = null;
+        const mesh = meshRef.current;
+        meshRef.current = null; // Null ref immediately to prevent new operations
+
+        mesh.destroy().catch(() => {
+          // Ignore cleanup errors
+        });
       }
     };
   }, []);

package/src/hooks/useMessages.js

@@ -58,11 +58,11 @@ function useMessages(mesh, options = {}) {
 
     setMessages(prev => {
       const updated = [msg, ...prev];
-      // Trim to max messages
       if (updated.length > maxMessages) {
-        const removed = updated.slice(maxMessages);
-        removed.forEach(m => messageIdRef.current.delete(m.id));
-        return updated.slice(0, maxMessages);
+        for (let i = maxMessages; i < updated.length; i++) {
+          messageIdRef.current.delete(updated[i].id);
+        }
+        updated.length = maxMessages;
       }
       return updated;
     });
@@ -114,6 +114,8 @@ function useMessages(mesh, options = {}) {
       mesh.off('broadcast-received', handleBroadcast);
       mesh.off('private-message-received', handlePrivate);
       mesh.off('channel-message-received', handleChannel);
+      // Clear dedup Set on unmount
+      messageIdRef.current.clear();
     };
   }, [mesh, addMessage]);
 

package/src/hooks/usePeers.js

@@ -35,18 +35,23 @@ function usePeers(mesh) {
     throw new Error('usePeers requires React. Install react as a dependency.');
   }
 
-  const { useState, useEffect, useCallback, useMemo } = React;
+  const { useState, useEffect, useCallback, useMemo, useRef } = React;
 
   const [peers, setPeers] = useState([]);
-  const [lastUpdate, setLastUpdate] = useState(Date.now());
+  const lastUpdateRef = useRef(Date.now());
 
   // Update peers from mesh
   const refreshPeers = useCallback(() => {
     if (mesh) {
       try {
         const allPeers = mesh.getPeers();
-        setPeers(allPeers);
-        setLastUpdate(Date.now());
+        setPeers(prev => {
+          if (prev.length === allPeers.length && prev.every((p, i) => p.id === allPeers[i]?.id && p.connectionState === allPeers[i]?.connectionState)) {
+            return prev;
+          }
+          return allPeers;
+        });
+        lastUpdateRef.current = Date.now();
       } catch (e) {
         // Mesh might not be ready
       }
@@ -84,10 +89,9 @@ function usePeers(mesh) {
     return peers.filter(p => p.connectionState === 'secured');
   }, [peers]);
 
-  // Get single peer by ID
-  const getPeer = useCallback((peerId) => {
-    return peers.find(p => p.id === peerId);
-  }, [peers]);
+  // Get single peer by ID (O(1) lookup via peerMap)
+  const peerMap = useMemo(() => new Map(peers.map(p => [p.id, p])), [peers]);
+  const getPeer = useCallback((peerId) => peerMap.get(peerId), [peerMap]);
 
   // Check if peer is connected
   const isConnected = useCallback((peerId) => {
@@ -104,7 +108,7 @@ function usePeers(mesh) {
     getPeer,
     isConnected,
     refresh: refreshPeers,
-    lastUpdate
+    lastUpdate: lastUpdateRef.current
   };
 }
 

package/src/index.js

@@ -2,8 +2,8 @@
  * @fileoverview BLE Mesh Network Library
  * @module rn-ble-mesh
  * @description Production-ready BLE Mesh Network with Noise Protocol security
- * 
- * This is the definitive React Native library for BitChat-compatible 
+ *
+ * This is the definitive React Native library for BitChat-compatible
  * decentralized mesh networking.
  */
 
@@ -16,9 +16,7 @@ const { MeshNetwork, BATTERY_MODE, PANIC_TRIGGER, HEALTH_STATUS } = require('./M
 const {
   MeshService,
   EmergencyManager,
-  BatteryOptimizer,
-  SessionManager,
-  HandshakeManager,
+  BatteryOptimizer
 } = require('./service');
 
 // Constants
@@ -27,7 +25,7 @@ const constants = require('./constants');
 // Errors
 const errors = require('./errors');
 
-// Crypto
+// Crypto — pluggable provider system (tweetnacl / quick-crypto / expo-crypto)
 const crypto = require('./crypto');
 
 // Protocol
@@ -51,6 +49,10 @@ const audio = require('./service/audio');
 // Text (from service module)
 const text = require('./service/text');
 
+// File transfer
+const file = require('./service/file');
+const { FileManager, FileChunker, FileAssembler, FileMessage, FILE_MESSAGE_TYPE, FILE_TRANSFER_STATE } = file;
+
 // React Native hooks
 const hooks = require('./hooks');
 
@@ -133,7 +135,7 @@ const { useMesh, usePeers, useMessages, AppStateManager } = hooks;
 
 // New PRD-specified components
 const { StoreAndForwardManager } = mesh;
-const { NetworkMonitor } = mesh;
+const { NetworkMonitor, ConnectionQuality, QUALITY_LEVEL } = mesh;
 const { MessageCompressor, compress, decompress } = utils;
 
 module.exports = {
@@ -156,6 +158,10 @@ module.exports = {
   // Store and Forward
   StoreAndForwardManager,
 
+  // Connection Quality
+  ConnectionQuality,
+  QUALITY_LEVEL,
+
   // Compression
   MessageCompressor,
   compress,
@@ -186,7 +192,7 @@ module.exports = {
   // Errors
   ...errors,
 
-  // Crypto primitives and Noise Protocol
+  // Crypto provider system
   crypto,
 
   // Protocol serialization
@@ -229,6 +235,15 @@ module.exports = {
   useMessages,
   AppStateManager,
 
+  // File transfer
+  FileManager,
+  FileChunker,
+  FileAssembler,
+  FileMessage,
+  FILE_MESSAGE_TYPE,
+  FILE_TRANSFER_STATE,
+  file,
+
   // Hooks module
   hooks
 };

package/src/mesh/dedup/BloomFilter.js

@@ -13,6 +13,15 @@
 const FNV_PRIME = 0x01000193;
 const FNV_OFFSET = 0x811c9dc5;
 
+// Cached TextEncoder singleton (avoids per-call allocation)
+let _encoder = null;
+function _getEncoder() {
+  if (!_encoder && typeof TextEncoder !== 'undefined') {
+    _encoder = new TextEncoder();
+  }
+  return _encoder;
+}
+
 /**
  * Bloom filter for probabilistic set membership testing
  * @class BloomFilter
@@ -56,6 +65,13 @@ class BloomFilter {
      * @private
      */
     this._count = 0;
+
+    /**
+     * Running count of set bits (avoids O(n) scan in getFillRatio)
+     * @type {number}
+     * @private
+     */
+    this._setBitCount = 0;
   }
 
   /**
@@ -90,72 +106,50 @@ class BloomFilter {
       return item;
     }
     if (typeof item === 'string') {
-      const encoder = new TextEncoder();
-      return encoder.encode(item);
+      const encoder = _getEncoder();
+      if (encoder) {
+        return encoder.encode(item);
+      }
+      // Fallback for environments without TextEncoder
+      const bytes = new Uint8Array(item.length);
+      for (let i = 0; i < item.length; i++) {
+        bytes[i] = item.charCodeAt(i) & 0xff;
+      }
+      return bytes;
     }
     throw new Error('Item must be string or Uint8Array');
   }
 
-  /**
-   * Computes hash positions for an item
-   * @param {string|Uint8Array} item - Item to hash
-   * @returns {number[]} Array of bit positions
-   * @private
-   */
-  _getPositions(item) {
-    const data = this._toBytes(item);
-    const positions = [];
-    for (let i = 0; i < this.hashCount; i++) {
-      const hash = this._fnv1a(data, i);
-      positions.push(hash % this.size);
-    }
-    return positions;
-  }
-
-  /**
-   * Sets a bit at the given position
-   * @param {number} position - Bit position
-   * @private
-   */
-  _setBit(position) {
-    const byteIndex = Math.floor(position / 8);
-    const bitIndex = position % 8;
-    this._bits[byteIndex] |= (1 << bitIndex);
-  }
-
-  /**
-   * Gets a bit at the given position
-   * @param {number} position - Bit position
-   * @returns {boolean} True if bit is set
-   * @private
-   */
-  _getBit(position) {
-    const byteIndex = Math.floor(position / 8);
-    const bitIndex = position % 8;
-    return (this._bits[byteIndex] & (1 << bitIndex)) !== 0;
-  }
-
   /**
    * Adds an item to the filter
+   * Inlined position computation to avoid intermediate array allocation
    * @param {string|Uint8Array} item - Item to add
    */
   add(item) {
-    const positions = this._getPositions(item);
-    for (const pos of positions) {
-      this._setBit(pos);
+    const data = this._toBytes(item);
+    for (let i = 0; i < this.hashCount; i++) {
+      const pos = this._fnv1a(data, i) % this.size;
+      const byteIndex = pos >> 3;
+      const mask = 1 << (pos & 7);
+      if (!(this._bits[byteIndex] & mask)) {
+        this._bits[byteIndex] |= mask;
+        this._setBitCount++;
+      }
     }
     this._count++;
   }
 
   /**
    * Tests if an item might be in the filter
+   * Inlined position computation to avoid intermediate array allocation
    * @param {string|Uint8Array} item - Item to test
    * @returns {boolean} True if item might be present, false if definitely absent
    */
   mightContain(item) {
-    const positions = this._getPositions(item);
-    for (const pos of positions) {
-      if (!this._getBit(pos)) {
+    const data = this._toBytes(item);
+    for (let i = 0; i < this.hashCount; i++) {
+      const pos = this._fnv1a(data, i) % this.size;
+      if (!(this._bits[pos >> 3] & (1 << (pos & 7)))) {
         return false;
       }
     }
@@ -168,22 +162,15 @@ class BloomFilter {
   clear() {
     this._bits.fill(0);
     this._count = 0;
+    this._setBitCount = 0;
   }
 
   /**
-   * Gets the fill ratio of the filter
+   * Gets the fill ratio of the filter (O(1) using running count)
    * @returns {number} Ratio of set bits to total bits (0-1)
    */
   getFillRatio() {
-    let setBits = 0;
-    for (let i = 0; i < this._bits.length; i++) {
-      let byte = this._bits[i];
-      while (byte) {
-        setBits += byte & 1;
-        byte >>>= 1;
-      }
-    }
-    return setBits / this.size;
+    return this._setBitCount / this.size;
   }
 
   /**

package/src/mesh/dedup/DedupManager.js

@@ -55,6 +55,13 @@ class DedupManager {
      */
     this._cache = new MessageCache(config.cacheSize);
 
+    /**
+     * Old Bloom filter kept during grace period after reset
+     * @type {BloomFilter|null}
+     * @private
+     */
+    this._oldBloomFilter = null;
+
     /**
      * Auto-reset threshold for Bloom filter
      * @type {number}
@@ -62,6 +69,13 @@ class DedupManager {
      */
     this._autoResetThreshold = config.autoResetThreshold;
 
+    /**
+     * Grace period timer ID for bloom filter reset
+     * @type {ReturnType<typeof setTimeout>|null}
+     * @private
+     */
+    this._graceTimer = null;
+
     /**
      * Statistics for monitoring
      * @type {Object}
@@ -85,20 +99,25 @@ class DedupManager {
   isDuplicate(messageId) {
     this._stats.checks++;
 
-    // Quick check with Bloom filter
-    if (!this._bloomFilter.mightContain(messageId)) {
-      return false;
-    }
-    this._stats.bloomPositives++;
-
-    // Confirm with exact cache lookup (handles false positives)
+    // Check cache first (most accurate)
     if (this._cache.has(messageId)) {
       this._stats.cacheHits++;
       this._stats.duplicates++;
       return true;
     }
 
-    // Bloom filter false positive
+    // Check current bloom filter
+    if (this._bloomFilter.mightContain(messageId)) {
+      this._stats.bloomPositives++;
+      return true;
+    }
+
+    // Check old bloom filter if in grace period
+    if (this._oldBloomFilter && this._oldBloomFilter.mightContain(messageId)) {
+      this._stats.bloomPositives++;
+      return true;
+    }
+
     return false;
   }
 
@@ -135,20 +154,45 @@ class DedupManager {
    * @private
    */
   _resetBloomFilter() {
-    this._bloomFilter.clear();
+    // Create a new bloom filter instead of clearing the old one
+    // Keep the old filter active for checking during transition
+    const oldFilter = this._bloomFilter;
+    this._bloomFilter = new BloomFilter(
+      oldFilter.size || MESH_CONFIG.BLOOM_FILTER_SIZE,
+      oldFilter.hashCount || MESH_CONFIG.BLOOM_HASH_COUNT
+    );
     this._stats.resets++;
 
-    // Re-add all cached entries to Bloom filter
+    // Re-add all cached entries to new filter
     const entries = this._cache.getAll();
     for (const messageId of entries) {
       this._bloomFilter.add(messageId);
     }
+
+    // Keep old filter for a grace period by checking both
+    this._oldBloomFilter = oldFilter;
+
+    // Clear any existing grace timer before starting a new one
+    if (this._graceTimer) {
+      clearTimeout(this._graceTimer);
+    }
+
+    // Clear old filter after grace period
+    this._graceTimer = setTimeout(() => {
+      this._oldBloomFilter = null;
+      this._graceTimer = null;
+    }, 60000); // 1 minute grace
   }
 
   /**
    * Resets both the Bloom filter and cache
    */
   reset() {
+    if (this._graceTimer) {
+      clearTimeout(this._graceTimer);
+      this._graceTimer = null;
+    }
+    this._oldBloomFilter = null;
     this._bloomFilter.clear();
     this._cache.clear();
     this._stats.resets++;
@@ -207,6 +251,19 @@ class DedupManager {
   getSeenTimestamp(messageId) {
     return this._cache.getTimestamp(messageId);
   }
+
+  /**
+   * Destroys the dedup manager and cleans up resources
+   */
+  destroy() {
+    if (this._graceTimer) {
+      clearTimeout(this._graceTimer);
+      this._graceTimer = null;
+    }
+    this._oldBloomFilter = null;
+    this._bloomFilter.clear();
+    this._cache.clear();
+  }
 }
 
 module.exports = DedupManager;