react-native-biometric-verifier 0.0.45 → 0.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-biometric-verifier",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "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,235 @@
+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);
+
+  /**
+   * Request 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,
+          ];
+        }
+
+        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;
+      }
+    }
+    return true; // iOS handles permissions differently
+  }, [notifyMessage]);
+
+  /**
+   * Enhanced distance calculation using multiple methods
+   */
+  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 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
+  }, []);
+
+  /**
+   * Filter out stale BLE 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 Bluetooth scan
+   */
+  const stopBluetoothScan = useCallback(() => {
+    console.log('[BLE] Stopping Bluetooth scan...');
+    manager.stopDeviceScan();
+    if (scanTimeoutRef.current) {
+      clearTimeout(scanTimeoutRef.current);
+      scanTimeoutRef.current = null;
+    }
+  }, []);
+
+  /**
+   * Enhanced BLE scanning with filtering and signal processing
+   */
+  const startBluetoothScan = useCallback(async () => {
+    console.log('[BLE] Starting enhanced Bluetooth scan...');
+    
+    const permission = await requestBluetoothPermissions();
+    if (!permission) {
+      return;
+    }
+
+    // Clear previous devices
+    setNearbyDevices([]);
+    
+    // Configure scan for better accuracy
+    const scanOptions = {
+      allowDuplicates: true,
+      scanMode: 2, // SCAN_MODE_LOW_LATENCY for Android
+    };
+
+    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';
+        }
+        
+        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,
+                rssi: device.rssi,
+                distance: avgDistance.toFixed(2),
+                lastSeen: Date.now(),
+                count: existing.count + 1,
+                txPowerLevel: device.txPowerLevel || existing.txPowerLevel,
+              };
+              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];
+            }
+          });
+        }
+      }
+    });
+
+    // 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?.('Scanning for nearby Bluetooth devices...', 'info');
+  }, [notifyMessage, requestBluetoothPermissions, stopBluetoothScan, filterStaleDevices, estimateDistance]);
+
+  /**
+   * Get device details by ID
+   */
+  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 all scanned devices
+   */
+  const clearDevices = useCallback(() => {
+    setNearbyDevices([]);
+  }, []);
+
+  return {
+    requestBluetoothPermission: requestBluetoothPermissions,
+    startBluetoothScan,
+    stopBluetoothScan,
+    nearbyDevices,
+    filterStaleDevices,
+    clearDevices,
+    getDeviceDetails,
+    estimateDistance,
+  };
+};

package/src/hooks/useGeolocation.js

@@ -1,32 +1,24 @@
-// Enhanced location service
-import { useCallback, useState, useRef } from 'react';
+import { useCallback, useRef } from 'react';
 import { Platform, PermissionsAndroid } from 'react-native';
 import Geolocation from 'react-native-geolocation-service';
-import { BleManager } from 'react-native-ble-plx';
-
-const manager = new BleManager();
 
 /**
  * Enhanced Geolocation Hook with better accuracy
  */
 export const useGeolocation = (notifyMessage) => {
-  const [nearbyDevices, setNearbyDevices] = useState([]);
-  const scanTimeoutRef = useRef(null);
   const locationWatchId = useRef(null);
 
   /**
-   * Request high-accuracy permissions
+   * Request high-accuracy location permissions
    */
-  const requestPermissions = useCallback(async () => {
-    console.log('[Permissions] Requesting enhanced permissions...');
+  const requestLocationPermissions = useCallback(async () => {
+    console.log('[Permissions] Requesting enhanced location permissions...');
     
     if (Platform.OS === 'android') {
       try {
         const granted = await PermissionsAndroid.requestMultiple([
           PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
           PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
-          PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
-          PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
         ]);
 
         // Check Android version for background location
@@ -36,16 +28,23 @@ export const useGeolocation = (notifyMessage) => {
           );
         }
 
-        return Object.values(granted).every(
+        const allGranted = Object.values(granted).every(
           status => status === PermissionsAndroid.RESULTS.GRANTED
         );
+        
+        if (!allGranted) {
+          notifyMessage?.('Location permissions are required for accurate positioning', 'warning');
+        }
+        
+        return allGranted;
       } catch (error) {
         console.error('[Permissions] Error:', error);
+        notifyMessage?.('Failed to request location permissions', 'error');
         return false;
       }
     }
     return true; // iOS handles permissions differently
-  }, []);
+  }, [notifyMessage]);
 
   /**
    * Get high-accuracy location with multiple attempts
@@ -56,8 +55,6 @@ export const useGeolocation = (notifyMessage) => {
         console.log('[Location] Fetching enhanced location...');
         
         let bestLocation = null;
-        let attempts = 0;
-        const maxAttempts = 3;
         
         const locationOptions = {
           enableHighAccuracy: true,
@@ -138,130 +135,39 @@ export const useGeolocation = (notifyMessage) => {
           resolve(bestLocation);
         } catch (error) {
           console.error('[Location] Error:', error);
-          reject(error);
+          
+          // Provide user-friendly error messages
+          let errorMessage = 'Failed to get location';
+          switch (error.code) {
+            case 1:
+              errorMessage = 'Location permission denied';
+              break;
+            case 2:
+              errorMessage = 'Location unavailable';
+              break;
+            case 3:
+              errorMessage = 'Location request timed out';
+              break;
+          }
+          
+          notifyMessage?.(errorMessage, 'error');
+          reject(new Error(errorMessage));
         }
       }),
     [notifyMessage]
   );
 
   /**
-   * Stop Bluetooth scan
+   * Stop location watching
    */
-  const stopBluetoothScan = useCallback(() => {
-    console.log('[BLE] Stopping Bluetooth scan...');
-    manager.stopDeviceScan();
-    if (scanTimeoutRef.current) {
-      clearTimeout(scanTimeoutRef.current);
-      scanTimeoutRef.current = null;
+  const stopLocationWatching = useCallback(() => {
+    if (locationWatchId.current !== null) {
+      console.log('[Location] Stopping location watch...');
+      Geolocation.clearWatch(locationWatchId.current);
+      locationWatchId.current = null;
     }
   }, []);
 
-  /**
-   * Enhanced BLE scanning with filtering
-   */
-  const startBluetoothScan = useCallback(async () => {
-    console.log('[BLE] Starting enhanced Bluetooth scan...');
-    const permission = await requestPermissions();
-    if (!permission) {
-      notifyMessage?.('Permissions required for Bluetooth scanning', 'error');
-      return;
-    }
-
-    setNearbyDevices([]);
-    
-    // Configure scan for better accuracy
-    const scanOptions = {
-      allowDuplicates: true,
-      scanMode: 2, // SCAN_MODE_LOW_LATENCY for Android
-    };
-
-    manager.startDeviceScan(null, scanOptions, (error, device) => {
-      if (error) {
-        console.error('[BLE] Scan error:', error);
-        stopBluetoothScan();
-        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,
-                rssi: device.rssi,
-                distance: avgDistance.toFixed(2),
-                lastSeen: Date.now(),
-                count: existing.count + 1,
-              };
-              return updated;
-            } else {
-              // Add new device
-              const newDevice = {
-                id: device.id,
-                name: device.name,
-                rssi: device.rssi,
-                distance: distance.toFixed(2),
-                lastSeen: Date.now(),
-                count: 1,
-                manufacturerData: device.manufacturerData,
-                serviceUUIDs: device.serviceUUIDs,
-              };
-              return [...prev, newDevice];
-            }
-          });
-        }
-      }
-    });
-
-    // Stop after optimized duration
-    scanTimeoutRef.current = setTimeout(() => {
-      stopBluetoothScan();
-      filterStaleDevices();
-    }, 10000);
-  }, [notifyMessage, requestPermissions, stopBluetoothScan, filterStaleDevices]);
-
-  /**
-   * Filter out stale BLE 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;
-      })
-    );
-  }, []);
-
-  /**
-   * Enhanced distance calculation using multiple methods
-   */
-  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 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
-  }, []);
-
   /**
    * Calculate distance between coordinates using Haversine formula with altitude
    */
@@ -288,12 +194,9 @@ export const useGeolocation = (notifyMessage) => {
   }, []);
 
   return {
-    requestLocationPermission: requestPermissions,
+    requestLocationPermission: requestLocationPermissions,
     getCurrentLocation,
-    startBluetoothScan,
-    stopBluetoothScan,
-    nearbyDevices,
+    stopLocationWatching,
     calculateEnhancedDistance,
-    filterStaleDevices,
   };
 };

package/src/index.js

@@ -17,15 +17,16 @@ import {
   Animated,
 } from "react-native";
 import Icon from "react-native-vector-icons/MaterialIcons";
+
 // Custom hooks
 import { useCountdown } from "./hooks/useCountdown";
 import { useGeolocation } from "./hooks/useGeolocation";
+import { useBluetoothService } from "./hooks/useBluetoothService";
 import { useImageProcessing } from "./hooks/useImageProcessing";
 import { useNotifyMessage } from "./hooks/useNotifyMessage";
 import { useSafeCallback } from "./hooks/useSafeCallback";
 
 // Utils
-import { getDistanceInMeters } from "./utils/distanceCalculator";
 import { Global } from "./utils/Global";
 import networkServiceCall from "./utils/NetworkServiceCall";
 import { getLoaderGif } from "./utils/getLoaderGif";
@@ -56,13 +57,23 @@ const BiometricModal = forwardRef(({
   // Custom hooks - Initialize notification hook first so notifyMessage is available for other hooks
   const { notification, fadeAnim, slideAnim, notifyMessage, clearNotification } = useNotifyMessage();
   const { countdown, startCountdown, resetCountdown, pauseCountdown, resumeCountdown } = useCountdown(duration);
+  
+  // Separate hooks for geolocation and bluetooth
   const {
     requestLocationPermission,
     getCurrentLocation,
+    stopLocationWatching,
+    calculateEnhancedDistance,
+  } = useGeolocation(notifyMessage);
+  
+  const {
+    requestBluetoothPermission,
     startBluetoothScan,
     stopBluetoothScan,
     nearbyDevices,
-  } = useGeolocation(notifyMessage);
+    clearDevices,
+  } = useBluetoothService(notifyMessage);
+  
   const { convertImageToBase64 } = useImageProcessing();
   const safeCallback = useSafeCallback(callback, notifyMessage);
 
@@ -84,6 +95,8 @@ const BiometricModal = forwardRef(({
   const responseRef = useRef(null);
   const processedRef = useRef(false);
   const resetTimeoutRef = useRef(null);
+  const bleScanTimeoutRef = useRef(null);
+  
   // Animation values
   const iconScaleAnim = useRef(new Animated.Value(1)).current;
   const iconOpacityAnim = useRef(new Animated.Value(0)).current;
@@ -104,10 +117,17 @@ const BiometricModal = forwardRef(({
       if (resetTimeoutRef.current) {
         clearTimeout(resetTimeoutRef.current);
       }
-
+      
+      if (bleScanTimeoutRef.current) {
+        clearTimeout(bleScanTimeoutRef.current);
+      }
+      
+      stopBluetoothScan();
+      stopLocationWatching();
+      clearDevices();
       clearNotification();
     };
-  }, []);
+  }, [stopBluetoothScan, stopLocationWatching, clearDevices, clearNotification]);
 
   // Update dataRef when data changes
   useEffect(() => {
@@ -189,13 +209,16 @@ const BiometricModal = forwardRef(({
     setModalVisible(false);
     processedRef.current = false;
     resetCountdown();
+    stopBluetoothScan();
+    stopLocationWatching();
+    clearDevices();
     clearNotification();
 
     if (resetTimeoutRef.current) {
       clearTimeout(resetTimeoutRef.current);
       resetTimeoutRef.current = null;
     }
-  }, [resetCountdown, clearNotification, onclose]);
+  }, [resetCountdown, stopBluetoothScan, stopLocationWatching, clearDevices, clearNotification, onclose]);
 
   // Error handler
   const handleProcessError = useCallback(
@@ -241,6 +264,47 @@ const BiometricModal = forwardRef(({
     return true;
   }, [apiurl, handleProcessError]);
 
+  /**
+   * Find consistent BLE devices across multiple samples
+   */
+  const findConsistentBLEDevices = useCallback((samples) => {
+    const deviceMap = new Map();
+
+    samples.forEach((sample, sampleIndex) => {
+      sample.forEach(device => {
+        if (!deviceMap.has(device.id)) {
+          deviceMap.set(device.id, {
+            ...device,
+            distances: [],
+            samples: 0
+          });
+        }
+        const entry = deviceMap.get(device.id);
+        entry.distances.push(parseFloat(device.distance));
+        entry.samples++;
+      });
+    });
+
+    // Filter for devices seen in at least 2 samples
+    return Array.from(deviceMap.values())
+      .filter(device => device.samples >= 2)
+      .map(device => ({
+        ...device,
+        avgDistance: device.distances.reduce((a, b) => a + b, 0) / device.distances.length,
+        stdDev: calculateStdDev(device.distances)
+      }))
+      .filter(device => device.stdDev < 2); // Filter out inconsistent readings
+  }, []);
+
+  /**
+   * Calculate standard deviation
+   */
+  const calculateStdDev = (array) => {
+    const n = array.length;
+    const mean = array.reduce((a, b) => a + b) / n;
+    return Math.sqrt(array.map(x => Math.pow(x - mean, 2)).reduce((a, b) => a + b) / n);
+  };
+
   // QR code processing - FIRST STEP
   // Enhanced QR processing
   const handleQRScanned = useCallback(
@@ -256,12 +320,18 @@ const BiometricModal = forwardRef(({
       try {
         // 1. Request permissions
         updateState({ loadingType: Global.LoadingTypes.locationPermission });
-        const hasPermission = await requestLocationPermission();
-        if (!hasPermission) {
+        const hasLocationPermission = await requestLocationPermission();
+        if (!hasLocationPermission) {
           handleProcessError("Location permission not granted.");
           return;
         }
 
+        const hasBluetoothPermission = await requestBluetoothPermission();
+        if (!hasBluetoothPermission) {
+          notifyMessage("Bluetooth scanning may not work", "warning");
+          // Continue anyway, Bluetooth is optional
+        }
+
         // 2. Parse QR data with validation
         const qrString = typeof qrCodeData === "object" ? qrCodeData?.data : qrCodeData;
         if (!qrString || typeof qrString !== "string") {
@@ -303,41 +373,48 @@ const BiometricModal = forwardRef(({
 
         // 4. Enhanced BLE scanning (optional - can be removed if not needed)
         updateState({ loadingType: Global.LoadingTypes.bleScan });
-        startBluetoothScan();
-
-        // Collect BLE data with multiple samples
-        const bleSamples = [];
-        for (let i = 0; i < 3; i++) {
-          await new Promise(resolve => setTimeout(resolve, 2000));
-          bleSamples.push([...nearbyDevices]);
+        
+        // Start BLE scan and collect samples
+        let consistentDevices = [];
+        let isBLENearby = false;
+        
+        try {
+          startBluetoothScan();
+          
+          // Collect BLE data with multiple samples
+          const bleSamples = [];
+          for (let i = 0; i < 3; i++) {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            bleSamples.push([...nearbyDevices]);
+          }
+          
+          consistentDevices = findConsistentBLEDevices(bleSamples);
+          isBLENearby = consistentDevices.length > 0 && consistentDevices.some(d => d.avgDistance <= 5);
+        } catch (bleError) {
+          console.warn("BLE scanning failed:", bleError);
+          // Continue without BLE data
+        } finally {
+          stopBluetoothScan();
         }
 
-        stopBluetoothScan();
-
-        // Process BLE data to find consistent nearby devices
-        const consistentDevices = findConsistentBLEDevices(bleSamples);
-        const isBLENearby = consistentDevices.length > 0 && consistentDevices.some(d => d.avgDistance <= 5);
-
         // 5. Calculate distance (no altitude in your QR code)
         updateState({ loadingType: Global.LoadingTypes.calculateDistance });
 
-        // Simple 2D distance calculation (since no altitude in QR)
+        // Use the enhanced distance calculation from geolocation hook
         const distance = calculateEnhancedDistance(
           qrLat, qrLng,
           location.latitude, location.longitude
         );
 
-        // 6. Enhanced verification with accuracy buffer
-        const maxAllowedDistance = MaxDistanceMeters + Math.max(location.accuracy, qrAccuracy);
-        const distanceWithinThreshold = distance <= maxAllowedDistance;
-
-        // Verify: distance within threshold AND BLE devices nearby AND depkey matches
-        if (distanceWithinThreshold && isBLENearby && qrDepKey === depkey) {
+        const distanceWithinThreshold = distance <= MaxDistanceMeters;
+        console.log('distanceWithinThreshold', distance, MaxDistanceMeters)
+        
+        // Verify: distance within threshold AND depkey matches (BLE is optional)
+        if (distanceWithinThreshold && qrDepKey === depkey) {
           const locationDetails = {
             qrLocation: {
               latitude: qrLat,
               longitude: qrLng,
-              // No altitude in your QR code format
               accuracy: qrAccuracy
             },
             deviceLocation: {
@@ -350,7 +427,7 @@ const BiometricModal = forwardRef(({
               timestamp: location.timestamp
             },
             distanceMeters: distance,
-            accuracyBuffer: maxAllowedDistance,
+            accuracyBuffer: MaxDistanceMeters,
             verified: true,
             verifiedAt: new Date().toISOString(),
             bleDevicesDetected: consistentDevices,
@@ -372,7 +449,6 @@ const BiometricModal = forwardRef(({
           setTimeout(() => startFaceRecognition(), 1200);
         } else {
           let errorMsg = `Location mismatch: ${distance.toFixed(1)}m away`;
-          if (!isBLENearby) errorMsg += " (No nearby BLE devices)";
           if (qrDepKey !== depkey) errorMsg += " (Key mismatch)";
           handleProcessError(errorMsg);
         }
@@ -385,75 +461,21 @@ const BiometricModal = forwardRef(({
       validateApiUrl,
       updateState,
       requestLocationPermission,
+      requestBluetoothPermission,
       getCurrentLocation,
       startBluetoothScan,
       stopBluetoothScan,
       nearbyDevices,
+      findConsistentBLEDevices,
       notifyMessage,
       handleProcessError,
       startFaceRecognition,
       depkey,
       MaxDistanceMeters,
+      calculateEnhancedDistance,
     ]
   );
 
-  /**
-   * Find consistent BLE devices across multiple samples
-   */
-  const findConsistentBLEDevices = (samples) => {
-    const deviceMap = new Map();
-
-    samples.forEach((sample, sampleIndex) => {
-      sample.forEach(device => {
-        if (!deviceMap.has(device.id)) {
-          deviceMap.set(device.id, {
-            ...device,
-            distances: [],
-            samples: 0
-          });
-        }
-        const entry = deviceMap.get(device.id);
-        entry.distances.push(parseFloat(device.distance));
-        entry.samples++;
-      });
-    });
-
-    // Filter for devices seen in at least 2 samples
-    return Array.from(deviceMap.values())
-      .filter(device => device.samples >= 2)
-      .map(device => ({
-        ...device,
-        avgDistance: device.distances.reduce((a, b) => a + b, 0) / device.distances.length,
-        stdDev: calculateStdDev(device.distances)
-      }))
-      .filter(device => device.stdDev < 2); // Filter out inconsistent readings
-  };
-
-  /**
-   * Calculate standard deviation
-   */
-  const calculateStdDev = (array) => {
-    const n = array.length;
-    const mean = array.reduce((a, b) => a + b) / n;
-    return Math.sqrt(array.map(x => Math.pow(x - mean, 2)).reduce((a, b) => a + b) / n);
-  };
-
-  /**
-   * Calculate enhanced distance with altitude
-   */
-  const calculateEnhancedDistance = (lat1, lng1, lat2, lng2, alt1 = 0, alt2 = 0) => {
-    const R = 6371000; // Earth's radius in meters
-    const dLat = (lat2 - lat1) * Math.PI / 180;
-    const dLng = (lng2 - lng1) * Math.PI / 180;
-    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-      Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
-      Math.sin(dLng / 2) * Math.sin(dLng / 2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    const horizontalDistance = R * c;
-    const verticalDistance = Math.abs(alt2 - alt1);
-    return Math.sqrt(horizontalDistance * horizontalDistance + verticalDistance * verticalDistance);
-  };
-
   // Face scan upload - SECOND STEP
   const uploadFaceScan = useCallback(
     async (selfie) => {
@@ -703,8 +725,7 @@ const BiometricModal = forwardRef(({
       </View>
     </Modal>
   );
-}
-);
+});
 
 // Wrap with memo after forwardRef
 const MemoizedBiometricModal = React.memo(BiometricModal);