react-native-biometric-verifier 0.0.47 → 0.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-biometric-verifier",
-  "version": "0.0.47",
+  "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

@@ -11,74 +11,60 @@ export const useBluetoothService = (notifyMessage) => {
   const [nearbyDevices, setNearbyDevices] = useState([]);
   const scanTimeoutRef = useRef(null);
 
-  /**
-   * Request Bluetooth permissions
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                           BLUETOOTH PERMISSIONS                             */
+  /* -------------------------------------------------------------------------- */
   const requestBluetoothPermissions = useCallback(async () => {
-    console.log('[Permissions] Requesting Bluetooth permissions...');
-    
-    if (Platform.OS === 'android') {
-      try {
-        let permissions = [];
-        
-        if (Platform.Version >= 31) {
-          // Android 12+ requires BLUETOOTH_SCAN and BLUETOOTH_CONNECT
-          permissions = [
-            PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
-            PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
-            PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-          ];
-        } else {
-          // Older Android versions
-          permissions = [
-            PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-          ];
-        }
+    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 granted = await PermissionsAndroid.requestMultiple(permissions);
+      const allGranted = Object.values(granted).every(
+        status => status === PermissionsAndroid.RESULTS.GRANTED
+      );
 
-        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;
+      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;
     }
-    return true; // iOS handles permissions differently
   }, [notifyMessage]);
 
-  /**
-   * Enhanced distance calculation using multiple methods
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                           DISTANCE ESTIMATION                                */
+  /* -------------------------------------------------------------------------- */
   const estimateDistance = useCallback((rssi, txPower = -59) => {
     if (!rssi || rssi >= 0) return -1;
-    
-    // Method 1: Log-distance path loss model (most common)
-    const n = 2.0; // Path loss exponent (2 for free space, 2.7-3.5 for indoor)
+
+    const n = 2.0;
     const distance1 = Math.pow(10, (txPower - rssi) / (10 * n));
-    
-    // Method 2: Quadratic approximation for short distances
     const distance2 = 0.89976 * Math.pow(Math.abs(rssi), 0.80976) + 0.111;
-    
-    // Average the methods for better accuracy
     const avgDistance = (distance1 + distance2) / 2;
-    
-    return Math.max(0.1, avgDistance); // Minimum 0.1m
+
+    return Math.max(0.1, avgDistance);
   }, []);
 
-  /**
-   * Filter out stale BLE devices
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                            FILTER STALE DEVICES                              */
+  /* -------------------------------------------------------------------------- */
   const filterStaleDevices = useCallback(() => {
-    setNearbyDevices(prev => 
+    setNearbyDevices(prev =>
       prev.filter(device => {
         const isRecent = Date.now() - device.lastSeen < 10000; // 10 seconds
         const hasMultipleReadings = device.count >= 3;
@@ -87,11 +73,10 @@ export const useBluetoothService = (notifyMessage) => {
     );
   }, []);
 
-  /**
-   * Stop Bluetooth scan
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                              STOP SCAN                                      */
+  /* -------------------------------------------------------------------------- */
   const stopBluetoothScan = useCallback(() => {
-    console.log('[BLE] Stopping Bluetooth scan...');
     manager.stopDeviceScan();
     if (scanTimeoutRef.current) {
       clearTimeout(scanTimeoutRef.current);
@@ -99,56 +84,43 @@ export const useBluetoothService = (notifyMessage) => {
     }
   }, []);
 
-  /**
-   * Enhanced BLE scanning with filtering and signal processing
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                             START BLE SCAN                                   */
+  /* -------------------------------------------------------------------------- */
   const startBluetoothScan = useCallback(async () => {
-    console.log('[BLE] Starting enhanced Bluetooth scan...');
-    
     const permission = await requestBluetoothPermissions();
-    if (!permission) {
-      return;
-    }
+    if (!permission) return;
 
-    // Clear previous devices
     setNearbyDevices([]);
-    
-    // Configure scan for better accuracy
+
     const scanOptions = {
       allowDuplicates: true,
-      scanMode: 2, // SCAN_MODE_LOW_LATENCY for Android
+      scanMode: 2,
     };
 
     manager.startDeviceScan(null, scanOptions, (error, device) => {
       if (error) {
         console.error('[BLE] Scan error:', error);
         stopBluetoothScan();
-        
-        // Provide user-friendly error messages
+
         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';
-        }
-        
+        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);
-        
-        // Filter out weak signals and calculate moving average
+
         if (distance > 0 && distance <= 20) {
           setNearbyDevices(prev => {
             const existingIndex = prev.findIndex(d => d.id === device.id);
-            
             if (existingIndex >= 0) {
-              // Update existing device with moving average
               const existing = prev[existingIndex];
               const avgDistance = (parseFloat(existing.distance) + distance) / 2;
-              
+
               const updated = [...prev];
               updated[existingIndex] = {
                 ...existing,
@@ -160,64 +132,52 @@ export const useBluetoothService = (notifyMessage) => {
               };
               return updated;
             } else {
-              // Add new device
-              const newDevice = {
-                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,
-              };
-              return [...prev, newDevice];
+              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,
+                },
+              ];
             }
           });
         }
       }
     });
 
-    // Stop after optimized duration
     scanTimeoutRef.current = setTimeout(() => {
       stopBluetoothScan();
       filterStaleDevices();
-      
-      if (nearbyDevices.length === 0) {
-        notifyMessage?.('No nearby Bluetooth devices found', 'info');
-      } else {
-        console.log(`[BLE] Found ${nearbyDevices.length} nearby devices`);
-      }
     }, 10000);
+  }, [notifyMessage, requestBluetoothPermissions, stopBluetoothScan, filterStaleDevices, estimateDistance, nearbyDevices]);
 
-    notifyMessage?.('Scanning for nearby Bluetooth devices...', 'info');
-  }, [notifyMessage, requestBluetoothPermissions, stopBluetoothScan, filterStaleDevices, estimateDistance]);
-
-  /**
-   * Get device details by ID
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                              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,
-      };
+
+      return { ...device, services, isConnected: true };
     } catch (error) {
       console.error('[BLE] Error getting device details:', error);
       return null;
     }
   }, []);
 
-  /**
-   * Clear all scanned devices
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                               CLEAR DEVICES                                  */
+  /* -------------------------------------------------------------------------- */
   const clearDevices = useCallback(() => {
     setNearbyDevices([]);
   }, []);
@@ -232,4 +192,4 @@ export const useBluetoothService = (notifyMessage) => {
     getDeviceDetails,
     estimateDistance,
   };
-};
+};