react-native-ble-mesh 1.0.1

package/src/transport/RNBLEAdapter.js

@@ -0,0 +1,328 @@
+'use strict';
+
+/**
+ * @fileoverview React Native BLE adapter using react-native-ble-plx
+ * @module transport/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/Transport.js

@@ -0,0 +1,188 @@
+'use strict';
+
+/**
+ * @fileoverview Abstract transport interface for BLE Mesh Network
+ * @module transport/Transport
+ */
+
+const EventEmitter = require('events');
+
+/**
+ * Transport states
+ * @constant {Object.<string, string>}
+ */
+const TRANSPORT_STATE = Object.freeze({
+  STOPPED: 'stopped',
+  STARTING: 'starting',
+  RUNNING: 'running',
+  STOPPING: 'stopping',
+  ERROR: 'error'
+});
+
+/**
+ * Abstract transport interface for mesh network communication.
+ * Extend this class to implement specific transport mechanisms (BLE, WiFi, etc.)
+ *
+ * @abstract
+ * @class Transport
+ * @extends EventEmitter
+ *
+ * @fires Transport#message - When a message is received from a peer
+ * @fires Transport#peerConnected - When a peer connects
+ * @fires Transport#peerDisconnected - When a peer disconnects
+ * @fires Transport#error - When an error occurs
+ * @fires Transport#stateChanged - When transport state changes
+ */
+class Transport extends EventEmitter {
+  /**
+   * Creates a new Transport instance
+   * @param {Object} [options={}] - Transport options
+   * @param {number} [options.maxPeers=8] - Maximum number of simultaneous peers
+   */
+  constructor(options = {}) {
+    super();
+
+    /**
+     * Transport options
+     * @type {Object}
+     * @protected
+     */
+    this._options = {
+      maxPeers: 8,
+      ...options
+    };
+
+    /**
+     * Current transport state
+     * @type {string}
+     * @protected
+     */
+    this._state = TRANSPORT_STATE.STOPPED;
+
+    /**
+     * Connected peers map (peerId -> connection info)
+     * @type {Map<string, Object>}
+     * @protected
+     */
+    this._peers = new Map();
+  }
+
+  /**
+   * Gets the current transport state
+   * @returns {string} Current state
+   */
+  get state() {
+    return this._state;
+  }
+
+  /**
+   * Checks if transport is running
+   * @returns {boolean} True if running
+   */
+  get isRunning() {
+    return this._state === TRANSPORT_STATE.RUNNING;
+  }
+
+  /**
+   * Sets the transport state and emits state change event
+   * @param {string} newState - New state
+   * @protected
+   */
+  _setState(newState) {
+    const oldState = this._state;
+    if (oldState !== newState) {
+      this._state = newState;
+      this.emit('stateChanged', { oldState, newState });
+    }
+  }
+
+  /**
+   * Starts the transport layer
+   * @abstract
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async start() {
+    throw new Error('Transport.start() must be implemented by subclass');
+  }
+
+  /**
+   * Stops the transport layer
+   * @abstract
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async stop() {
+    throw new Error('Transport.stop() must be implemented by subclass');
+  }
+
+  /**
+   * Sends data to a specific peer
+   * @abstract
+   * @param {string} peerId - Target peer ID
+   * @param {Uint8Array} data - Data to send
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async send(_peerId, _data) {
+    throw new Error('Transport.send() must be implemented by subclass');
+  }
+
+  /**
+   * Broadcasts data to all connected peers
+   * @abstract
+   * @param {Uint8Array} data - Data to broadcast
+   * @returns {Promise<string[]>} Array of peer IDs that received the broadcast
+   * @throws {Error} If not implemented by subclass
+   */
+  async broadcast(_data) {
+    throw new Error('Transport.broadcast() must be implemented by subclass');
+  }
+
+  /**
+   * Gets list of connected peer IDs
+   * @returns {string[]} Array of connected peer IDs
+   */
+  getConnectedPeers() {
+    return Array.from(this._peers.keys());
+  }
+
+  /**
+   * Checks if a peer is connected
+   * @param {string} peerId - Peer ID to check
+   * @returns {boolean} True if peer is connected
+   */
+  isConnected(peerId) {
+    return this._peers.has(peerId);
+  }
+
+  /**
+   * Gets connection info for a peer
+   * @param {string} peerId - Peer ID
+   * @returns {Object|undefined} Connection info or undefined
+   */
+  getPeerInfo(peerId) {
+    return this._peers.get(peerId);
+  }
+
+  /**
+   * Gets the number of connected peers
+   * @returns {number} Number of connected peers
+   */
+  getConnectionCount() {
+    return this._peers.size;
+  }
+
+  /**
+   * Checks if more peers can connect
+   * @returns {boolean} True if under max peer limit
+   */
+  canAcceptPeer() {
+    return this._peers.size < this._options.maxPeers;
+  }
+}
+
+// Export state constants with the class
+Transport.STATE = TRANSPORT_STATE;
+
+module.exports = Transport;

package/src/transport/adapters/BLEAdapter.js

@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * @fileoverview Abstract BLE adapter interface
+ * @module transport/adapters/BLEAdapter
+ */
+
+const { BLUETOOTH_STATE } = require('../../constants');
+
+/**
+ * Abstract BLE adapter interface.
+ * Provides a unified API for different BLE implementations.
+ *
+ * @abstract
+ * @class BLEAdapter
+ */
+class BLEAdapter {
+  /**
+   * Creates a new BLEAdapter instance
+   * @param {Object} [options={}] - Adapter options
+   */
+  constructor(options = {}) {
+    /**
+     * Adapter options
+     * @type {Object}
+     * @protected
+     */
+    this._options = options;
+
+    /**
+     * State change callback
+     * @type {Function|null}
+     * @protected
+     */
+    this._stateChangeCallback = null;
+
+    /**
+     * Whether adapter is initialized
+     * @type {boolean}
+     * @protected
+     */
+    this._initialized = false;
+  }
+
+  /**
+   * Gets whether the adapter is initialized
+   * @returns {boolean} True if initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+
+  /**
+   * Initializes the BLE adapter
+   * @abstract
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async initialize() {
+    throw new Error('BLEAdapter.initialize() must be implemented by subclass');
+  }
+
+  /**
+   * Destroys the BLE adapter and releases resources
+   * @abstract
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async destroy() {
+    throw new Error('BLEAdapter.destroy() must be implemented by subclass');
+  }
+
+  /**
+   * Starts scanning for BLE devices
+   * @abstract
+   * @param {string[]} serviceUUIDs - Service UUIDs to filter by
+   * @param {Function} callback - Callback for discovered devices
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async startScan(_serviceUUIDs, _callback) {
+    throw new Error('BLEAdapter.startScan() must be implemented by subclass');
+  }
+
+  /**
+   * Stops scanning for BLE devices
+   * @abstract
+   * @throws {Error} If not implemented by subclass
+   */
+  stopScan() {
+    throw new Error('BLEAdapter.stopScan() must be implemented by subclass');
+  }
+
+  /**
+   * Connects to a BLE device
+   * @abstract
+   * @param {string} deviceId - Device ID to connect to
+   * @returns {Promise<Object>} Connected device info
+   * @throws {Error} If not implemented by subclass
+   */
+  async connect(_deviceId) {
+    throw new Error('BLEAdapter.connect() must be implemented by subclass');
+  }
+
+  /**
+   * Disconnects from a BLE device
+   * @abstract
+   * @param {string} deviceId - Device ID to disconnect from
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async disconnect(_deviceId) {
+    throw new Error('BLEAdapter.disconnect() must be implemented by subclass');
+  }
+
+  /**
+   * Writes data to a characteristic
+   * @abstract
+   * @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>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async write(_deviceId, _serviceUUID, _charUUID, _data) {
+    throw new Error('BLEAdapter.write() must be implemented by subclass');
+  }
+
+  /**
+   * Subscribes to characteristic notifications
+   * @abstract
+   * @param {string} deviceId - Target device ID
+   * @param {string} serviceUUID - Service UUID
+   * @param {string} charUUID - Characteristic UUID
+   * @param {Function} callback - Notification callback
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async subscribe(_deviceId, _serviceUUID, _charUUID, _callback) {
+    throw new Error('BLEAdapter.subscribe() must be implemented by subclass');
+  }
+
+  /**
+   * Gets the current Bluetooth state
+   * @abstract
+   * @returns {Promise<string>} Bluetooth state
+   * @throws {Error} If not implemented by subclass
+   */
+  async getState() {
+    throw new Error('BLEAdapter.getState() must be implemented by subclass');
+  }
+
+  /**
+   * Registers a callback for Bluetooth state changes
+   * @param {Function} callback - State change callback
+   */
+  onStateChange(callback) {
+    this._stateChangeCallback = callback;
+  }
+
+  /**
+   * Notifies listeners of state change
+   * @param {string} state - New Bluetooth state
+   * @protected
+   */
+  _notifyStateChange(state) {
+    if (this._stateChangeCallback) {
+      this._stateChangeCallback(state);
+    }
+  }
+}
+
+// Export state constants with the class
+BLEAdapter.STATE = BLUETOOTH_STATE;
+
+module.exports = BLEAdapter;