react-native-biometric-verifier 0.0.43 → 0.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-biometric-verifier",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "description": "A React Native module for biometric verification with face recognition and QR code scanning",
   "main": "src/index.js",
   "private": false,

package/src/components/Notification.js

@@ -1,32 +1,23 @@
 import React, { useEffect, useRef } from 'react';
 import { Animated, Text, Platform, StyleSheet } from 'react-native';
 import Icon from 'react-native-vector-icons/MaterialIcons';
-import PropTypes from 'prop-types';
 import { Global } from '../utils/Global';
 
-export const Notification = ({ notification, fadeAnim, slideAnim }) => {
-  if (!notification || typeof notification !== 'object') {
-    console.warn('Notification: Invalid or missing notification object');
-    return null;
-  }
+export const Notification = ({ notification = {}, fadeAnim, slideAnim }) => {
+  const { visible = false, type = 'info', message = '' } = notification;
 
-  const { visible, type = 'info', message = '' } = notification;
-  if (!visible) return null;
+  // Animations (must ALWAYS exist)
+  const scaleAnim = useRef(new Animated.Value(1)).current;
+  const shakeAnim = useRef(new Animated.Value(0)).current;
 
-  // Icon and color mapping
   const iconMap = {
     success: { name: 'check-circle', color: Global.AppTheme.success },
     error: { name: 'error', color: Global.AppTheme.error },
     info: { name: 'info', color: Global.AppTheme.info },
   };
 
-  const { name: iconName, color: iconColor } = iconMap[type] || iconMap.info;
-
-  // Heartbeat animation (scale in/out)
-  const scaleAnim = useRef(new Animated.Value(1)).current;
-
-  // Shake animation (rotation wiggle)
-  const shakeAnim = useRef(new Animated.Value(0)).current;
+  const { name: iconName, color: iconColor } =
+    iconMap[type] || iconMap.info;
 
   useEffect(() => {
     const heartbeat = Animated.loop(
@@ -78,20 +69,20 @@ export const Notification = ({ notification, fadeAnim, slideAnim }) => {
       heartbeat.stop();
       shake.stop();
     };
-  }, [visible, type, scaleAnim, shakeAnim]);
+  }, [visible, type]);
 
-  // Shake rotation mapping (small wiggle)
-  const shakeInterpolate = shakeAnim.interpolate({
+  const shakeRotate = shakeAnim.interpolate({
     inputRange: [-1, 1],
     outputRange: ['-10deg', '10deg'],
   });
 
   return (
     <Animated.View
+      pointerEvents={visible ? 'auto' : 'none'}
       style={[
         styles.container,
         {
-          opacity: fadeAnim instanceof Animated.Value ? fadeAnim : 1,
+          opacity: visible ? 1 : 0,
           transform: [
             { translateY: slideAnim instanceof Animated.Value ? slideAnim : 0 },
           ],
@@ -102,12 +93,13 @@ export const Notification = ({ notification, fadeAnim, slideAnim }) => {
         style={{
           transform: [
             { scale: scaleAnim },
-            ...(type === 'error' ? [{ rotate: shakeInterpolate }] : []),
+            ...(type === 'error' ? [{ rotate: shakeRotate }] : []),
           ],
         }}
       >
-        <Icon name={iconName} size={50} color={iconColor} style={styles.icon} />
+        <Icon name={iconName} size={50} color={iconColor} />
       </Animated.View>
+
       <Text style={styles.message}>
         {message || 'No message provided'}
       </Text>
@@ -142,20 +134,4 @@ const styles = StyleSheet.create({
   },
 });
 
-Notification.propTypes = {
-  notification: PropTypes.shape({
-    visible: PropTypes.bool.isRequired,
-    type: PropTypes.oneOf(['success', 'error', 'info']),
-    message: PropTypes.string,
-  }),
-  fadeAnim: PropTypes.instanceOf(Animated.Value),
-  slideAnim: PropTypes.instanceOf(Animated.Value),
-};
-
-Notification.defaultProps = {
-  notification: { visible: false, type: 'info', message: '' },
-  fadeAnim: new Animated.Value(1),
-  slideAnim: new Animated.Value(0),
-};
-
 export default Notification;

package/src/hooks/useGeolocation.js

@@ -1,71 +1,299 @@
-import { useCallback } from 'react';
+// Enhanced location service
+import { useCallback, useState, 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();
 
 /**
- * Custom hook for requesting location permission and fetching current location.
- *
- * @param {Function} notifyMessage - Callback to show notifications (message, type).
- * @returns {Object} { requestLocationPermission, getCurrentLocation }
+ * Enhanced Geolocation Hook with better accuracy
  */
 export const useGeolocation = (notifyMessage) => {
+  const [nearbyDevices, setNearbyDevices] = useState([]);
+  const scanTimeoutRef = useRef(null);
+  const locationWatchId = useRef(null);
+
   /**
-   * Requests location permission (Android only).
-   * @returns {Promise<boolean>} - True if permission granted, else false.
+   * Request high-accuracy permissions
    */
-  const requestLocationPermission = useCallback(async () => {
-    if (Platform.OS !== 'android') return true;
-
-    try {
-      const granted = await PermissionsAndroid.request(
-        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-        {
-          title: 'Location Permission Required',
-          message: 'This app needs your location to verify QR code scans.',
-          buttonPositive: 'OK',
-          buttonNegative: 'Cancel',
-        }
-      );
+  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,
+        ]);
 
-      const hasPermission = granted === PermissionsAndroid.RESULTS.GRANTED;
+        // Check Android version for background location
+        if (Platform.Version >= 29) {
+          await PermissionsAndroid.request(
+            PermissionsAndroid.PERMISSIONS.ACCESS_BACKGROUND_LOCATION
+          );
+        }
 
-      if (!hasPermission) {
-        notifyMessage?.('Cannot get location without permission.', 'error');
+        return Object.values(granted).every(
+          status => status === PermissionsAndroid.RESULTS.GRANTED
+        );
+      } catch (error) {
+        console.error('[Permissions] Error:', error);
+        return false;
       }
-
-      return hasPermission;
-    } catch (error) {
-      console.error('Location permission error:', error);
-      notifyMessage?.('Location permission error.', 'error');
-      return false;
     }
-  }, [notifyMessage]);
+    return true; // iOS handles permissions differently
+  }, []);
 
   /**
-   * Fetches the current location of the device.
-   * @returns {Promise<GeolocationCoordinates>}
+   * Get high-accuracy location with multiple attempts
    */
   const getCurrentLocation = useCallback(
     () =>
-      new Promise((resolve, reject) => {
-        Geolocation.getCurrentPosition(
-          (position) => {
-            resolve(position.coords);
-          },
-          (error) => {
-            notifyMessage?.('Unable to fetch current location.', 'error');
-            reject(error);
-          },
-          {
-            enableHighAccuracy: true,
-            timeout: 15000,
-            maximumAge: 10000,
-            distanceFilter: 1,
+      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;
+
+            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);
+          });
+        };
+
+        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]
   );
 
-  return { requestLocationPermission, getCurrentLocation };
-};
+  /**
+   * Stop Bluetooth scan
+   */
+  const stopBluetoothScan = useCallback(() => {
+    console.log('[BLE] Stopping Bluetooth scan...');
+    manager.stopDeviceScan();
+    if (scanTimeoutRef.current) {
+      clearTimeout(scanTimeoutRef.current);
+      scanTimeoutRef.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;
+    }
+
+    setNearbyDevices([]);
+    
+    // Configure scan for better accuracy
+    const scanOptions = {
+      allowDuplicates: true,
+      scanMode: 2, // SCAN_MODE_LOW_LATENCY for Android
+    };
+
+    manager.startDeviceScan(null, scanOptions, (error, device) => {
+      if (error) {
+        console.error('[BLE] Scan error:', error);
+        stopBluetoothScan();
+        return;
+      }
+
+      if (device && device.name && device.rssi) {
+        const distance = estimateDistance(device.rssi);
+        
+        // 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];
+            }
+          });
+        }
+      }
+    });
+
+    // 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
+  }, []);
+
+  /**
+   * 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;
+  }, []);
+
+  return {
+    requestLocationPermission: requestPermissions,
+    getCurrentLocation,
+    startBluetoothScan,
+    stopBluetoothScan,
+    nearbyDevices,
+    calculateEnhancedDistance,
+    filterStaleDevices,
+  };
+};