react-native-biometric-verifier 0.0.46 → 0.0.48

package/src/hooks/useGeolocation.js

@@ -1,299 +1,220 @@
-// Enhanced location service
-import { useCallback, useState, useRef } from 'react';
+import { useCallback, useRef } from 'react';
 import { Platform, PermissionsAndroid } from 'react-native';
 import Geolocation from 'react-native-geolocation-service';
-import { BleManager } from 'react-native-ble-plx';
-
-const manager = new BleManager();
 
 /**
- * Enhanced Geolocation Hook with better accuracy
+ * Geolocation Hook for GPS functionality
  */
 export const useGeolocation = (notifyMessage) => {
-  const [nearbyDevices, setNearbyDevices] = useState([]);
-  const scanTimeoutRef = useRef(null);
   const locationWatchId = useRef(null);
 
-  /**
-   * Request high-accuracy permissions
-   */
-  const requestPermissions = useCallback(async () => {
-    console.log('[Permissions] Requesting enhanced permissions...');
-    
-    if (Platform.OS === 'android') {
-      try {
-        const granted = await PermissionsAndroid.requestMultiple([
-          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-          PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
-          PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
-          PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
-        ]);
+  /* -------------------------------------------------------------------------- */
+  /*                               PERMISSIONS                                   */
+  /* -------------------------------------------------------------------------- */
+  const requestLocationPermission = useCallback(async () => {
+    try {
+      if (Platform.OS !== 'android') return true;
 
-        // Check Android version for background location
-        if (Platform.Version >= 29) {
-          await PermissionsAndroid.request(
-            PermissionsAndroid.PERMISSIONS.ACCESS_BACKGROUND_LOCATION
-          );
-        }
+      const permissions = [
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+        PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
+      ];
 
-        return Object.values(granted).every(
-          status => status === PermissionsAndroid.RESULTS.GRANTED
-        );
-      } catch (error) {
-        console.error('[Permissions] Error:', error);
-        return false;
+      if (Platform.Version >= 31) {
+        permissions.push(PermissionsAndroid.PERMISSIONS.NEARBY_WIFI_DEVICES);
       }
-    }
-    return true; // iOS handles permissions differently
-  }, []);
-
-  /**
-   * Get high-accuracy location with multiple attempts
-   */
-  const getCurrentLocation = useCallback(
-    () =>
-      new Promise(async (resolve, reject) => {
-        console.log('[Location] Fetching enhanced location...');
-        
-        let bestLocation = null;
-        let attempts = 0;
-        const maxAttempts = 3;
-        
-        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;
+      const result = await PermissionsAndroid.requestMultiple(permissions);
 
-            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`);
-                }
+      const granted = Object.values(result).every(
+        status => status === PermissionsAndroid.RESULTS.GRANTED
+      );
 
-                // 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;
-            }
-          }
-
-          // Validate location quality
-          if (!bestLocation || bestLocation.accuracy > 50) {
-            notifyMessage?.('Location accuracy is low. Please move to an open area.', 'warning');
-          }
-
-          resolve(bestLocation);
-        } catch (error) {
-          console.error('[Location] Error:', error);
-          reject(error);
-        }
-      }),
-    [notifyMessage]
-  );
+      if (!granted) {
+        notifyMessage?.('Location permissions missing', 'warning');
+      }
 
-  /**
-   * Stop Bluetooth scan
-   */
-  const stopBluetoothScan = useCallback(() => {
-    console.log('[BLE] Stopping Bluetooth scan...');
-    manager.stopDeviceScan();
-    if (scanTimeoutRef.current) {
-      clearTimeout(scanTimeoutRef.current);
-      scanTimeoutRef.current = null;
+      return granted;
+    } catch (err) {
+      console.error('[Geolocation Permissions] Error:', err);
+      return false;
+    }
+  }, [notifyMessage]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                           STOP LOCATION WATCH                               */
+  /* -------------------------------------------------------------------------- */
+  const stopLocationWatching = useCallback(() => {
+    if (locationWatchId.current !== null) {
+      Geolocation.clearWatch(locationWatchId.current);
+      locationWatchId.current = null;
     }
   }, []);
 
-  /**
-   * Enhanced BLE scanning with filtering
-   */
-  const startBluetoothScan = useCallback(async () => {
-    console.log('[BLE] Starting enhanced Bluetooth scan...');
-    const permission = await requestPermissions();
-    if (!permission) {
-      notifyMessage?.('Permissions required for Bluetooth scanning', 'error');
-      return;
-    }
+  /* -------------------------------------------------------------------------- */
+  /*                            HIGH ACCURACY GPS                                */
+  /* -------------------------------------------------------------------------- */
+  const getCurrentLocation = useCallback((options = {}) => {
+    return new Promise(async (resolve, reject) => {
+      let bestCoords = null;
+      let bestAccuracy = Infinity;
+
+      const defaultOptions = {
+        enableHighAccuracy: true,
+        timeout: 20000,
+        maximumAge: 0,
+        forceRequestLocation: true,
+        showLocationDialog: true,
+        ...options,
+      };
 
-    setNearbyDevices([]);
-    
-    // Configure scan for better accuracy
-    const scanOptions = {
-      allowDuplicates: true,
-      scanMode: 2, // SCAN_MODE_LOW_LATENCY for Android
-    };
+      try {
+        const pos = await new Promise((res, rej) => {
+          Geolocation.getCurrentPosition(res, rej, defaultOptions);
+        });
 
-    manager.startDeviceScan(null, scanOptions, (error, device) => {
-      if (error) {
-        console.error('[BLE] Scan error:', error);
-        stopBluetoothScan();
-        return;
-      }
+        if (!pos.coords || typeof pos.coords.latitude !== 'number' || typeof pos.coords.longitude !== 'number') {
+          reject(new Error('Invalid GPS coordinates received'));
+          return;
+        }
 
-      if (device && device.name && device.rssi) {
-        const distance = estimateDistance(device.rssi);
+        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,
+        };
         
-        // Filter out weak signals and calculate moving average
-        if (distance > 0 && distance <= 20) {
-          setNearbyDevices(prev => {
-            const existingIndex = prev.findIndex(d => d.id === device.id);
-            
-            if (existingIndex >= 0) {
-              // Update existing device with moving average
-              const existing = prev[existingIndex];
-              const avgDistance = (parseFloat(existing.distance) + distance) / 2;
-              
-              const updated = [...prev];
-              updated[existingIndex] = {
-                ...existing,
-                rssi: device.rssi,
-                distance: avgDistance.toFixed(2),
-                lastSeen: Date.now(),
-                count: existing.count + 1,
-              };
-              return updated;
-            } else {
-              // Add new device
-              const newDevice = {
-                id: device.id,
-                name: device.name,
-                rssi: device.rssi,
-                distance: distance.toFixed(2),
-                lastSeen: Date.now(),
-                count: 1,
-                manufacturerData: device.manufacturerData,
-                serviceUUIDs: device.serviceUUIDs,
-              };
-              return [...prev, newDevice];
-            }
-          });
+        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);
+              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,
+        });
+      } catch (err) {
+        console.error('[Geolocation] Failed to get location:', err);
+        stopLocationWatching();
+        notifyMessage?.('Failed to get location', 'error');
+        reject(err);
       }
     });
+  }, [notifyMessage, stopLocationWatching]);
 
-    // Stop after optimized duration
-    scanTimeoutRef.current = setTimeout(() => {
-      stopBluetoothScan();
-      filterStaleDevices();
-    }, 10000);
-  }, [notifyMessage, requestPermissions, stopBluetoothScan, filterStaleDevices]);
-
-  /**
-   * Filter out stale BLE devices
-   */
-  const filterStaleDevices = useCallback(() => {
-    setNearbyDevices(prev => 
-      prev.filter(device => {
-        const isRecent = Date.now() - device.lastSeen < 10000; // 10 seconds
-        const hasMultipleReadings = device.count >= 3;
-        return isRecent && hasMultipleReadings;
-      })
-    );
-  }, []);
-
-  /**
-   * Enhanced distance calculation using multiple methods
-   */
-  const estimateDistance = useCallback((rssi, txPower = -59) => {
-    if (!rssi || rssi >= 0) return -1;
-    
-    // Method 1: Log-distance path loss model (most common)
-    const n = 2.0; // Path loss exponent (2 for free space, 2.7-3.5 for indoor)
-    const distance1 = Math.pow(10, (txPower - rssi) / (10 * n));
-    
-    // Method 2: Quadratic approximation for short distances
-    const distance2 = 0.89976 * Math.pow(Math.abs(rssi), 0.80976) + 0.111;
-    
-    // Average the methods for better accuracy
-    const avgDistance = (distance1 + distance2) / 2;
-    
-    return Math.max(0.1, avgDistance); // Minimum 0.1m
-  }, []);
+  /* -------------------------------------------------------------------------- */
+  /*                          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' ||
+          isNaN(lat1) || isNaN(lon1) || isNaN(lat2) || isNaN(lon2)
+        ) return Infinity;
+
+        const toRad = (deg) => deg * Math.PI / 180;
+        const R = 6371e3; // meters
+        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 heightDifference = Math.abs(alt1 - alt2);
+        return Math.sqrt(surfaceDistance ** 2 + heightDifference ** 2);
+      } catch (err) {
+        console.error('[Geolocation Distance] Error:', err);
+        return Infinity;
+      }
+    },
+    []
+  );
 
-  /**
-   * 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;
+  const calculateSafeDistance = useCallback(
+    (point1, point2) => {
+      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);
+        return Infinity;
+      }
+    },
+    [calculateEnhancedDistance]
+  );
 
-    // 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;
-  }, []);
+  /* -------------------------------------------------------------------------- */
+  /*                                   GETTERS                                   */
+  /* -------------------------------------------------------------------------- */
+  const getCurrentWatchId = useCallback(() => locationWatchId.current, []);
 
   return {
-    requestLocationPermission: requestPermissions,
+    requestLocationPermission,
     getCurrentLocation,
-    startBluetoothScan,
-    stopBluetoothScan,
-    nearbyDevices,
+    stopLocationWatching,
+    getCurrentWatchId,
     calculateEnhancedDistance,
-    filterStaleDevices,
+    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,
+  };
+};