react-native-biometric-verifier 0.0.47 → 0.0.48

package/src/hooks/useGeolocation.js

@@ -3,200 +3,218 @@ import { Platform, PermissionsAndroid } from 'react-native';
 import Geolocation from 'react-native-geolocation-service';
 
 /**
- * Enhanced Geolocation Hook with better accuracy
+ * Geolocation Hook for GPS functionality
  */
 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
-          );
-        }
+  /* -------------------------------------------------------------------------- */
+  /*                               PERMISSIONS                                   */
+  /* -------------------------------------------------------------------------- */
+  const requestLocationPermission = useCallback(async () => {
+    try {
+      if (Platform.OS !== 'android') return true;
 
-        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;
+      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 result = await PermissionsAndroid.requestMultiple(permissions);
 
-        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);
-          });
-        };
+      const granted = Object.values(result).every(
+        status => status === PermissionsAndroid.RESULTS.GRANTED
+      );
 
-        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);
-          
-          // 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');
+      }
 
-  /**
-   * Stop location watching
-   */
+      return granted;
+    } catch (err) {
+      console.error('[Geolocation Permissions] Error:', err);
+      return false;
+    }
+  }, [notifyMessage]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                           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;
-  }, []);
+  /* -------------------------------------------------------------------------- */
+  /*                            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,
+      };
+
+      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);
+              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]);
+
+  /* -------------------------------------------------------------------------- */
+  /*                          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;
+      }
+    },
+    []
+  );
+
+  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]
+  );
+
+  /* -------------------------------------------------------------------------- */
+  /*                                   GETTERS                                   */
+  /* -------------------------------------------------------------------------- */
+  const getCurrentWatchId = useCallback(() => locationWatchId.current, []);
 
   return {
-    requestLocationPermission: requestLocationPermissions,
+    requestLocationPermission,
     getCurrentLocation,
     stopLocationWatching,
+    getCurrentWatchId,
     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,
+  };
+};