react-native-biometric-verifier 0.0.47 → 0.0.49

package/package.json

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

package/src/hooks/useGeolocation.js

@@ -3,200 +3,251 @@ import { Platform, PermissionsAndroid } from 'react-native';
 import Geolocation from 'react-native-geolocation-service';
 
 /**
- * Enhanced Geolocation Hook with better accuracy
+ * FAST + ACCURATE Geolocation Hook (Optimized for Verification)
  */
 export const useGeolocation = (notifyMessage) => {
   const locationWatchId = useRef(null);
 
-  /**
-   * Request high-accuracy location 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,
-        ]);
-
-        // Check Android version for background location
-        if (Platform.Version >= 29) {
-          await PermissionsAndroid.request(
-            PermissionsAndroid.PERMISSIONS.ACCESS_BACKGROUND_LOCATION
-          );
-        }
-
-        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;
+  /* -------------------------------------------------------------------------- */
+  /*                               PERMISSIONS                                   */
+  /* -------------------------------------------------------------------------- */
+  const requestLocationPermission = useCallback(async () => {
+    try {
+      if (Platform.OS !== 'android') return true;
+
+      const permissions = [
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+        PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
+      ];
+
+      if (Platform.Version >= 31) {
+        permissions.push(PermissionsAndroid.PERMISSIONS.NEARBY_WIFI_DEVICES);
       }
-    }
-    return true; // iOS handles permissions differently
-  }, [notifyMessage]);
 
-  /**
-   * Get high-accuracy location with multiple attempts
-   */
-  const getCurrentLocation = useCallback(
-    () =>
-      new Promise(async (resolve, reject) => {
-        console.log('[Location] Fetching enhanced location...');
-        
-        let bestLocation = null;
-        
-        const locationOptions = {
-          enableHighAccuracy: true,
-          timeout: 20000,
-          maximumAge: 0,
-          distanceFilter: 0,
-          forceRequestLocation: true,
-          showLocationDialog: true,
-        };
-
-        const watchLocationForAccuracy = () => {
-          return new Promise((resolveWatch, rejectWatch) => {
-            let bestAccuracy = Infinity;
-            let bestCoords = null;
-            let watchTimer;
-
-            locationWatchId.current = Geolocation.watchPosition(
-              (position) => {
-                const { coords } = position;
-                
-                // Track best accuracy
-                if (coords.accuracy < bestAccuracy) {
-                  bestAccuracy = coords.accuracy;
-                  bestCoords = coords;
-                  console.log(`[Location] Improved accuracy: ${coords.accuracy}m`);
-                }
-
-                // Stop if we reach desired accuracy
-                if (coords.accuracy <= 5) {
-                  clearTimeout(watchTimer);
-                  Geolocation.clearWatch(locationWatchId.current);
-                  resolveWatch(coords);
-                }
-              },
-              (error) => {
-                clearTimeout(watchTimer);
-                Geolocation.clearWatch(locationWatchId.current);
-                rejectWatch(error);
-              },
-              locationOptions
-            );
-
-            // Timeout after 15 seconds
-            watchTimer = setTimeout(() => {
-              Geolocation.clearWatch(locationWatchId.current);
-              resolveWatch(bestCoords);
-            }, 15000);
-          });
-        };
-
-        try {
-          // First try: Single high-accuracy reading
-          const singleLocation = await new Promise((resolveSingle, rejectSingle) => {
-            Geolocation.getCurrentPosition(
-              resolveSingle,
-              rejectSingle,
-              locationOptions
-            );
-          });
-
-          bestLocation = singleLocation.coords;
-          console.log(`[Location] Initial accuracy: ${bestLocation.accuracy}m`);
-
-          // If accuracy > 20m, try watching for improvement
-          if (bestLocation.accuracy > 20) {
-            console.log('[Location] Accuracy insufficient, starting watch...');
-            const watchedCoords = await watchLocationForAccuracy();
-            if (watchedCoords && watchedCoords.accuracy < bestLocation.accuracy) {
-              bestLocation = watchedCoords;
-            }
-          }
+      const result = await PermissionsAndroid.requestMultiple(permissions);
 
-          // Validate location quality
-          if (!bestLocation || bestLocation.accuracy > 50) {
-            notifyMessage?.('Location accuracy is low. Please move to an open area.', 'warning');
-          }
+      const granted = Object.values(result).every(
+        status => status === PermissionsAndroid.RESULTS.GRANTED
+      );
 
-          resolve(bestLocation);
-        } catch (error) {
-          console.error('[Location] Error:', 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]
-  );
+      if (!granted) {
+        notifyMessage?.('Location permissions missing', 'warning');
+      }
+
+      return granted;
+    } catch (err) {
+      console.error('[Geo Permissions]', err);
+      return false;
+    }
+  }, [notifyMessage]);
 
-  /**
-   * Stop location watching
-   */
+  /* -------------------------------------------------------------------------- */
+  /*                           STOP LOCATION WATCH                               */
+  /* -------------------------------------------------------------------------- */
   const stopLocationWatching = useCallback(() => {
     if (locationWatchId.current !== null) {
-      console.log('[Location] Stopping location watch...');
       Geolocation.clearWatch(locationWatchId.current);
       locationWatchId.current = null;
     }
   }, []);
 
-  /**
-   * Calculate distance between coordinates using Haversine formula with altitude
-   */
-  const calculateEnhancedDistance = useCallback((lat1, lon1, lat2, lon2, alt1 = 0, alt2 = 0) => {
-    const R = 6371e3; // Earth's radius in meters
-    
-    const φ1 = lat1 * Math.PI/180;
-    const φ2 = lat2 * Math.PI/180;
-    const Δφ = (lat2-lat1) * Math.PI/180;
-    const Δλ = (lon2-lon1) * Math.PI/180;
-
-    // Haversine formula for surface distance
-    const a = Math.sin(Δφ/2) * Math.sin(Δφ/2) +
-              Math.cos(φ1) * Math.cos(φ2) *
-              Math.sin(Δλ/2) * Math.sin(Δλ/2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
-    const surfaceDistance = R * c;
-    
-    // Add altitude difference (Pythagorean theorem)
-    const altitudeDiff = Math.abs(alt1 - alt2);
-    const totalDistance = Math.sqrt(Math.pow(surfaceDistance, 2) + Math.pow(altitudeDiff, 2));
-    
-    return totalDistance;
-  }, []);
+  /* -------------------------------------------------------------------------- */
+  /*                     FAST + ACCURATE LOCATION FETCH                          */
+  /* -------------------------------------------------------------------------- */
+  const getCurrentLocation = useCallback((options = {}) => {
+    return new Promise((resolve, reject) => {
+      let samples = [];
+      let resolved = false;
+
+      const defaultOptions = {
+        enableHighAccuracy: true,
+        timeout: 8000,           // ⏱ fast
+        maximumAge: 2000,        // allow cached fix
+        forceRequestLocation: true,
+        showLocationDialog: true,
+        interval: 800,
+        fastestInterval: 500,
+        distanceFilter: 0,
+        ...options,
+      };
+
+      try {
+        /* ---------------- FAST FIRST FIX ---------------- */
+        Geolocation.getCurrentPosition(
+          (pos) => {
+            if (!pos?.coords || resolved) return;
+
+            const {
+              latitude,
+              longitude,
+              accuracy,
+              altitude = 0,
+              speed = 0,
+              heading = 0,
+            } = pos.coords;
+
+            // Accept immediately if good enough for verification
+            if (accuracy <= 15) {
+              resolved = true;
+              resolve({
+                latitude,
+                longitude,
+                altitude,
+                accuracy,
+                speed,
+                heading,
+                timestamp: pos.timestamp,
+              });
+            }
+
+            samples.push({
+              latitude,
+              longitude,
+              altitude,
+              accuracy,
+              speed,
+              heading,
+              timestamp: pos.timestamp,
+            });
+          },
+          (err) => {
+            console.warn('[Geo Fast Fix Failed]', err);
+          },
+          defaultOptions
+        );
+
+        /* ---------------- BACKGROUND IMPROVEMENT ---------------- */
+        locationWatchId.current = Geolocation.watchPosition(
+          (p) => {
+            if (!p?.coords) return;
+
+            const {
+              latitude,
+              longitude,
+              accuracy,
+              altitude = 0,
+              speed = 0,
+              heading = 0,
+            } = p.coords;
+
+            /* -------- LIGHT NOISE FILTERS -------- */
+            if (accuracy > 40) return;
+            if (speed > 50) return;
+
+            samples.push({
+              latitude,
+              longitude,
+              altitude,
+              accuracy,
+              speed,
+              heading,
+              timestamp: p.timestamp,
+            });
+
+            if (samples.length > 8) samples.shift();
+
+            samples.sort((a, b) => a.accuracy - b.accuracy);
+            const best = samples[0];
+
+            // Upgrade accuracy silently
+            if (best.accuracy <= 6 && !resolved) {
+              resolved = true;
+              stopLocationWatching();
+              resolve(best);
+            }
+          },
+          (err) => {
+            console.error('[Geo Watch Error]', err);
+            stopLocationWatching();
+          },
+          defaultOptions
+        );
+
+        /* ---------------- HARD STOP ---------------- */
+        setTimeout(() => {
+          if (!resolved && samples.length) {
+            resolved = true;
+            stopLocationWatching();
+            samples.sort((a, b) => a.accuracy - b.accuracy);
+            resolve(samples[0]);
+          }
+        }, 5000);
+      } catch (err) {
+        stopLocationWatching();
+        notifyMessage?.('Failed to get location', 'error');
+        reject(err);
+      }
+    });
+  }, [notifyMessage, stopLocationWatching]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                          DISTANCE CALCULATION                               */
+  /* -------------------------------------------------------------------------- */
+  const calculateEnhancedDistance = useCallback(
+    (lat1, lon1, lat2, lon2, alt1 = 0, alt2 = 0) => {
+      try {
+        if (
+          typeof lat1 !== 'number' ||
+          typeof lon1 !== 'number' ||
+          typeof lat2 !== 'number' ||
+          typeof lon2 !== 'number'
+        ) return Infinity;
+
+        const toRad = deg => deg * Math.PI / 180;
+        const R = 6371e3;
+
+        const φ1 = toRad(lat1);
+        const φ2 = toRad(lat2);
+        const Δφ = toRad(lat2 - lat1);
+        const Δλ = toRad(lon2 - lon1);
+
+        const a =
+          Math.sin(Δφ / 2) ** 2 +
+          Math.cos(φ1) * Math.cos(φ2) *
+          Math.sin(Δλ / 2) ** 2;
+
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        const surfaceDistance = R * c;
+
+        const heightDiff = Math.abs(alt1 - alt2);
+        return Math.sqrt(surfaceDistance ** 2 + heightDiff ** 2);
+      } catch {
+        return Infinity;
+      }
+    },
+    []
+  );
+
+  const calculateSafeDistance = useCallback(
+    (p1, p2) => {
+      try {
+        const lat1 = p1.latitude ?? p1.lat;
+        const lon1 = p1.longitude ?? p1.lng ?? p1.lon;
+        const alt1 = p1.altitude ?? p1.alt ?? 0;
+
+        const lat2 = p2.latitude ?? p2.lat;
+        const lon2 = p2.longitude ?? p2.lng ?? p2.lon;
+        const alt2 = p2.altitude ?? p2.alt ?? 0;
+
+        return calculateEnhancedDistance(
+          lat1, lon1, lat2, lon2, alt1, alt2
+        );
+      } catch {
+        return Infinity;
+      }
+    },
+    [calculateEnhancedDistance]
+  );
 
+  /* -------------------------------------------------------------------------- */
+  /*                                   API                                       */
+  /* -------------------------------------------------------------------------- */
   return {
-    requestLocationPermission: requestLocationPermissions,
+    requestLocationPermission,
     getCurrentLocation,
     stopLocationWatching,
+    getCurrentWatchId: () => locationWatchId.current,
     calculateEnhancedDistance,
+    calculateSafeDistance,
   };
-};
+};

package/src/hooks/useWifiService.js

@@ -0,0 +1,175 @@
+import { useCallback } from 'react';
+import { Platform, PermissionsAndroid } from 'react-native';
+import WifiManager from 'react-native-wifi-reborn';
+
+/**
+ * WiFi Service Hook for WiFi scanning and fingerprinting
+ */
+export const useWifiService = (notifyMessage) => {
+
+  /* -------------------------------------------------------------------------- */
+  /*                               WIFI PERMISSIONS                              */
+  /* -------------------------------------------------------------------------- */
+  const requestWifiPermissions = useCallback(async () => {
+    try {
+      if (Platform.OS !== 'android') return false;
+
+      const permissions = [PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION];
+
+      if (Platform.Version >= 31) {
+        permissions.push(PermissionsAndroid.PERMISSIONS.NEARBY_WIFI_DEVICES);
+      }
+
+      const result = await PermissionsAndroid.requestMultiple(permissions);
+
+      const granted = Object.values(result).every(
+        status => status === PermissionsAndroid.RESULTS.GRANTED
+      );
+
+      if (!granted) {
+        notifyMessage?.('WiFi scanning permissions missing', 'warning');
+      }
+
+      return granted;
+    } catch (err) {
+      console.error('[WiFi Permissions] Error:', err);
+      return false;
+    }
+  }, [notifyMessage]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                              WIFI SCANNING                                  */
+  /* -------------------------------------------------------------------------- */
+  const scanWifiFingerprint = useCallback(async () => {
+    if (Platform.OS !== 'android') return [];
+
+    try {
+      const hasPermission = await requestWifiPermissions();
+      if (!hasPermission) return [];
+
+      const list = await WifiManager.loadWifiList();
+
+      const fingerprint = list.map(ap => ({
+        bssid: ap.BSSID,
+        ssid: ap.SSID || 'Unknown',
+        rssi: ap.level,
+        frequency: ap.frequency || 0,
+        capabilities: ap.capabilities || '',
+        timestamp: Date.now(),
+      }));
+
+      return fingerprint;
+    } catch (err) {
+      console.error('[WiFi] Scan failed:', err);
+      notifyMessage?.('WiFi scan failed', 'error');
+      return [];
+    }
+  }, [requestWifiPermissions, notifyMessage]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                         WIFI FINGERPRINT MATCHING                           */
+  /* -------------------------------------------------------------------------- */
+  const matchWifiFingerprint = useCallback((scan, reference, options = {}) => {
+    const { rssiThreshold = 10, matchWeight = 1, partialMatchWeight = 0.5 } = options;
+
+    if (!scan || !reference || !Array.isArray(scan) || !Array.isArray(reference)) return 0;
+
+    let score = 0;
+    let matches = 0;
+    const totalPossibleMatches = Math.min(scan.length, reference.length);
+
+    scan.forEach(ap => {
+      const match = reference.find(r => r.bssid === ap.bssid);
+      if (match) {
+        const diff = Math.abs((match.rssi || 0) - ap.rssi);
+        score += diff <= rssiThreshold ? matchWeight : partialMatchWeight;
+        matches++;
+      }
+    });
+
+    const matchPercentage = totalPossibleMatches > 0 ? (matches / totalPossibleMatches) * 100 : 0;
+
+    return {
+      score,
+      matches,
+      totalPossibleMatches,
+      matchPercentage,
+    };
+  }, []);
+
+  /* -------------------------------------------------------------------------- */
+  /*                              WIFI UTILITIES                                 */
+  /* -------------------------------------------------------------------------- */
+  const getWifiNetworksByStrength = useCallback((networks, limit = 5) => {
+    if (!Array.isArray(networks)) return [];
+    return networks
+      .filter(network => network && typeof network.rssi === 'number')
+      .sort((a, b) => b.rssi - a.rssi)
+      .slice(0, limit);
+  }, []);
+
+  const filterWifiNetworks = useCallback((networks, options = {}) => {
+    const { minRssi = -90, maxRssi = -30, excludeHidden = true } = options;
+    if (!Array.isArray(networks)) return [];
+
+    return networks.filter(network => {
+      if (!network || !network.bssid) return false;
+      if (network.rssi < minRssi || network.rssi > maxRssi) return false;
+      if (excludeHidden && (!network.ssid || network.ssid === '' || network.ssid === '<unknown ssid>')) return false;
+      return true;
+    });
+  }, []);
+
+  const getCurrentWifiInfo = useCallback(async () => {
+    if (Platform.OS !== 'android') return null;
+
+    try {
+      const hasPermission = await requestWifiPermissions();
+      if (!hasPermission) return null;
+
+      const currentWifi = await WifiManager.getCurrentWifiSSID();
+      return { ssid: currentWifi, timestamp: Date.now() };
+    } catch (err) {
+      console.error('[WiFi] Failed to get current WiFi:', err);
+      return null;
+    }
+  }, [requestWifiPermissions]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                         COMBINED LOCATION SCAN                              */
+  /* -------------------------------------------------------------------------- */
+  const getLocationWithWifi = useCallback(async (geolocationHook) => {
+    try {
+      const wifiPromise = scanWifiFingerprint();
+
+      let locationResult;
+      try {
+        locationResult = await geolocationHook.getCurrentLocation();
+      } catch {
+        locationResult = null; // continue with WiFi only
+      }
+
+      const wifiFingerprint = await wifiPromise;
+
+      return {
+        ...(locationResult || {}),
+        wifi: wifiFingerprint,
+        timestamp: Date.now(),
+        source: locationResult ? 'gps+wifi' : 'wifi-only',
+      };
+    } catch (err) {
+      console.error('[WiFi+Location] Combined scan failed:', err);
+      throw err;
+    }
+  }, [scanWifiFingerprint]);
+
+  return {
+    requestWifiPermissions,
+    scanWifiFingerprint,
+    getCurrentWifiInfo,
+    matchWifiFingerprint,
+    getWifiNetworksByStrength,
+    filterWifiNetworks,
+    getLocationWithWifi,
+  };
+};

package/src/index.js

@@ -18,10 +18,9 @@ import {
 } from "react-native";
 import Icon from "react-native-vector-icons/MaterialIcons";
 
-// Custom hooks
+// Custom hooks - Removed unnecessary ones
 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";
@@ -51,42 +50,35 @@ const BiometricModal = forwardRef(({
   fileurl,
   imageurl,
   navigation,
-  MaxDistanceMeters = 50,
-  duration = 100
+  MaxDistanceMeters = 30,
+  duration = 100,
 }, ref) => {
-  // Custom hooks - Initialize notification hook first so notifyMessage is available for other hooks
+  // Custom hooks - Initialize notification hook first
   const { notification, fadeAnim, slideAnim, notifyMessage, clearNotification } = useNotifyMessage();
   const { countdown, startCountdown, resetCountdown, pauseCountdown, resumeCountdown } = useCountdown(duration);
-  
-  // Separate hooks for geolocation and bluetooth
+
+  // Only keep geolocation hook
   const {
     requestLocationPermission,
     getCurrentLocation,
     stopLocationWatching,
-    calculateEnhancedDistance,
+    calculateSafeDistance,
   } = useGeolocation(notifyMessage);
-  
-  const {
-    requestBluetoothPermission,
-    startBluetoothScan,
-    stopBluetoothScan,
-    nearbyDevices,
-    clearDevices,
-  } = useBluetoothService(notifyMessage);
-  
+
   const { convertImageToBase64 } = useImageProcessing();
   const safeCallback = useSafeCallback(callback, notifyMessage);
 
-  // State
+  // State - Simplified
   const [modalVisible, setModalVisible] = useState(false);
-  const [cameraType, setCameraType] = useState("back"); // Start with back camera for QR scan
+  const [cameraType, setCameraType] = useState("back");
   const [state, setState] = useState({
     isLoading: false,
     loadingType: Global.LoadingTypes.none,
     currentStep: "Start",
     employeeData: null,
-    animationState: Global.AnimationStates.qrScan, // Start with QR scan animation
-    qrData: null, // Store QR data for later use in face recognition
+    animationState: Global.AnimationStates.qrScan,
+    qrData: null,
+    // Removed: wifiReferenceScan
   });
 
   // Refs
@@ -95,8 +87,8 @@ const BiometricModal = forwardRef(({
   const responseRef = useRef(null);
   const processedRef = useRef(false);
   const resetTimeoutRef = useRef(null);
-  const bleScanTimeoutRef = useRef(null);
-  
+  // Removed: bleScanTimeoutRef, wifiScanTimeoutRef
+
   // Animation values
   const iconScaleAnim = useRef(new Animated.Value(1)).current;
   const iconOpacityAnim = useRef(new Animated.Value(0)).current;
@@ -109,7 +101,7 @@ const BiometricModal = forwardRef(({
     getStatus: () => state,
   }));
 
-  // Cleanup on unmount
+  // Cleanup on unmount - Simplified
   useEffect(() => {
     return () => {
       mountedRef.current = false;
@@ -117,17 +109,11 @@ const BiometricModal = forwardRef(({
       if (resetTimeoutRef.current) {
         clearTimeout(resetTimeoutRef.current);
       }
-      
-      if (bleScanTimeoutRef.current) {
-        clearTimeout(bleScanTimeoutRef.current);
-      }
-      
-      stopBluetoothScan();
+
       stopLocationWatching();
-      clearDevices();
       clearNotification();
     };
-  }, [stopBluetoothScan, stopLocationWatching, clearDevices, clearNotification]);
+  }, [stopLocationWatching, clearNotification]);
 
   // Update dataRef when data changes
   useEffect(() => {
@@ -136,11 +122,9 @@ const BiometricModal = forwardRef(({
 
   // Animation helper
   const animateIcon = useCallback(() => {
-    // Reset animation
     iconScaleAnim.setValue(1);
     iconOpacityAnim.setValue(0);
 
-    // Start animation sequence
     Animated.sequence([
       Animated.parallel([
         Animated.timing(iconOpacityAnim, {
@@ -169,7 +153,6 @@ const BiometricModal = forwardRef(({
         const merged = { ...prev, ...newState };
 
         if (JSON.stringify(prev) !== JSON.stringify(merged)) {
-          // Pause/resume countdown based on loading state
           if (newState.isLoading !== undefined) {
             if (newState.isLoading) {
               pauseCountdown();
@@ -178,7 +161,6 @@ const BiometricModal = forwardRef(({
             }
           }
 
-          // Animate icon when step changes
           if (newState.currentStep && newState.currentStep !== prev.currentStep) {
             animateIcon();
           }
@@ -191,7 +173,7 @@ const BiometricModal = forwardRef(({
     }
   }, [animateIcon, pauseCountdown, resumeCountdown]);
 
-  // Reset state helper
+  // Reset state helper - Simplified
   const resetState = useCallback(() => {
     if (onclose) {
       onclose(false);
@@ -209,16 +191,14 @@ const BiometricModal = forwardRef(({
     setModalVisible(false);
     processedRef.current = false;
     resetCountdown();
-    stopBluetoothScan();
     stopLocationWatching();
-    clearDevices();
     clearNotification();
 
     if (resetTimeoutRef.current) {
       clearTimeout(resetTimeoutRef.current);
       resetTimeoutRef.current = null;
     }
-  }, [resetCountdown, stopBluetoothScan, stopLocationWatching, clearDevices, clearNotification, onclose]);
+  }, [resetCountdown, stopLocationWatching, clearNotification, onclose]);
 
   // Error handler
   const handleProcessError = useCallback(
@@ -264,49 +244,7 @@ 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
+  // Simplified QR scanning handler - GPS + Key verification only
   const handleQRScanned = useCallback(
     async (qrCodeData) => {
       if (!validateApiUrl()) return;
@@ -318,7 +256,7 @@ const BiometricModal = forwardRef(({
       });
 
       try {
-        // 1. Request permissions
+        // 1. Request location permission
         updateState({ loadingType: Global.LoadingTypes.locationPermission });
         const hasLocationPermission = await requestLocationPermission();
         if (!hasLocationPermission) {
@@ -326,12 +264,6 @@ const BiometricModal = forwardRef(({
           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") {
@@ -339,7 +271,7 @@ const BiometricModal = forwardRef(({
           return;
         }
 
-        // 3. Parse and validate QR coordinates in format: latitude,longitude,depkey
+        // 3. Parse and validate QR coordinates
         const parts = qrString.split(",");
 
         if (parts.length < 3) {
@@ -349,10 +281,8 @@ const BiometricModal = forwardRef(({
 
         const latStr = parts[0];
         const lngStr = parts[1];
-        const qrDepKey = parts[2]; // This is your 1234 from the QR code
-
-        // Optional: QR code accuracy if provided as fourth parameter
-        const qrAccuracy = parts.length > 3 ? parseFloat(parts[3]) : 5; // Default 5m accuracy
+        const qrDepKey = parts[2];
+        const qrAccuracy = parts.length > 3 ? parseFloat(parts[3]) : 5;
 
         const qrLat = parseFloat(latStr);
         const qrLng = parseFloat(lngStr);
@@ -362,55 +292,56 @@ const BiometricModal = forwardRef(({
           return;
         }
 
-        // 3. Get high-accuracy location
+        // 4. Get high-accuracy location
         updateState({ loadingType: Global.LoadingTypes.gettingLocation });
-        const location = await getCurrentLocation();
+
+        let location;
+        try {
+          location = await getCurrentLocation();
+        } catch (locationError) {
+          console.error('Location error:', locationError);
+          handleProcessError("Failed to get location. Please try again.");
+          return;
+        }
+
+        // Validate location object
+        if (!location || typeof location !== 'object') {
+          handleProcessError("Invalid location data received.");
+          return;
+        }
+
+        // Validate location coordinates
+        if (typeof location.latitude !== 'number' || typeof location.longitude !== 'number' ||
+          isNaN(location.latitude) || isNaN(location.longitude)) {
+          handleProcessError("Invalid GPS coordinates received.");
+          return;
+        }
 
         // Validate location accuracy
         if (location.accuracy > 50) {
           notifyMessage(`Location accuracy is ${location.accuracy.toFixed(1)}m. For best results, move to an open area.`, 'warning');
         }
 
-        // 4. Enhanced BLE scanning (optional - can be removed if not needed)
-        updateState({ loadingType: Global.LoadingTypes.bleScan });
-        
-        // 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();
-        }
-
-        // 5. Calculate distance (no altitude in your QR code)
+        // 5. Calculate distance using safe calculation
         updateState({ loadingType: Global.LoadingTypes.calculateDistance });
 
-        // Use the enhanced distance calculation from geolocation hook
-        const distance = calculateEnhancedDistance(
-          qrLat, qrLng,
-          location.latitude, location.longitude
+        const distance = calculateSafeDistance(
+          { latitude: qrLat, longitude: qrLng },
+          { latitude: location.latitude, longitude: location.longitude }
         );
 
+        // Validate distance calculation
+        if (distance === Infinity || isNaN(distance)) {
+          handleProcessError("Failed to calculate distance. Please try again.");
+          return;
+        }
+
         const distanceWithinThreshold = distance <= MaxDistanceMeters;
-        console.log('distanceWithinThreshold', distance, MaxDistanceMeters)
-        
-        // Verify: distance within threshold AND depkey matches (BLE is optional)
-        if (distanceWithinThreshold && qrDepKey === depkey) {
+
+        // Simple verification criteria - GPS + Key only
+        const verificationPassed = distanceWithinThreshold && qrDepKey === depkey;
+
+        if (verificationPassed) {
           const locationDetails = {
             qrLocation: {
               latitude: qrLat,
@@ -422,15 +353,15 @@ const BiometricModal = forwardRef(({
               longitude: location.longitude,
               altitude: location.altitude || 0,
               accuracy: location.accuracy,
-              speed: location.speed,
-              heading: location.heading,
-              timestamp: location.timestamp
+              speed: location.speed || 0,
+              heading: location.heading || 0,
+              timestamp: location.timestamp || Date.now()
             },
             distanceMeters: distance,
             accuracyBuffer: MaxDistanceMeters,
             verified: true,
+            verificationMethod: "GPS+Key",
             verifiedAt: new Date().toISOString(),
-            bleDevicesDetected: consistentDevices,
             locationMethod: location.provider || 'unknown',
             qrData: qrString,
             qrKey: qrDepKey
@@ -445,38 +376,34 @@ const BiometricModal = forwardRef(({
             loadingType: Global.LoadingTypes.none,
           });
 
-          notifyMessage(`Location verified! Distance: ${distance.toFixed(1)}m (±${Math.max(location.accuracy, qrAccuracy).toFixed(1)}m)`, "success");
+          const successMessage = `Location verified! Distance: ${distance.toFixed(1)}m (±${Math.max(location.accuracy || 0, qrAccuracy).toFixed(1)}m)`;
+          notifyMessage(successMessage, "success");
           setTimeout(() => startFaceRecognition(), 1200);
         } else {
-          let errorMsg = `Location mismatch: ${distance.toFixed(1)}m away`;
+          let errorMsg = `Verification failed: ${distance.toFixed(1)}m away`;
           if (qrDepKey !== depkey) errorMsg += " (Key mismatch)";
           handleProcessError(errorMsg);
         }
       } catch (error) {
-        console.error("Enhanced verification failed:", error);
-        handleProcessError("Unable to verify location or BLE proximity.", error);
+        console.error("Location verification failed:", error);
+        handleProcessError("Unable to verify location. Please try again.", error);
       }
     },
     [
       validateApiUrl,
       updateState,
       requestLocationPermission,
-      requestBluetoothPermission,
       getCurrentLocation,
-      startBluetoothScan,
-      stopBluetoothScan,
-      nearbyDevices,
-      findConsistentBLEDevices,
       notifyMessage,
       handleProcessError,
       startFaceRecognition,
       depkey,
       MaxDistanceMeters,
-      calculateEnhancedDistance,
+      calculateSafeDistance,
     ]
   );
 
-  // Face scan upload - SECOND STEP
+  // Face scan upload - SECOND STEP (simplified, no WiFi revalidation)
   const uploadFaceScan = useCallback(
     async (selfie) => {
       if (!validateApiUrl()) return;
@@ -539,7 +466,7 @@ const BiometricModal = forwardRef(({
           if (response?.httpstatus === 200) {
             // Combine face recognition response with QR location data
             responseRef.current = {
-              ...responseRef.current, // Contains location data from QR scan
+              ...responseRef.current,
               ...response.data?.data || {},
               faceRecognition: response.data?.data || null,
             };
@@ -587,7 +514,7 @@ const BiometricModal = forwardRef(({
       safeCallback,
       handleProcessError,
       state.qrData,
-      apiurl
+      apiurl,
     ]
   );
 
@@ -758,6 +685,7 @@ const styles = StyleSheet.create({
     position: 'absolute',
     bottom: Platform.OS === 'ios' ? 50 : 30,
     left: 0,
+    right: 0,
     zIndex: 10,
   },
   headerContainer: {
@@ -793,6 +721,16 @@ const styles = StyleSheet.create({
     textShadowOffset: { width: 1, height: 1 },
     textShadowRadius: 2,
   },
+  wifiIndicator: {
+    fontSize: 12,
+    color: Global.AppTheme.primary || '#4CAF50',
+    marginTop: 4,
+    fontWeight: '500',
+    fontFamily: Platform.OS === 'ios' ? 'Helvetica Neue' : 'sans-serif',
+    textShadowColor: 'rgba(0, 0, 0, 0.2)',
+    textShadowOffset: { width: 1, height: 1 },
+    textShadowRadius: 1,
+  },
   closeButton: {
     position: 'absolute',
     top: Platform.OS === 'ios' ? 40 : 20,