react-native-biometric-verifier 0.0.48 → 0.0.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-biometric-verifier",
-  "version": "0.0.48",
+  "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/useGeolocation.js

@@ -3,7 +3,7 @@ import { Platform, PermissionsAndroid } from 'react-native';
 import Geolocation from 'react-native-geolocation-service';
 
 /**
- * Geolocation Hook for GPS functionality
+ * FAST + ACCURATE Geolocation Hook (Optimized for Verification)
  */
 export const useGeolocation = (notifyMessage) => {
   const locationWatchId = useRef(null);
@@ -36,7 +36,7 @@ export const useGeolocation = (notifyMessage) => {
 
       return granted;
     } catch (err) {
-      console.error('[Geolocation Permissions] Error:', err);
+      console.error('[Geo Permissions]', err);
       return false;
     }
   }, [notifyMessage]);
@@ -52,90 +52,127 @@ export const useGeolocation = (notifyMessage) => {
   }, []);
 
   /* -------------------------------------------------------------------------- */
-  /*                            HIGH ACCURACY GPS                                */
+  /*                     FAST + ACCURATE LOCATION FETCH                          */
   /* -------------------------------------------------------------------------- */
   const getCurrentLocation = useCallback((options = {}) => {
-    return new Promise(async (resolve, reject) => {
-      let bestCoords = null;
-      let bestAccuracy = Infinity;
+    return new Promise((resolve, reject) => {
+      let samples = [];
+      let resolved = false;
 
       const defaultOptions = {
         enableHighAccuracy: true,
-        timeout: 20000,
-        maximumAge: 0,
+        timeout: 8000,           // ⏱ fast
+        maximumAge: 2000,        // allow cached fix
         forceRequestLocation: true,
         showLocationDialog: true,
+        interval: 800,
+        fastestInterval: 500,
+        distanceFilter: 0,
         ...options,
       };
 
       try {
-        const pos = await new Promise((res, rej) => {
-          Geolocation.getCurrentPosition(res, rej, defaultOptions);
-        });
-
-        if (!pos.coords || typeof pos.coords.latitude !== 'number' || typeof pos.coords.longitude !== 'number') {
-          reject(new Error('Invalid GPS coordinates received'));
-          return;
-        }
-
-        bestCoords = {
-          latitude: pos.coords.latitude,
-          longitude: pos.coords.longitude,
-          altitude: pos.coords.altitude || 0,
-          accuracy: pos.coords.accuracy,
-          speed: pos.coords.speed || 0,
-          heading: pos.coords.heading || 0,
-          timestamp: pos.timestamp,
-        };
-        
-        bestAccuracy = pos.coords.accuracy;
-
-        if (bestAccuracy > 15) {
-          locationWatchId.current = Geolocation.watchPosition(
-            (p) => {
-              if (
-                p.coords &&
-                typeof p.coords.latitude === 'number' &&
-                typeof p.coords.longitude === 'number' &&
-                p.coords.accuracy < bestAccuracy
-              ) {
-                bestAccuracy = p.coords.accuracy;
-                bestCoords = {
-                  latitude: p.coords.latitude,
-                  longitude: p.coords.longitude,
-                  altitude: p.coords.altitude || 0,
-                  accuracy: p.coords.accuracy,
-                  speed: p.coords.speed || 0,
-                  heading: p.coords.heading || 0,
-                  timestamp: p.timestamp,
-                };
-              }
-
-              if (bestAccuracy <= 5) {
-                stopLocationWatching();
-              }
-            },
-            (err) => {
-              console.error('[Geolocation Watch Error]:', err);
+        /* ---------------- 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();
-            },
-            defaultOptions
-          );
-
-          setTimeout(() => stopLocationWatching(), 12000);
-        }
-
-        resolve({
-          latitude: bestCoords.latitude,
-          longitude: bestCoords.longitude,
-          altitude: bestCoords.altitude,
-          accuracy: bestAccuracy,
-          speed: bestCoords.speed,
-          heading: bestCoords.heading,
-          timestamp: bestCoords.timestamp,
-        });
+              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) {
-        console.error('[Geolocation] Failed to get location:', err);
         stopLocationWatching();
         notifyMessage?.('Failed to get location', 'error');
         reject(err);
@@ -150,28 +187,31 @@ export const useGeolocation = (notifyMessage) => {
     (lat1, lon1, lat2, lon2, alt1 = 0, alt2 = 0) => {
       try {
         if (
-          typeof lat1 !== 'number' || typeof lon1 !== 'number' ||
-          typeof lat2 !== 'number' || typeof lon2 !== 'number' ||
-          isNaN(lat1) || isNaN(lon1) || isNaN(lat2) || isNaN(lon2)
+          typeof lat1 !== 'number' ||
+          typeof lon1 !== 'number' ||
+          typeof lat2 !== 'number' ||
+          typeof lon2 !== 'number'
         ) return Infinity;
 
-        const toRad = (deg) => deg * Math.PI / 180;
-        const R = 6371e3; // meters
+        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 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 heightDifference = Math.abs(alt1 - alt2);
-        return Math.sqrt(surfaceDistance ** 2 + heightDifference ** 2);
-      } catch (err) {
-        console.error('[Geolocation Distance] Error:', err);
+        const heightDiff = Math.abs(alt1 - alt2);
+        return Math.sqrt(surfaceDistance ** 2 + heightDiff ** 2);
+      } catch {
         return Infinity;
       }
     },
@@ -179,25 +219,20 @@ export const useGeolocation = (notifyMessage) => {
   );
 
   const calculateSafeDistance = useCallback(
-    (point1, point2) => {
+    (p1, p2) => {
       try {
-        const lat1 = typeof point1.latitude === 'number' ? point1.latitude :
-                     typeof point1.lat === 'number' ? point1.lat : 0;
-        const lon1 = typeof point1.longitude === 'number' ? point1.longitude :
-                     typeof point1.lng === 'number' ? point1.lng :
-                     typeof point1.lon === 'number' ? point1.lon : 0;
-        const alt1 = point1.altitude || point1.alt || 0;
-
-        const lat2 = typeof point2.latitude === 'number' ? point2.latitude :
-                     typeof point2.lat === 'number' ? point2.lat : 0;
-        const lon2 = typeof point2.longitude === 'number' ? point2.longitude :
-                     typeof point2.lng === 'number' ? point2.lng :
-                     typeof point2.lon === 'number' ? point2.lon : 0;
-        const alt2 = point2.altitude || point2.alt || 0;
-
-        return calculateEnhancedDistance(lat1, lon1, lat2, lon2, alt1, alt2);
-      } catch (err) {
-        console.error('[Geolocation SafeDistance] Error:', err);
+        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;
       }
     },
@@ -205,15 +240,13 @@ export const useGeolocation = (notifyMessage) => {
   );
 
   /* -------------------------------------------------------------------------- */
-  /*                                   GETTERS                                   */
+  /*                                   API                                       */
   /* -------------------------------------------------------------------------- */
-  const getCurrentWatchId = useCallback(() => locationWatchId.current, []);
-
   return {
     requestLocationPermission,
     getCurrentLocation,
     stopLocationWatching,
-    getCurrentWatchId,
+    getCurrentWatchId: () => locationWatchId.current,
     calculateEnhancedDistance,
     calculateSafeDistance,
   };

package/src/index.js

@@ -18,11 +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 { useWifiService } from "./hooks/useWifiService";
-import { useBluetoothService } from "./hooks/useBluetoothService";
 import { useImageProcessing } from "./hooks/useImageProcessing";
 import { useNotifyMessage } from "./hooks/useNotifyMessage";
 import { useSafeCallback } from "./hooks/useSafeCallback";
@@ -54,13 +52,12 @@ const BiometricModal = forwardRef(({
   navigation,
   MaxDistanceMeters = 30,
   duration = 100,
-  useWiFiFingerprinting = true,
 }, ref) => {
   // Custom hooks - Initialize notification hook first
   const { notification, fadeAnim, slideAnim, notifyMessage, clearNotification } = useNotifyMessage();
   const { countdown, startCountdown, resetCountdown, pauseCountdown, resumeCountdown } = useCountdown(duration);
 
-  // Split hooks for geolocation and WiFi
+  // Only keep geolocation hook
   const {
     requestLocationPermission,
     getCurrentLocation,
@@ -68,25 +65,10 @@ const BiometricModal = forwardRef(({
     calculateSafeDistance,
   } = useGeolocation(notifyMessage);
 
-  const {
-    requestWifiPermissions,
-    scanWifiFingerprint,
-    matchWifiFingerprint,
-    getLocationWithWifi,
-  } = useWifiService(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");
   const [state, setState] = useState({
@@ -96,7 +78,7 @@ const BiometricModal = forwardRef(({
     employeeData: null,
     animationState: Global.AnimationStates.qrScan,
     qrData: null,
-    wifiReferenceScan: null,
+    // Removed: wifiReferenceScan
   });
 
   // Refs
@@ -105,8 +87,7 @@ const BiometricModal = forwardRef(({
   const responseRef = useRef(null);
   const processedRef = useRef(false);
   const resetTimeoutRef = useRef(null);
-  const bleScanTimeoutRef = useRef(null);
-  const wifiScanTimeoutRef = useRef(null);
+  // Removed: bleScanTimeoutRef, wifiScanTimeoutRef
 
   // Animation values
   const iconScaleAnim = useRef(new Animated.Value(1)).current;
@@ -120,7 +101,7 @@ const BiometricModal = forwardRef(({
     getStatus: () => state,
   }));
 
-  // Cleanup on unmount
+  // Cleanup on unmount - Simplified
   useEffect(() => {
     return () => {
       mountedRef.current = false;
@@ -129,20 +110,10 @@ const BiometricModal = forwardRef(({
         clearTimeout(resetTimeoutRef.current);
       }
 
-      if (bleScanTimeoutRef.current) {
-        clearTimeout(bleScanTimeoutRef.current);
-      }
-
-      if (wifiScanTimeoutRef.current) {
-        clearTimeout(wifiScanTimeoutRef.current);
-      }
-
-      stopBluetoothScan();
       stopLocationWatching();
-      clearDevices();
       clearNotification();
     };
-  }, [stopBluetoothScan, stopLocationWatching, clearDevices, clearNotification]);
+  }, [stopLocationWatching, clearNotification]);
 
   // Update dataRef when data changes
   useEffect(() => {
@@ -202,7 +173,7 @@ const BiometricModal = forwardRef(({
     }
   }, [animateIcon, pauseCountdown, resumeCountdown]);
 
-  // Reset state helper
+  // Reset state helper - Simplified
   const resetState = useCallback(() => {
     if (onclose) {
       onclose(false);
@@ -215,22 +186,19 @@ const BiometricModal = forwardRef(({
       employeeData: null,
       animationState: Global.AnimationStates.qrScan,
       qrData: null,
-      wifiReferenceScan: null,
     });
 
     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(
@@ -276,108 +244,7 @@ const BiometricModal = forwardRef(({
     return true;
   }, [apiurl, handleProcessError]);
 
-  /**
-   * WiFi fingerprint scanning with validation
-   */
-  const performWiFiScan = useCallback(async () => {
-    if (!useWiFiFingerprinting || Platform.OS !== 'android') {
-      return { scan: [], score: 0, isMatch: false };
-    }
-
-    try {
-      updateState({ loadingType: Global.LoadingTypes.wifiScan });
-
-      // Request WiFi permissions if needed
-      const hasWifiPermission = await requestWifiPermissions();
-      if (!hasWifiPermission) {
-        return { scan: [], score: 0, isMatch: false };
-      }
-
-      // Perform WiFi scan using the WiFi service hook
-      const wifiScan = await scanWifiFingerprint();
-
-      if (wifiScan.length === 0) {
-        notifyMessage("No WiFi networks detected", "warning");
-        return { scan: [], score: 0, isMatch: false };
-      }
-
-      // If we have a reference scan, match against it
-      if (state.wifiReferenceScan && state.wifiReferenceScan.length > 0) {
-        const matchResult = matchWifiFingerprint(wifiScan, state.wifiReferenceScan);
-        const isMatch = matchResult.score >= 3; // Threshold of 3 matching APs
-
-        if (isMatch) {
-          notifyMessage(`WiFi fingerprint match: ${matchResult.score.toFixed(1)}`, "success");
-        } else {
-          notifyMessage(`Weak WiFi match: ${matchResult.score.toFixed(1)}`, "warning");
-        }
-
-        return { 
-          scan: wifiScan, 
-          score: matchResult.score, 
-          isMatch,
-          matchDetails: matchResult
-        };
-      }
-
-      // Return scan without matching
-      return { scan: wifiScan, score: 0, isMatch: false };
-    } catch (error) {
-      console.warn("WiFi scan failed:", error);
-      notifyMessage("WiFi scan unavailable", "warning");
-      return { scan: [], score: 0, isMatch: false };
-    }
-  }, [
-    useWiFiFingerprinting, 
-    requestWifiPermissions, 
-    scanWifiFingerprint, 
-    matchWifiFingerprint, 
-    state.wifiReferenceScan, 
-    notifyMessage, 
-    updateState
-  ]);
-
-  /**
-   * 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);
-  }, []);
-
-  /**
-   * 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);
-  };
-
+  // Simplified QR scanning handler - GPS + Key verification only
   const handleQRScanned = useCallback(
     async (qrCodeData) => {
       if (!validateApiUrl()) return;
@@ -389,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) {
@@ -397,11 +264,6 @@ const BiometricModal = forwardRef(({
           return;
         }
 
-        const hasBluetoothPermission = await requestBluetoothPermission();
-        if (!hasBluetoothPermission) {
-          notifyMessage("Bluetooth scanning may not work", "warning");
-        }
-
         // 2. Parse QR data with validation
         const qrString = typeof qrCodeData === "object" ? qrCodeData?.data : qrCodeData;
         if (!qrString || typeof qrString !== "string") {
@@ -430,38 +292,12 @@ const BiometricModal = forwardRef(({
           return;
         }
 
-        // 4. Perform initial WiFi scan FIRST to establish reference
-        let wifiFingerprint = [];
-        let wifiMatchScore = 0;
-        let isWiFiMatch = false;
-        let wifiMatchDetails = null;
-
-        if (useWiFiFingerprinting && Platform.OS === 'android') {
-          try {
-            const wifiResult = await performWiFiScan();
-            wifiFingerprint = wifiResult.scan;
-
-            // Store as reference for later matching
-            if (wifiFingerprint.length > 0) {
-              updateState({ wifiReferenceScan: wifiFingerprint });
-            }
-          } catch (wifiError) {
-            console.warn('WiFi scan failed:', wifiError);
-            notifyMessage("WiFi scan failed, continuing without WiFi verification", "warning");
-          }
-        }
-
-        // 5. Get high-accuracy location
+        // 4. Get high-accuracy location
         updateState({ loadingType: Global.LoadingTypes.gettingLocation });
 
         let location;
         try {
-          // Use combined location with WiFi if available, otherwise just GPS
-          if (useWiFiFingerprinting && wifiFingerprint.length > 0) {
-            location = await getLocationWithWifi({ getCurrentLocation });
-          } else {
-            location = await getCurrentLocation();
-          }
+          location = await getCurrentLocation();
         } catch (locationError) {
           console.error('Location error:', locationError);
           handleProcessError("Failed to get location. Please try again.");
@@ -486,45 +322,7 @@ const BiometricModal = forwardRef(({
           notifyMessage(`Location accuracy is ${location.accuracy.toFixed(1)}m. For best results, move to an open area.`, 'warning');
         }
 
-        // 6. Perform SECOND WiFi scan to compare with reference
-        if (useWiFiFingerprinting && Platform.OS === 'android' && state.wifiReferenceScan) {
-          try {
-            const wifiResult = await performWiFiScan();
-            wifiFingerprint = wifiResult.scan;
-            wifiMatchScore = wifiResult.score;
-            isWiFiMatch = wifiResult.isMatch;
-            wifiMatchDetails = wifiResult.matchDetails;
-          } catch (wifiError) {
-            console.warn('Second WiFi scan failed:', wifiError);
-            // Continue without WiFi match
-          }
-        }
-
-        // 7. Enhanced BLE scanning (optional)
-        updateState({ loadingType: Global.LoadingTypes.bleScan });
-
-        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);
-        } finally {
-          stopBluetoothScan();
-        }
-
-        // 8. Calculate distance using safe calculation
+        // 5. Calculate distance using safe calculation
         updateState({ loadingType: Global.LoadingTypes.calculateDistance });
 
         const distance = calculateSafeDistance(
@@ -540,20 +338,8 @@ const BiometricModal = forwardRef(({
 
         const distanceWithinThreshold = distance <= MaxDistanceMeters;
 
-        // Enhanced verification criteria
-        let verificationPassed = distanceWithinThreshold && qrDepKey === depkey;
-        let verificationMethod = "GPS+Key";
-
-        // Add WiFi fingerprint verification if enabled and we have a reference
-        if (useWiFiFingerprinting && state.wifiReferenceScan && state.wifiReferenceScan.length > 0) {
-          verificationMethod = isWiFiMatch ? "GPS+WiFi+Key" : "GPS+Key";
-
-          if (isWiFiMatch) {
-            // Strong WiFi verification achieved
-          } else if (wifiFingerprint.length > 0) {
-            notifyMessage(`WiFi environment changed (score: ${wifiMatchScore.toFixed(1)}). Using GPS verification.`, "warning");
-          }
-        }
+        // Simple verification criteria - GPS + Key only
+        const verificationPassed = distanceWithinThreshold && qrDepKey === depkey;
 
         if (verificationPassed) {
           const locationDetails = {
@@ -571,20 +357,11 @@ const BiometricModal = forwardRef(({
               heading: location.heading || 0,
               timestamp: location.timestamp || Date.now()
             },
-            wifiFingerprint: {
-              accessPoints: wifiFingerprint,
-              matchScore: wifiMatchScore,
-              isMatch: isWiFiMatch,
-              enabled: useWiFiFingerprinting,
-              matchDetails: wifiMatchDetails,
-              referenceScanTimestamp: state.wifiReferenceScan?.[0]?.timestamp || Date.now()
-            },
             distanceMeters: distance,
             accuracyBuffer: MaxDistanceMeters,
             verified: true,
-            verificationMethod: verificationMethod,
+            verificationMethod: "GPS+Key",
             verifiedAt: new Date().toISOString(),
-            bleDevicesDetected: consistentDevices,
             locationMethod: location.provider || 'unknown',
             qrData: qrString,
             qrKey: qrDepKey
@@ -599,52 +376,34 @@ const BiometricModal = forwardRef(({
             loadingType: Global.LoadingTypes.none,
           });
 
-          let successMessage = `Location verified! Distance: ${distance.toFixed(1)}m (±${Math.max(location.accuracy || 0, qrAccuracy).toFixed(1)}m)`;
-          if (useWiFiFingerprinting && isWiFiMatch) {
-            successMessage += `, Strong WiFi match: ${wifiMatchScore.toFixed(1)}`;
-          } else if (useWiFiFingerprinting && wifiFingerprint.length > 0) {
-            successMessage += `, WiFi environment: ${wifiFingerprint.length} APs detected`;
-          }
-
+          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 = `Verification failed: ${distance.toFixed(1)}m away`;
           if (qrDepKey !== depkey) errorMsg += " (Key mismatch)";
-          if (useWiFiFingerprinting && wifiFingerprint.length > 0) {
-            errorMsg += ` (WiFi environment: ${wifiFingerprint.length} APs)`;
-          }
           handleProcessError(errorMsg);
         }
       } catch (error) {
-        console.error("Enhanced verification failed:", error);
-        handleProcessError("Unable to verify location or proximity.", error);
+        console.error("Location verification failed:", error);
+        handleProcessError("Unable to verify location. Please try again.", error);
       }
     },
     [
       validateApiUrl,
       updateState,
       requestLocationPermission,
-      requestBluetoothPermission,
       getCurrentLocation,
-      getLocationWithWifi,
-      startBluetoothScan,
-      stopBluetoothScan,
-      nearbyDevices,
-      findConsistentBLEDevices,
       notifyMessage,
       handleProcessError,
       startFaceRecognition,
       depkey,
       MaxDistanceMeters,
       calculateSafeDistance,
-      useWiFiFingerprinting,
-      performWiFiScan,
-      state.wifiReferenceScan,
     ]
   );
 
-  // Face scan upload - SECOND STEP with WiFi re-validation
+  // Face scan upload - SECOND STEP (simplified, no WiFi revalidation)
   const uploadFaceScan = useCallback(
     async (selfie) => {
       if (!validateApiUrl()) return;
@@ -655,25 +414,6 @@ const BiometricModal = forwardRef(({
         return;
       }
 
-      // Optional: Re-validate WiFi fingerprint during face scan
-      let wifiRevalidation = null;
-      if (useWiFiFingerprinting && Platform.OS === 'android' && state.wifiReferenceScan) {
-        const wifiResult = await performWiFiScan();
-        if (wifiResult.scan.length > 0) {
-          wifiRevalidation = {
-            scan: wifiResult.scan,
-            score: wifiResult.score,
-            isMatch: wifiResult.isMatch,
-            referenceScanLength: state.wifiReferenceScan.length,
-            timestamp: new Date().toISOString()
-          };
-
-          if (!wifiResult.isMatch) {
-            notifyMessage("Warning: WiFi environment changed since QR scan", "warning");
-          }
-        }
-      }
-
       const currentData = dataRef.current;
 
       if (!currentData) {
@@ -729,7 +469,6 @@ const BiometricModal = forwardRef(({
               ...responseRef.current,
               ...response.data?.data || {},
               faceRecognition: response.data?.data || null,
-              wifiRevalidation: wifiRevalidation,
             };
 
             updateState({
@@ -775,10 +514,7 @@ const BiometricModal = forwardRef(({
       safeCallback,
       handleProcessError,
       state.qrData,
-      state.wifiReferenceScan,
       apiurl,
-      useWiFiFingerprinting,
-      performWiFiScan,
     ]
   );
 
@@ -877,9 +613,6 @@ const BiometricModal = forwardRef(({
               <View style={styles.titleContainer}>
                 <Text style={styles.title}>Biometric Verification</Text>
                 <Text style={styles.subtitle}>{state.currentStep}</Text>
-                {useWiFiFingerprinting && Platform.OS === 'android' && (
-                  <Text style={styles.wifiIndicator}>WiFi Fingerprinting: Active</Text>
-                )}
               </View>
             </View>
           )}