react-native-ble-mesh 1.0.1

package/src/transport/adapters/RNBLEAdapter.js

@@ -0,0 +1,328 @@
+'use strict';
+
+/**
+ * @fileoverview React Native BLE adapter using react-native-ble-plx
+ * @module transport/adapters/RNBLEAdapter
+ */
+
+const BLEAdapter = require('./BLEAdapter');
+
+/**
+ * React Native BLE adapter implementation.
+ * Wraps react-native-ble-plx for BLE communication in React Native apps.
+ *
+ * NOTE: react-native-ble-plx is an optional peer dependency.
+ * Install it separately: npm install react-native-ble-plx
+ *
+ * @class RNBLEAdapter
+ * @extends BLEAdapter
+ */
+class RNBLEAdapter extends BLEAdapter {
+  /**
+   * Creates a new RNBLEAdapter instance
+   * @param {Object} [options={}] - Adapter options
+   * @param {Object} [options.BleManager] - BleManager class from react-native-ble-plx
+   */
+  constructor(options = {}) {
+    super(options);
+
+    /**
+     * BleManager instance
+     * @type {Object|null}
+     * @private
+     */
+    this._manager = null;
+
+    /**
+     * BleManager class reference
+     * @type {Function|null}
+     * @private
+     */
+    this._BleManager = options.BleManager || null;
+
+    /**
+     * Connected devices map
+     * @type {Map<string, Object>}
+     * @private
+     */
+    this._devices = new Map();
+
+    /**
+     * Subscription handlers map
+     * @type {Map<string, Object>}
+     * @private
+     */
+    this._subscriptions = new Map();
+
+    /**
+     * Scan subscription reference
+     * @type {Object|null}
+     * @private
+     */
+    this._scanSubscription = null;
+
+    /**
+     * State subscription reference
+     * @type {Object|null}
+     * @private
+     */
+    this._stateSubscription = null;
+  }
+
+  /**
+   * Initializes the BLE manager
+   * @returns {Promise<void>}
+   * @throws {Error} If react-native-ble-plx is not available
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+
+    // Try to load BleManager if not provided
+    if (!this._BleManager) {
+      try {
+        const blePlx = require('react-native-ble-plx');
+        this._BleManager = blePlx.BleManager;
+      } catch (error) {
+        throw new Error(
+          'react-native-ble-plx is required. Install with: npm install react-native-ble-plx'
+        );
+      }
+    }
+
+    this._manager = new this._BleManager();
+
+    // Subscribe to state changes
+    this._stateSubscription = this._manager.onStateChange((state) => {
+      this._notifyStateChange(this._mapState(state));
+    }, true);
+
+    this._initialized = true;
+  }
+
+  /**
+   * Destroys the BLE manager and releases resources
+   * @returns {Promise<void>}
+   */
+  async destroy() {
+    if (!this._initialized) {
+      return;
+    }
+
+    // Cancel all subscriptions
+    for (const subscription of this._subscriptions.values()) {
+      subscription.remove();
+    }
+    this._subscriptions.clear();
+
+    // Stop scanning
+    this.stopScan();
+
+    // Remove state subscription
+    if (this._stateSubscription) {
+      this._stateSubscription.remove();
+      this._stateSubscription = null;
+    }
+
+    // Disconnect all devices
+    for (const deviceId of this._devices.keys()) {
+      await this.disconnect(deviceId);
+    }
+
+    // Destroy manager
+    if (this._manager) {
+      this._manager.destroy();
+      this._manager = null;
+    }
+
+    this._initialized = false;
+  }
+
+  /**
+   * Starts scanning for BLE devices
+   * @param {string[]} serviceUUIDs - Service UUIDs to filter by
+   * @param {Function} callback - Callback for discovered devices
+   * @returns {Promise<void>}
+   */
+  async startScan(serviceUUIDs, callback) {
+    this._ensureInitialized();
+
+    this._manager.startDeviceScan(serviceUUIDs, null, (error, device) => {
+      if (error) {
+        return;
+      }
+      if (device) {
+        callback({
+          id: device.id,
+          name: device.name || device.localName,
+          rssi: device.rssi
+        });
+      }
+    });
+  }
+
+  /**
+   * Stops scanning for BLE devices
+   */
+  stopScan() {
+    if (this._manager) {
+      this._manager.stopDeviceScan();
+    }
+  }
+
+  /**
+   * Connects to a BLE device
+   * @param {string} deviceId - Device ID to connect to
+   * @returns {Promise<Object>} Connected device info
+   */
+  async connect(deviceId) {
+    this._ensureInitialized();
+
+    const device = await this._manager.connectToDevice(deviceId);
+    await device.discoverAllServicesAndCharacteristics();
+
+    this._devices.set(deviceId, device);
+
+    // Monitor disconnection
+    device.onDisconnected(() => {
+      this._devices.delete(deviceId);
+    });
+
+    return {
+      id: device.id,
+      name: device.name,
+      rssi: device.rssi
+    };
+  }
+
+  /**
+   * Disconnects from a BLE device
+   * @param {string} deviceId - Device ID to disconnect from
+   * @returns {Promise<void>}
+   */
+  async disconnect(deviceId) {
+    const device = this._devices.get(deviceId);
+    if (device) {
+      await this._manager.cancelDeviceConnection(deviceId);
+      this._devices.delete(deviceId);
+    }
+  }
+
+  /**
+   * Writes data to a characteristic
+   * @param {string} deviceId - Target device ID
+   * @param {string} serviceUUID - Service UUID
+   * @param {string} charUUID - Characteristic UUID
+   * @param {Uint8Array} data - Data to write
+   * @returns {Promise<void>}
+   */
+  async write(deviceId, serviceUUID, charUUID, data) {
+    this._ensureInitialized();
+
+    const base64Data = this._uint8ArrayToBase64(data);
+    await this._manager.writeCharacteristicWithResponseForDevice(
+      deviceId,
+      serviceUUID,
+      charUUID,
+      base64Data
+    );
+  }
+
+  /**
+   * Subscribes to characteristic notifications
+   * @param {string} deviceId - Target device ID
+   * @param {string} serviceUUID - Service UUID
+   * @param {string} charUUID - Characteristic UUID
+   * @param {Function} callback - Notification callback
+   * @returns {Promise<void>}
+   */
+  async subscribe(deviceId, serviceUUID, charUUID, callback) {
+    this._ensureInitialized();
+
+    const key = `${deviceId}:${serviceUUID}:${charUUID}`;
+    const subscription = this._manager.monitorCharacteristicForDevice(
+      deviceId,
+      serviceUUID,
+      charUUID,
+      (error, characteristic) => {
+        if (!error && characteristic) {
+          const data = this._base64ToUint8Array(characteristic.value);
+          callback(data);
+        }
+      }
+    );
+
+    this._subscriptions.set(key, subscription);
+  }
+
+  /**
+   * Gets the current Bluetooth state
+   * @returns {Promise<string>} Bluetooth state
+   */
+  async getState() {
+    this._ensureInitialized();
+    const state = await this._manager.state();
+    return this._mapState(state);
+  }
+
+  /**
+   * Maps react-native-ble-plx state to BLEAdapter state
+   * @param {string} state - RN BLE state
+   * @returns {string} Mapped state
+   * @private
+   */
+  _mapState(state) {
+    const stateMap = {
+      Unknown: BLEAdapter.STATE.UNKNOWN,
+      Resetting: BLEAdapter.STATE.RESETTING,
+      Unsupported: BLEAdapter.STATE.UNSUPPORTED,
+      Unauthorized: BLEAdapter.STATE.UNAUTHORIZED,
+      PoweredOff: BLEAdapter.STATE.POWERED_OFF,
+      PoweredOn: BLEAdapter.STATE.POWERED_ON
+    };
+    return stateMap[state] || BLEAdapter.STATE.UNKNOWN;
+  }
+
+  /**
+   * Ensures the adapter is initialized
+   * @throws {Error} If not initialized
+   * @private
+   */
+  _ensureInitialized() {
+    if (!this._initialized) {
+      throw new Error('RNBLEAdapter is not initialized');
+    }
+  }
+
+  /**
+   * Converts Uint8Array to Base64 string
+   * @param {Uint8Array} bytes - Bytes to convert
+   * @returns {string} Base64 string
+   * @private
+   */
+  _uint8ArrayToBase64(bytes) {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+
+  /**
+   * Converts Base64 string to Uint8Array
+   * @param {string} base64 - Base64 string
+   * @returns {Uint8Array} Byte array
+   * @private
+   */
+  _base64ToUint8Array(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+}
+
+module.exports = RNBLEAdapter;

package/src/transport/adapters/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * @fileoverview BLE adapter exports
+ * @module transport/adapters
+ */
+
+const BLEAdapter = require('./BLEAdapter');
+const RNBLEAdapter = require('./RNBLEAdapter');
+const NodeBLEAdapter = require('./NodeBLEAdapter');
+
+module.exports = {
+  BLEAdapter,
+  RNBLEAdapter,
+  NodeBLEAdapter
+};

package/src/transport/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * @fileoverview Transport module exports
+ * @module transport
+ */
+
+const Transport = require('./Transport');
+const MockTransport = require('./MockTransport');
+const BLETransport = require('./BLETransport');
+
+// Adapters (now flat in transport folder)
+const BLEAdapter = require('./BLEAdapter');
+const RNBLEAdapter = require('./RNBLEAdapter');
+const NodeBLEAdapter = require('./NodeBLEAdapter');
+
+// Legacy: keep adapters object for backward compatibility
+const adapters = require('./adapters');
+
+module.exports = {
+  // Core transports
+  Transport,
+  MockTransport,
+  BLETransport,
+
+  // Adapters (flat exports for easy imports)
+  BLEAdapter,
+  RNBLEAdapter,
+  NodeBLEAdapter,
+
+  // Legacy adapters namespace
+  adapters
+};

package/src/utils/BoundedMap.js

@@ -0,0 +1,151 @@
+'use strict';
+
+/**
+ * @fileoverview Map with maximum size and LRU eviction
+ * @module utils/BoundedMap
+ */
+
+/**
+ * Map with maximum size limit and LRU eviction policy
+ * When the map exceeds maxSize, the least recently used entry is removed.
+ *
+ * @class BoundedMap
+ * @template K, V
+ * @example
+ * const cache = new BoundedMap(100);
+ * cache.set('key1', 'value1');
+ * const value = cache.get('key1'); // Marks as recently used
+ */
+class BoundedMap {
+  /**
+   * Creates a new BoundedMap
+   * @param {number} [maxSize=1000] - Maximum number of entries
+   */
+  constructor(maxSize = 1000) {
+    if (typeof maxSize !== 'number' || maxSize < 1) {
+      throw new Error('maxSize must be a positive number');
+    }
+    /** @private */
+    this._maxSize = maxSize;
+    /** @private */
+    this._map = new Map();
+  }
+
+  /**
+   * Get the value for a key (marks as recently used)
+   * @param {K} key - The key to look up
+   * @returns {V|undefined} The value or undefined
+   */
+  get(key) {
+    if (!this._map.has(key)) {
+      return undefined;
+    }
+    // Move to end (most recently used)
+    const value = this._map.get(key);
+    this._map.delete(key);
+    this._map.set(key, value);
+    return value;
+  }
+
+  /**
+   * Set a key-value pair (evicts LRU if at capacity)
+   * @param {K} key - The key
+   * @param {V} value - The value
+   * @returns {BoundedMap} This instance for chaining
+   */
+  set(key, value) {
+    // If key exists, delete it first to update position
+    if (this._map.has(key)) {
+      this._map.delete(key);
+    } else if (this._map.size >= this._maxSize) {
+      // Evict least recently used (first entry)
+      const firstKey = this._map.keys().next().value;
+      this._map.delete(firstKey);
+    }
+    this._map.set(key, value);
+    return this;
+  }
+
+  /**
+   * Check if key exists
+   * @param {K} key - The key to check
+   * @returns {boolean} True if key exists
+   */
+  has(key) {
+    return this._map.has(key);
+  }
+
+  /**
+   * Delete a key
+   * @param {K} key - The key to delete
+   * @returns {boolean} True if key was deleted
+   */
+  delete(key) {
+    return this._map.delete(key);
+  }
+
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this._map.clear();
+  }
+
+  /**
+   * Get the number of entries
+   * @returns {number} Number of entries
+   */
+  get size() {
+    return this._map.size;
+  }
+
+  /**
+   * Get the maximum size
+   * @returns {number} Maximum size
+   */
+  get maxSize() {
+    return this._maxSize;
+  }
+
+  /**
+   * Get all keys
+   * @returns {IterableIterator<K>} Iterator of keys
+   */
+  keys() {
+    return this._map.keys();
+  }
+
+  /**
+   * Get all values
+   * @returns {IterableIterator<V>} Iterator of values
+   */
+  values() {
+    return this._map.values();
+  }
+
+  /**
+   * Get all entries
+   * @returns {Iterator} Iterator of [key, value] pairs
+   */
+  entries() {
+    return this._map.entries();
+  }
+
+  /**
+   * Iterate over entries
+   * @param {function(V, K, BoundedMap): void} callback - Callback function
+   */
+  forEach(callback) {
+    this._map.forEach((value, key) => callback(value, key, this));
+  }
+
+  /**
+   * Make iterable
+   * @returns {Iterator} Iterator of [key, value] pairs
+   */
+  [Symbol.iterator]() {
+    return this._map[Symbol.iterator]();
+  }
+}
+
+module.exports = BoundedMap;