react-native-biometric-verifier 0.0.46 → 0.0.48

package/src/index.js

@@ -17,15 +17,17 @@ 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 { useWifiService } from "./hooks/useWifiService";
+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";
@@ -50,32 +52,51 @@ const BiometricModal = forwardRef(({
   fileurl,
   imageurl,
   navigation,
-  MaxDistanceMeters = 50,
-  duration = 100
+  MaxDistanceMeters = 30,
+  duration = 100,
+  useWiFiFingerprinting = true,
 }, 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);
+
+  // Split hooks for geolocation and WiFi
   const {
     requestLocationPermission,
     getCurrentLocation,
+    stopLocationWatching,
+    calculateSafeDistance,
+  } = useGeolocation(notifyMessage);
+
+  const {
+    requestWifiPermissions,
+    scanWifiFingerprint,
+    matchWifiFingerprint,
+    getLocationWithWifi,
+  } = useWifiService(notifyMessage);
+
+  const {
+    requestBluetoothPermission,
     startBluetoothScan,
     stopBluetoothScan,
     nearbyDevices,
-  } = useGeolocation(notifyMessage);
+    clearDevices,
+  } = useBluetoothService(notifyMessage);
+
   const { convertImageToBase64 } = useImageProcessing();
   const safeCallback = useSafeCallback(callback, notifyMessage);
 
   // State
   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,
+    wifiReferenceScan: null,
   });
 
   // Refs
@@ -84,6 +105,9 @@ const BiometricModal = forwardRef(({
   const responseRef = useRef(null);
   const processedRef = useRef(false);
   const resetTimeoutRef = useRef(null);
+  const bleScanTimeoutRef = useRef(null);
+  const wifiScanTimeoutRef = useRef(null);
+
   // Animation values
   const iconScaleAnim = useRef(new Animated.Value(1)).current;
   const iconOpacityAnim = useRef(new Animated.Value(0)).current;
@@ -105,9 +129,20 @@ 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]);
 
   // Update dataRef when data changes
   useEffect(() => {
@@ -116,11 +151,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, {
@@ -149,7 +182,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();
@@ -158,7 +190,6 @@ const BiometricModal = forwardRef(({
             }
           }
 
-          // Animate icon when step changes
           if (newState.currentStep && newState.currentStep !== prev.currentStep) {
             animateIcon();
           }
@@ -184,18 +215,22 @@ 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, clearNotification, onclose]);
+  }, [resetCountdown, stopBluetoothScan, stopLocationWatching, clearDevices, clearNotification, onclose]);
 
   // Error handler
   const handleProcessError = useCallback(
@@ -241,8 +276,108 @@ const BiometricModal = forwardRef(({
     return true;
   }, [apiurl, handleProcessError]);
 
-  // QR code processing - FIRST STEP
-  // Enhanced QR processing
+  /**
+   * 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);
+  };
+
   const handleQRScanned = useCallback(
     async (qrCodeData) => {
       if (!validateApiUrl()) return;
@@ -256,12 +391,17 @@ 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");
+        }
+
         // 2. Parse QR data with validation
         const qrString = typeof qrCodeData === "object" ? qrCodeData?.data : qrCodeData;
         if (!qrString || typeof qrString !== "string") {
@@ -269,7 +409,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) {
@@ -279,10 +419,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);
@@ -292,45 +430,132 @@ const BiometricModal = forwardRef(({
           return;
         }
 
-        // 3. Get high-accuracy location
+        // 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
         updateState({ loadingType: Global.LoadingTypes.gettingLocation });
-        const location = await getCurrentLocation();
+
+        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();
+          }
+        } 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)
+        // 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 });
-        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]);
-        }
+        let consistentDevices = [];
+        let isBLENearby = false;
 
-        stopBluetoothScan();
+        try {
+          startBluetoothScan();
 
-        // Process BLE data to find consistent nearby devices
-        const consistentDevices = findConsistentBLEDevices(bleSamples);
-        const isBLENearby = consistentDevices.length > 0 && consistentDevices.some(d => d.avgDistance <= 5);
+          // 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();
+        }
 
-        // 5. Calculate distance (no altitude in your QR code)
+        // 8. Calculate distance using safe calculation
         updateState({ loadingType: Global.LoadingTypes.calculateDistance });
 
-        // Simple 2D distance calculation (since no altitude in QR)
-        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 BLE devices nearby AND depkey matches
-        if (distanceWithinThreshold && qrDepKey === depkey) {
+
+        // 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");
+          }
+        }
+
+        if (verificationPassed) {
           const locationDetails = {
             qrLocation: {
               latitude: qrLat,
@@ -342,13 +567,22 @@ 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()
+            },
+            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,
             verifiedAt: new Date().toISOString(),
             bleDevicesDetected: consistentDevices,
             locationMethod: location.provider || 'unknown',
@@ -365,93 +599,52 @@ const BiometricModal = forwardRef(({
             loadingType: Global.LoadingTypes.none,
           });
 
-          notifyMessage(`Location verified! Distance: ${distance.toFixed(1)}m (±${Math.max(location.accuracy, qrAccuracy).toFixed(1)}m)`, "success");
+          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`;
+          }
+
+          notifyMessage(successMessage, "success");
           setTimeout(() => startFaceRecognition(), 1200);
         } else {
-          let errorMsg = `Location mismatch: ${distance.toFixed(1)}m away`;
-          if (!isBLENearby) errorMsg += " (No nearby BLE devices)";
+          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 BLE proximity.", error);
+        handleProcessError("Unable to verify location or proximity.", error);
       }
     },
     [
       validateApiUrl,
       updateState,
       requestLocationPermission,
+      requestBluetoothPermission,
       getCurrentLocation,
+      getLocationWithWifi,
       startBluetoothScan,
       stopBluetoothScan,
       nearbyDevices,
+      findConsistentBLEDevices,
       notifyMessage,
       handleProcessError,
       startFaceRecognition,
       depkey,
       MaxDistanceMeters,
+      calculateSafeDistance,
+      useWiFiFingerprinting,
+      performWiFiScan,
+      state.wifiReferenceScan,
     ]
   );
 
-  /**
-   * 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
+  // Face scan upload - SECOND STEP with WiFi re-validation
   const uploadFaceScan = useCallback(
     async (selfie) => {
       if (!validateApiUrl()) return;
@@ -462,6 +655,25 @@ 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) {
@@ -514,9 +726,10 @@ 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,
+              wifiRevalidation: wifiRevalidation,
             };
 
             updateState({
@@ -562,7 +775,10 @@ const BiometricModal = forwardRef(({
       safeCallback,
       handleProcessError,
       state.qrData,
-      apiurl
+      state.wifiReferenceScan,
+      apiurl,
+      useWiFiFingerprinting,
+      performWiFiScan,
     ]
   );
 
@@ -661,6 +877,9 @@ 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>
           )}
@@ -700,8 +919,7 @@ const BiometricModal = forwardRef(({
       </View>
     </Modal>
   );
-}
-);
+});
 
 // Wrap with memo after forwardRef
 const MemoizedBiometricModal = React.memo(BiometricModal);
@@ -734,6 +952,7 @@ const styles = StyleSheet.create({
     position: 'absolute',
     bottom: Platform.OS === 'ios' ? 50 : 30,
     left: 0,
+    right: 0,
     zIndex: 10,
   },
   headerContainer: {
@@ -769,6 +988,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,