react-native-biometric-verifier 0.0.46 → 0.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-biometric-verifier",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "A React Native module for biometric verification with face recognition and QR code scanning",
   "main": "src/index.js",
   "private": false,

package/src/hooks/useBluetoothService.js

@@ -0,0 +1,195 @@
+import { useCallback, useState, useRef } from 'react';
+import { Platform, PermissionsAndroid } from 'react-native';
+import { BleManager } from 'react-native-ble-plx';
+
+const manager = new BleManager();
+
+/**
+ * Bluetooth Service Hook for device scanning and distance estimation
+ */
+export const useBluetoothService = (notifyMessage) => {
+  const [nearbyDevices, setNearbyDevices] = useState([]);
+  const scanTimeoutRef = useRef(null);
+
+  /* -------------------------------------------------------------------------- */
+  /*                           BLUETOOTH PERMISSIONS                             */
+  /* -------------------------------------------------------------------------- */
+  const requestBluetoothPermissions = useCallback(async () => {
+    if (Platform.OS !== 'android') return true;
+
+    try {
+      let permissions = [];
+      if (Platform.Version >= 31) {
+        permissions = [
+          PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+          PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+        ];
+      } else {
+        permissions = [PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION];
+      }
+
+      const granted = await PermissionsAndroid.requestMultiple(permissions);
+      const allGranted = Object.values(granted).every(
+        status => status === PermissionsAndroid.RESULTS.GRANTED
+      );
+
+      if (!allGranted) {
+        notifyMessage?.('Bluetooth permissions are required for device scanning', 'warning');
+      }
+
+      return allGranted;
+    } catch (error) {
+      console.error('[Permissions] Error:', error);
+      notifyMessage?.('Failed to request Bluetooth permissions', 'error');
+      return false;
+    }
+  }, [notifyMessage]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                           DISTANCE ESTIMATION                                */
+  /* -------------------------------------------------------------------------- */
+  const estimateDistance = useCallback((rssi, txPower = -59) => {
+    if (!rssi || rssi >= 0) return -1;
+
+    const n = 2.0;
+    const distance1 = Math.pow(10, (txPower - rssi) / (10 * n));
+    const distance2 = 0.89976 * Math.pow(Math.abs(rssi), 0.80976) + 0.111;
+    const avgDistance = (distance1 + distance2) / 2;
+
+    return Math.max(0.1, avgDistance);
+  }, []);
+
+  /* -------------------------------------------------------------------------- */
+  /*                            FILTER STALE DEVICES                              */
+  /* -------------------------------------------------------------------------- */
+  const filterStaleDevices = useCallback(() => {
+    setNearbyDevices(prev =>
+      prev.filter(device => {
+        const isRecent = Date.now() - device.lastSeen < 10000; // 10 seconds
+        const hasMultipleReadings = device.count >= 3;
+        return isRecent && hasMultipleReadings;
+      })
+    );
+  }, []);
+
+  /* -------------------------------------------------------------------------- */
+  /*                              STOP SCAN                                      */
+  /* -------------------------------------------------------------------------- */
+  const stopBluetoothScan = useCallback(() => {
+    manager.stopDeviceScan();
+    if (scanTimeoutRef.current) {
+      clearTimeout(scanTimeoutRef.current);
+      scanTimeoutRef.current = null;
+    }
+  }, []);
+
+  /* -------------------------------------------------------------------------- */
+  /*                             START BLE SCAN                                   */
+  /* -------------------------------------------------------------------------- */
+  const startBluetoothScan = useCallback(async () => {
+    const permission = await requestBluetoothPermissions();
+    if (!permission) return;
+
+    setNearbyDevices([]);
+
+    const scanOptions = {
+      allowDuplicates: true,
+      scanMode: 2,
+    };
+
+    manager.startDeviceScan(null, scanOptions, (error, device) => {
+      if (error) {
+        console.error('[BLE] Scan error:', error);
+        stopBluetoothScan();
+
+        let errorMessage = 'Bluetooth scan failed';
+        if (error.errorCode === 102) errorMessage = 'Bluetooth is not enabled';
+        else if (error.errorCode === 103) errorMessage = 'Location services required for scanning';
+
+        notifyMessage?.(errorMessage, 'error');
+        return;
+      }
+
+      if (device && device.name && device.rssi) {
+        const distance = estimateDistance(device.rssi);
+
+        if (distance > 0 && distance <= 20) {
+          setNearbyDevices(prev => {
+            const existingIndex = prev.findIndex(d => d.id === device.id);
+            if (existingIndex >= 0) {
+              const existing = prev[existingIndex];
+              const avgDistance = (parseFloat(existing.distance) + distance) / 2;
+
+              const updated = [...prev];
+              updated[existingIndex] = {
+                ...existing,
+                rssi: device.rssi,
+                distance: avgDistance.toFixed(2),
+                lastSeen: Date.now(),
+                count: existing.count + 1,
+                txPowerLevel: device.txPowerLevel || existing.txPowerLevel,
+              };
+              return updated;
+            } else {
+              return [
+                ...prev,
+                {
+                  id: device.id,
+                  name: device.name || 'Unknown Device',
+                  rssi: device.rssi,
+                  distance: distance.toFixed(2),
+                  lastSeen: Date.now(),
+                  count: 1,
+                  manufacturerData: device.manufacturerData,
+                  serviceUUIDs: device.serviceUUIDs,
+                  txPowerLevel: device.txPowerLevel,
+                  isConnectable: device.isConnectable,
+                },
+              ];
+            }
+          });
+        }
+      }
+    });
+
+    scanTimeoutRef.current = setTimeout(() => {
+      stopBluetoothScan();
+      filterStaleDevices();
+    }, 10000);
+  }, [notifyMessage, requestBluetoothPermissions, stopBluetoothScan, filterStaleDevices, estimateDistance, nearbyDevices]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                              DEVICE DETAILS                                  */
+  /* -------------------------------------------------------------------------- */
+  const getDeviceDetails = useCallback(async (deviceId) => {
+    try {
+      const device = await manager.connectToDevice(deviceId);
+      await device.discoverAllServicesAndCharacteristics();
+      const services = await device.services();
+
+      return { ...device, services, isConnected: true };
+    } catch (error) {
+      console.error('[BLE] Error getting device details:', error);
+      return null;
+    }
+  }, []);
+
+  /* -------------------------------------------------------------------------- */
+  /*                               CLEAR DEVICES                                  */
+  /* -------------------------------------------------------------------------- */
+  const clearDevices = useCallback(() => {
+    setNearbyDevices([]);
+  }, []);
+
+  return {
+    requestBluetoothPermission: requestBluetoothPermissions,
+    startBluetoothScan,
+    stopBluetoothScan,
+    nearbyDevices,
+    filterStaleDevices,
+    clearDevices,
+    getDeviceDetails,
+    estimateDistance,
+  };
+};