react-native-biometric-verifier 0.0.55 → 0.0.57

package/src/utils/Global.js

@@ -42,5 +42,4 @@ export class Global {
     format: 'JPEG', // 'PNG' or 'JPEG'
     quality: 85, // 0–100
   };
-
 }

package/src/hooks/useBluetoothService.js

@@ -1,195 +0,0 @@
-import { useCallback, useState, useRef } from 'react';
-import { Platform, PermissionsAndroid } from 'react-native';
-import { BleManager } from 'react-native-ble-plx';
-
-const manager = new BleManager();
-
-/**
- * Bluetooth Service Hook for device scanning and distance estimation
- */
-export const useBluetoothService = (notifyMessage) => {
-  const [nearbyDevices, setNearbyDevices] = useState([]);
-  const scanTimeoutRef = useRef(null);
-
-  /* -------------------------------------------------------------------------- */
-  /*                           BLUETOOTH PERMISSIONS                             */
-  /* -------------------------------------------------------------------------- */
-  const requestBluetoothPermissions = useCallback(async () => {
-    if (Platform.OS !== 'android') return true;
-
-    try {
-      let permissions = [];
-      if (Platform.Version >= 31) {
-        permissions = [
-          PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
-          PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
-          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-        ];
-      } else {
-        permissions = [PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION];
-      }
-
-      const granted = await PermissionsAndroid.requestMultiple(permissions);
-      const allGranted = Object.values(granted).every(
-        status => status === PermissionsAndroid.RESULTS.GRANTED
-      );
-
-      if (!allGranted) {
-        notifyMessage?.('Bluetooth permissions are required for device scanning', 'warning');
-      }
-
-      return allGranted;
-    } catch (error) {
-      console.error('[Permissions] Error:', error);
-      notifyMessage?.('Failed to request Bluetooth permissions', 'error');
-      return false;
-    }
-  }, [notifyMessage]);
-
-  /* -------------------------------------------------------------------------- */
-  /*                           DISTANCE ESTIMATION                                */
-  /* -------------------------------------------------------------------------- */
-  const estimateDistance = useCallback((rssi, txPower = -59) => {
-    if (!rssi || rssi >= 0) return -1;
-
-    const n = 2.0;
-    const distance1 = Math.pow(10, (txPower - rssi) / (10 * n));
-    const distance2 = 0.89976 * Math.pow(Math.abs(rssi), 0.80976) + 0.111;
-    const avgDistance = (distance1 + distance2) / 2;
-
-    return Math.max(0.1, avgDistance);
-  }, []);
-
-  /* -------------------------------------------------------------------------- */
-  /*                            FILTER STALE 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;
-      })
-    );
-  }, []);
-
-  /* -------------------------------------------------------------------------- */
-  /*                              STOP SCAN                                      */
-  /* -------------------------------------------------------------------------- */
-  const stopBluetoothScan = useCallback(() => {
-    manager.stopDeviceScan();
-    if (scanTimeoutRef.current) {
-      clearTimeout(scanTimeoutRef.current);
-      scanTimeoutRef.current = null;
-    }
-  }, []);
-
-  /* -------------------------------------------------------------------------- */
-  /*                             START BLE SCAN                                   */
-  /* -------------------------------------------------------------------------- */
-  const startBluetoothScan = useCallback(async () => {
-    const permission = await requestBluetoothPermissions();
-    if (!permission) return;
-
-    setNearbyDevices([]);
-
-    const scanOptions = {
-      allowDuplicates: true,
-      scanMode: 2,
-    };
-
-    manager.startDeviceScan(null, scanOptions, (error, device) => {
-      if (error) {
-        console.error('[BLE] Scan error:', error);
-        stopBluetoothScan();
-
-        let errorMessage = 'Bluetooth scan failed';
-        if (error.errorCode === 102) errorMessage = 'Bluetooth is not enabled';
-        else if (error.errorCode === 103) errorMessage = 'Location services required for scanning';
-
-        notifyMessage?.(errorMessage, 'error');
-        return;
-      }
-
-      if (device && device.name && device.rssi) {
-        const distance = estimateDistance(device.rssi);
-
-        if (distance > 0 && distance <= 20) {
-          setNearbyDevices(prev => {
-            const existingIndex = prev.findIndex(d => d.id === device.id);
-            if (existingIndex >= 0) {
-              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,
-                txPowerLevel: device.txPowerLevel || existing.txPowerLevel,
-              };
-              return updated;
-            } else {
-              return [
-                ...prev,
-                {
-                  id: device.id,
-                  name: device.name || 'Unknown Device',
-                  rssi: device.rssi,
-                  distance: distance.toFixed(2),
-                  lastSeen: Date.now(),
-                  count: 1,
-                  manufacturerData: device.manufacturerData,
-                  serviceUUIDs: device.serviceUUIDs,
-                  txPowerLevel: device.txPowerLevel,
-                  isConnectable: device.isConnectable,
-                },
-              ];
-            }
-          });
-        }
-      }
-    });
-
-    scanTimeoutRef.current = setTimeout(() => {
-      stopBluetoothScan();
-      filterStaleDevices();
-    }, 10000);
-  }, [notifyMessage, requestBluetoothPermissions, stopBluetoothScan, filterStaleDevices, estimateDistance, nearbyDevices]);
-
-  /* -------------------------------------------------------------------------- */
-  /*                              DEVICE DETAILS                                  */
-  /* -------------------------------------------------------------------------- */
-  const getDeviceDetails = useCallback(async (deviceId) => {
-    try {
-      const device = await manager.connectToDevice(deviceId);
-      await device.discoverAllServicesAndCharacteristics();
-      const services = await device.services();
-
-      return { ...device, services, isConnected: true };
-    } catch (error) {
-      console.error('[BLE] Error getting device details:', error);
-      return null;
-    }
-  }, []);
-
-  /* -------------------------------------------------------------------------- */
-  /*                               CLEAR DEVICES                                  */
-  /* -------------------------------------------------------------------------- */
-  const clearDevices = useCallback(() => {
-    setNearbyDevices([]);
-  }, []);
-
-  return {
-    requestBluetoothPermission: requestBluetoothPermissions,
-    startBluetoothScan,
-    stopBluetoothScan,
-    nearbyDevices,
-    filterStaleDevices,
-    clearDevices,
-    getDeviceDetails,
-    estimateDistance,
-  };
-};

package/src/hooks/useWifiService.js

@@ -1,175 +0,0 @@
-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,
-  };
-};