react-native-biometric-verifier 0.0.57 → 0.0.59

package/package.json

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

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,131 @@
 import { useCallback } from 'react';
-import { Platform, PermissionsAndroid } from 'react-native';
+import {
+  Platform,
+  PermissionsAndroid,
+  Linking,
+} from 'react-native';
 import Geolocation from 'react-native-geolocation-service';
 
 /**
- * Custom hook for requesting location permission and fetching current location.
+ * High-accuracy geolocation hook with GPS warm-up
  *
- * @param {Function} notifyMessage - Callback to show notifications (message, type).
- * @returns {Object} { requestLocationPermission, getCurrentLocation }
+ * @param {Function} notifyMessage - (message, type) => void
  */
 export const useGeolocation = (notifyMessage) => {
   /**
-   * Requests location permission (Android only).
-   * @returns {Promise<boolean>} - True if permission granted, else false.
+   * Request location permission (Android only)
    */
   const requestLocationPermission = useCallback(async () => {
-    if (Platform.OS !== 'android') return true;
+    if (Platform.OS !== 'android') {
+      return true;
+    }
 
     try {
-      const granted = await PermissionsAndroid.request(
+      const result = await PermissionsAndroid.requestMultiple([
         PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-        {
-          title: 'Location Permission Required',
-          message: 'This app needs your location to verify QR code scans.',
-          buttonPositive: 'OK',
-          buttonNegative: 'Cancel',
-        }
-      );
+        PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
+      ]);
 
-      const hasPermission = granted === PermissionsAndroid.RESULTS.GRANTED;
+      const fineGranted =
+        result[PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION] ===
+        PermissionsAndroid.RESULTS.GRANTED;
 
-      if (!hasPermission) {
-        notifyMessage?.('Cannot get location without permission.', 'error');
+      if (!fineGranted) {
+        notifyMessage?.(
+          'Precise location permission is required for accurate location.',
+          'error'
+        );
+        return false;
       }
 
-      return hasPermission;
+      return true;
     } catch (error) {
-      console.error('Location permission error:', error);
+      console.error('Permission error:', error);
       notifyMessage?.('Location permission error.', 'error');
       return false;
     }
   }, [notifyMessage]);
 
   /**
-   * Fetches the current location of the device.
-   * @returns {Promise<GeolocationCoordinates>}
+   * Get current location with GPS warm-up
    */
-  const getCurrentLocation = useCallback(
-    () =>
-      new Promise((resolve, reject) => {
-        Geolocation.getCurrentPosition(
-          (position) => {
+  const getCurrentLocation = useCallback(() => {
+    return new Promise(async (resolve, reject) => {
+      const hasPermission = await requestLocationPermission();
+      if (!hasPermission) {
+        return reject('Permission denied');
+      }
+
+      let watchId = null;
+      let timeoutId = null;
+
+      const cleanup = () => {
+        if (watchId !== null) {
+          Geolocation.clearWatch(watchId);
+        }
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      };
+
+      // Safety timeout (avoid infinite GPS wait)
+      timeoutId = setTimeout(() => {
+        cleanup();
+        notifyMessage?.(
+          'Unable to get accurate location. Please try again outdoors.',
+          'error'
+        );
+        reject('Location timeout');
+      }, 25000);
+
+      watchId = Geolocation.watchPosition(
+        (position) => {
+          const { accuracy } = position.coords;
+
+          /**
+           * Accept the location only when GPS is accurate enough
+           * Typical threshold: 15–25 meters
+           */
+          if (accuracy && accuracy <= 20) {
+            cleanup();
             resolve(position.coords);
-          },
-          (error) => {
-            notifyMessage?.('Unable to fetch current location.', 'error');
-            reject(error);
-          },
-          {
-            enableHighAccuracy: true,
-            timeout: 15000,
-            maximumAge: 10000,
-            distanceFilter: 1,
           }
-        );
-      }),
-    [notifyMessage]
-  );
+        },
+        (error) => {
+          cleanup();
+
+          // GPS disabled
+          if (error.code === 2) {
+            notifyMessage?.(
+              'Please enable GPS for accurate location.',
+              'warning'
+            );
+            Linking.openSettings();
+          } else {
+            notifyMessage?.('Unable to fetch location.', 'error');
+          }
+
+          reject(error);
+        },
+        {
+          enableHighAccuracy: true,
+          accuracy: {
+            android: 'high',
+            ios: 'best',
+          },
+          distanceFilter: 0,
+          interval: 1000,
+          fastestInterval: 500,
+          forceRequestLocation: true,
+          showLocationDialog: true,
+          maximumAge: 0,
+        }
+      );
+    });
+  }, [notifyMessage, requestLocationPermission]);
 
-  return { requestLocationPermission, getCurrentLocation };
+  return {
+    requestLocationPermission,
+    getCurrentLocation,
+  };
 };