react-native-sdk-ble-middleware-v2 0.1.0

package/src/services/BLEMiddleware.ts

@@ -0,0 +1,291 @@
+import { Platform, PermissionsAndroid } from 'react-native';
+import type { ScanOptions, BLEEventType, UserRole } from '../types';
+
+/**
+ * BLEMiddleware - Wrapper class for react-native-sdk-ble
+ * Handles all BLE operations and event management
+ */
+class BLEMiddleware {
+  private bleManager: any = null;
+  private isInitialized: boolean = false;
+  private initializationPromise: Promise<void> | null = null;
+  private currentUserRole: UserRole = 'patient'; // Default role
+
+  constructor() {
+    // Start initialization immediately
+    this.initializationPromise = this.initializeBLEManager();
+  }
+
+  private async initializeBLEManager(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    try {
+      // Import the real BLE SDK
+      const BleModule = require('react-native-sdk-ble');
+      this.bleManager = BleModule.default || BleModule;
+      this.isInitialized = true;
+      console.log('✅ BLE Manager initialized successfully');
+    } catch (error) {
+      console.error('❌ Failed to initialize BLE Manager:', error);
+      console.error(
+        'Make sure react-native-sdk-ble is installed in your app as a peer dependency'
+      );
+      console.error('Run: npm install react-native-sdk-ble');
+      this.isInitialized = false;
+      throw new Error(
+        'react-native-sdk-ble is required but not installed. Please install it in your app: npm install react-native-sdk-ble'
+      );
+    }
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    // Wait for initialization to complete
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+    }
+
+    if (!this.isInitialized || !this.bleManager) {
+      throw new Error(
+        'BLE Manager is not initialized. Please ensure react-native-sdk-ble is installed: npm install react-native-sdk-ble'
+      );
+    }
+  }
+
+  /**
+   * Check if Bluetooth is enabled on the device
+   */
+  async isBluetoothEnabled(): Promise<boolean> {
+    await this.ensureInitialized();
+    return await this.bleManager.isBluetoothEnabled();
+  }
+
+  /**
+   * Request necessary permissions for BLE operations
+   */
+  async requestPermissions(): Promise<void> {
+    if (Platform.OS === 'android') {
+      const granted = await PermissionsAndroid.requestMultiple([
+        PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+        PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+      ]);
+
+      const allGranted = Object.values(granted).every(
+        (status) => status === PermissionsAndroid.RESULTS.GRANTED
+      );
+
+      if (!allGranted) {
+        console.warn('Not all BLE permissions were granted');
+      }
+    }
+
+    await this.ensureInitialized();
+    await this.bleManager.requestPermissions();
+  }
+
+  /**
+   * Start scanning for BLE devices
+   */
+  async startScan(options: ScanOptions = {}): Promise<void> {
+    await this.ensureInitialized();
+    const defaultOptions = {
+      timeout: 10000,
+      allowDuplicates: false,
+      ...options,
+    };
+    await this.bleManager.startScan(defaultOptions);
+  }
+
+  /**
+   * Stop scanning for BLE devices
+   */
+  async stopScan(): Promise<void> {
+    await this.ensureInitialized();
+    await this.bleManager.stopScan();
+  }
+
+  /**
+   * Connect to a BLE device
+   */
+  async connect(deviceId: string): Promise<void> {
+    await this.ensureInitialized();
+    await this.bleManager.connect(deviceId);
+
+    // Automatically send user role command after connection
+    await this.sendUserRoleCommand();
+  }
+
+  /**
+   * Send user role command to device
+   * @private
+   */
+  private async sendUserRoleCommand(): Promise<void> {
+    try {
+      await this.ensureInitialized();
+      if (this.bleManager && this.bleManager.setUserRole) {
+        await this.bleManager.setUserRole(this.currentUserRole);
+        console.log(`✅ User role '${this.currentUserRole}' sent to device`);
+      } else {
+        console.warn('⚠️ setUserRole method not available in BLE SDK');
+      }
+    } catch (error) {
+      console.warn(`⚠️ Failed to send user role:`, error);
+      // Don't throw - allow connection to proceed even if role command fails
+    }
+  }
+
+  /**
+   * Disconnect from a BLE device
+   */
+  async disconnect(deviceId: string): Promise<void> {
+    await this.ensureInitialized();
+    await this.bleManager.disconnect(deviceId);
+  }
+
+  /**
+   * Register event listener
+   */
+  on(event: BLEEventType, callback: (data: any) => void): void {
+    // For event listeners, we check synchronously but warn if not ready
+    if (!this.isInitialized || !this.bleManager) {
+      console.warn(
+        `BLE Manager not ready yet. Event listener for '${event}' will be registered once initialization completes.`
+      );
+      // Queue the event listener to be registered after initialization
+      this.initializationPromise?.then(() => {
+        if (this.isInitialized && this.bleManager) {
+          this.bleManager.on(event, callback);
+        }
+      });
+      return;
+    }
+    this.bleManager.on(event, callback);
+  }
+
+  /**
+   * Remove all event listeners
+   */
+  removeAllListeners(): void {
+    if (this.isInitialized && this.bleManager) {
+      this.bleManager.removeAllListeners();
+    }
+  }
+
+  /**
+   * Get the underlying BLE manager instance
+   * Use with caution - prefer using the wrapper methods
+   */
+  async getRawManager(): Promise<any> {
+    await this.ensureInitialized();
+    return this.bleManager;
+  }
+
+  /**
+   * Check if the BLE manager is ready
+   */
+  isReady(): boolean {
+    return this.isInitialized && this.bleManager !== null;
+  }
+
+  /**
+   * Wait for initialization to complete
+   */
+  async waitForInitialization(): Promise<void> {
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+    }
+  }
+
+  /**
+   * Read characteristic value
+   */
+  async readCharacteristic(
+    deviceId: string,
+    serviceUuid: string,
+    characteristicUuid: string
+  ): Promise<any> {
+    await this.ensureInitialized();
+    return await this.bleManager.readCharacteristic(
+      deviceId,
+      serviceUuid,
+      characteristicUuid
+    );
+  }
+
+  /**
+   * Write characteristic value
+   */
+  async writeCharacteristic(
+    deviceId: string,
+    serviceUuid: string,
+    characteristicUuid: string,
+    data: string,
+    options?: { withResponse?: boolean }
+  ): Promise<void> {
+    await this.ensureInitialized();
+    await this.bleManager.writeCharacteristic(
+      deviceId,
+      serviceUuid,
+      characteristicUuid,
+      data,
+      options
+    );
+  }
+
+  /**
+   * Start infusion - Sends command A4 01 01
+   */
+  async startInfusion(deviceId: string): Promise<void> {
+    await this.ensureInitialized();
+    await this.bleManager.startInfusion(deviceId);
+    console.log('✅ Infusion started - Command A4 01 01 sent');
+  }
+
+  /**
+   * Stop infusion - Sends command A4 01 00
+   */
+  async stopInfusion(deviceId: string): Promise<void> {
+    await this.ensureInitialized();
+    await this.bleManager.stopInfusion(deviceId);
+    console.log('✅ Infusion stopped - Command A4 01 00 sent');
+  }
+
+  /**
+   * Set infusion level - Sends command A5 01 0{level}
+   * @param deviceId - The device ID to send the command to
+   * @param level - Infusion level (1-9)
+   */
+  async setInfusionLevel(deviceId: string, level: number): Promise<void> {
+    await this.ensureInitialized();
+    if (level < 1 || level > 5) {
+      throw new Error('Infusion level must be between 1 and 5');
+    }
+    await this.bleManager.setInfusionLevel(deviceId, level);
+    console.log(
+      `✅ Infusion level set to ${level} - Command A5 01 0${level} sent`
+    );
+  }
+
+  /**
+   * Set user role
+   * @param role - The user role to set ('patient', 'nurse', or 'engineer')
+   */
+  setUserRole(role: UserRole): void {
+    this.currentUserRole = role;
+    console.log(`✅ User role set to: ${role}`);
+  }
+
+  /**
+   * Get current user role
+   * @returns The current user role
+   */
+  getUserRole(): UserRole {
+    return this.currentUserRole;
+  }
+}
+
+// Export singleton instance
+export const bleMiddleware = new BLEMiddleware();
+export default bleMiddleware;

package/src/services/MockBLEManager.ts

@@ -0,0 +1,96 @@
+/**
+ * Mock BLE Manager for development/testing
+ * Replace this with the actual react-native-sdk-ble package
+ */
+
+class MockBLEManager {
+  private listeners: Map<string, Function[]> = new Map();
+
+  async isBluetoothEnabled(): Promise<boolean> {
+    console.log('📱 Mock: Checking Bluetooth status...');
+    return true;
+  }
+
+  async requestPermissions(): Promise<void> {
+    console.log('📱 Mock: Requesting permissions...');
+    return Promise.resolve();
+  }
+
+  async startScan(options: any): Promise<void> {
+    console.log('📱 Mock: Starting scan with options:', options);
+
+    // Simulate finding devices
+    setTimeout(() => {
+      this.emit('scanResult', {
+        device: {
+          id: 'mock-device-1',
+          name: 'Mock BLE Device 1',
+          rssi: -65,
+        },
+      });
+    }, 1000);
+
+    setTimeout(() => {
+      this.emit('scanResult', {
+        device: {
+          id: 'mock-device-2',
+          name: 'Mock BLE Device 2',
+          rssi: -75,
+        },
+      });
+    }, 2000);
+
+    return Promise.resolve();
+  }
+
+  async stopScan(): Promise<void> {
+    console.log('📱 Mock: Stopping scan...');
+    return Promise.resolve();
+  }
+
+  async connect(deviceId: string): Promise<void> {
+    console.log('📱 Mock: Connecting to device:', deviceId);
+    setTimeout(() => {
+      this.emit('connected', { deviceId });
+
+      // Simulate characteristic notifications
+      setTimeout(() => {
+        this.emit('characteristicChanged', {
+          deviceId,
+          serviceUuid: '0000FF00-0000-1000-8000-00805F9B34FB',
+          characteristicUuid: '0000FF21-0000-1000-8000-00805F9B34FB',
+          value: [1, 2, 3, 4],
+        });
+      }, 2000);
+    }, 500);
+    return Promise.resolve();
+  }
+
+  async disconnect(deviceId: string): Promise<void> {
+    console.log('📱 Mock: Disconnecting from device:', deviceId);
+    setTimeout(() => {
+      this.emit('disconnected', { deviceId });
+    }, 500);
+    return Promise.resolve();
+  }
+
+  on(event: string, callback: Function): void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)!.push(callback);
+    console.log(`📱 Mock: Registered listener for '${event}'`);
+  }
+
+  removeAllListeners(): void {
+    console.log('📱 Mock: Removing all listeners');
+    this.listeners.clear();
+  }
+
+  private emit(event: string, data: any): void {
+    const callbacks = this.listeners.get(event) || [];
+    callbacks.forEach((callback) => callback(data));
+  }
+}
+
+export default new MockBLEManager();

package/src/services/index.ts

@@ -0,0 +1 @@
+export { default as bleMiddleware } from './BLEMiddleware';

package/src/types/index.ts

@@ -0,0 +1,97 @@
+/**
+ * BLE Device interface
+ */
+export interface BLEDevice {
+  id: string;
+  name?: string;
+  rssi?: number;
+  [key: string]: any;
+}
+
+/**
+ * Scan configuration options
+ */
+export interface ScanOptions {
+  timeout?: number;
+  allowDuplicates?: boolean;
+}
+
+/**
+ * User role types
+ */
+export type UserRole = 'patient' | 'nurse' | 'engineer';
+
+/**
+ * Characteristic notification event
+ */
+export interface CharacteristicNotification {
+  deviceId: string;
+  serviceUuid: string;
+  characteristicUuid: string;
+  value: any;
+}
+
+/**
+ * Device connection state
+ */
+export interface DeviceConnectionState {
+  deviceId: string;
+  isConnected: boolean;
+  isInfusionRunning: boolean;
+  infusionLevel: number | null;
+  notifications: {
+    ff01: CharacteristicNotification | null;
+    ff21: CharacteristicNotification | null;
+    ff31: CharacteristicNotification | null;
+    ff41: CharacteristicNotification | null;
+    ff02: CharacteristicNotification | null;
+  };
+}
+
+/**
+ * BLE event types
+ */
+export type BLEEventType =
+  | 'scanResult'
+  | 'connected'
+  | 'disconnected'
+  | 'BleManagerScanFailed'
+  | 'bluetoothStateChanged'
+  | 'characteristicChanged';
+
+/**
+ * BLE event payloads
+ */
+export interface BLEEvents {
+  scanResult: { device: BLEDevice };
+  connected: { deviceId: string };
+  disconnected: { deviceId: string };
+  BleManagerScanFailed: { error: string };
+  bluetoothStateChanged: { state: string };
+  characteristicChanged: CharacteristicNotification;
+}
+
+/**
+ * Characteristic UUIDs for notifications
+ */
+export enum CharacteristicUUID {
+  FF01 = '0000FF01-0000-1000-8000-00805F9B34FB',
+  FF21 = '0000FF21-0000-1000-8000-00805F9B34FB',
+  FF31 = '0000FF31-0000-1000-8000-00805F9B34FB',
+  FF41 = '0000FF41-0000-1000-8000-00805F9B34FB',
+  FF02 = '0000FF02-0000-1000-8000-00805F9B34FB',
+}
+
+/**
+ * BLE Manager interface
+ */
+export interface IBLEManager {
+  isBluetoothEnabled(): Promise<boolean>;
+  requestPermissions(): Promise<void>;
+  startScan(options?: ScanOptions): Promise<void>;
+  stopScan(): Promise<void>;
+  connect(deviceId: string): Promise<void>;
+  disconnect(deviceId: string): Promise<void>;
+  on(event: BLEEventType, callback: (data: any) => void): void;
+  removeAllListeners(): void;
+}