react-native-biometric-verifier 0.0.55 → 0.0.57

package/src/hooks/useGeolocation.js

@@ -1,249 +1,71 @@
-import { useCallback, useRef } from 'react';
+import { useCallback } from 'react';
 import { Platform, PermissionsAndroid } from 'react-native';
 import Geolocation from 'react-native-geolocation-service';
 
 /**
- * FAST + ACCURATE Geolocation Hook (Optimized for Verification)
+ * Custom hook for requesting location permission and fetching current location.
+ *
+ * @param {Function} notifyMessage - Callback to show notifications (message, type).
+ * @returns {Object} { requestLocationPermission, getCurrentLocation }
  */
 export const useGeolocation = (notifyMessage) => {
-  const locationWatchId = useRef(null);
-
-  /* -------------------------------------------------------------------------- */
-  /*                               PERMISSIONS                                   */
-  /* -------------------------------------------------------------------------- */
+  /**
+   * Requests location permission (Android only).
+   * @returns {Promise<boolean>} - True if permission granted, else false.
+   */
   const requestLocationPermission = useCallback(async () => {
-    try {
-      if (Platform.OS !== 'android') return true;
+    if (Platform.OS !== 'android') return true;
 
-      const permissions = [
+    try {
+      const granted = await PermissionsAndroid.request(
         PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-        PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
-      ];
-
-      const result = await PermissionsAndroid.requestMultiple(permissions);
-
-      const granted = Object.values(result).every(
-        status => status === PermissionsAndroid.RESULTS.GRANTED
+        {
+          title: 'Location Permission Required',
+          message: 'This app needs your location to verify QR code scans.',
+          buttonPositive: 'OK',
+          buttonNegative: 'Cancel',
+        }
       );
 
-      if (!granted) {
-        notifyMessage?.('Location permissions missing', 'warning');
+      const hasPermission = granted === PermissionsAndroid.RESULTS.GRANTED;
+
+      if (!hasPermission) {
+        notifyMessage?.('Cannot get location without permission.', 'error');
       }
 
-      return granted;
-    } catch (err) {
-      console.error('[Geo Permissions]', err);
+      return hasPermission;
+    } catch (error) {
+      console.error('Location permission error:', error);
+      notifyMessage?.('Location permission error.', 'error');
       return false;
     }
   }, [notifyMessage]);
 
-  /* -------------------------------------------------------------------------- */
-  /*                           STOP LOCATION WATCH                               */
-  /* -------------------------------------------------------------------------- */
-  const stopLocationWatching = useCallback(() => {
-    if (locationWatchId.current !== null) {
-      Geolocation.clearWatch(locationWatchId.current);
-      locationWatchId.current = null;
-    }
-  }, []);
-
-  /* -------------------------------------------------------------------------- */
-  /*                     FAST + ACCURATE LOCATION FETCH                          */
-  /* -------------------------------------------------------------------------- */
-  const getCurrentLocation = useCallback((options = {}) => {
-    return new Promise((resolve, reject) => {
-      let samples = [];
-      let resolved = false;
-
-      const defaultOptions = {
-        enableHighAccuracy: true,
-        timeout: 8000,           // ⏱ fast
-        maximumAge: 2000,        // allow cached fix
-        forceRequestLocation: true,
-        showLocationDialog: true,
-        interval: 800,
-        fastestInterval: 500,
-        distanceFilter: 0,
-        ...options,
-      };
-
-      try {
-        /* ---------------- FAST FIRST FIX ---------------- */
+  /**
+   * Fetches the current location of the device.
+   * @returns {Promise<GeolocationCoordinates>}
+   */
+  const getCurrentLocation = useCallback(
+    () =>
+      new Promise((resolve, reject) => {
         Geolocation.getCurrentPosition(
-          (pos) => {
-            if (!pos?.coords || resolved) return;
-
-            const {
-              latitude,
-              longitude,
-              accuracy,
-              altitude = 0,
-              speed = 0,
-              heading = 0,
-            } = pos.coords;
-
-            // Accept immediately if good enough for verification
-            if (accuracy <= 15) {
-              resolved = true;
-              resolve({
-                latitude,
-                longitude,
-                altitude,
-                accuracy,
-                speed,
-                heading,
-                timestamp: pos.timestamp,
-              });
-            }
-
-            samples.push({
-              latitude,
-              longitude,
-              altitude,
-              accuracy,
-              speed,
-              heading,
-              timestamp: pos.timestamp,
-            });
-          },
-          (err) => {
-            console.warn('[Geo Fast Fix Failed]', err);
-          },
-          defaultOptions
-        );
-
-        /* ---------------- BACKGROUND IMPROVEMENT ---------------- */
-        locationWatchId.current = Geolocation.watchPosition(
-          (p) => {
-            if (!p?.coords) return;
-
-            const {
-              latitude,
-              longitude,
-              accuracy,
-              altitude = 0,
-              speed = 0,
-              heading = 0,
-            } = p.coords;
-
-            /* -------- LIGHT NOISE FILTERS -------- */
-            if (accuracy > 40) return;
-            if (speed > 50) return;
-
-            samples.push({
-              latitude,
-              longitude,
-              altitude,
-              accuracy,
-              speed,
-              heading,
-              timestamp: p.timestamp,
-            });
-
-            if (samples.length > 8) samples.shift();
-
-            samples.sort((a, b) => a.accuracy - b.accuracy);
-            const best = samples[0];
-
-            // Upgrade accuracy silently
-            if (best.accuracy <= 6 && !resolved) {
-              resolved = true;
-              stopLocationWatching();
-              resolve(best);
-            }
+          (position) => {
+            resolve(position.coords);
           },
-          (err) => {
-            console.error('[Geo Watch Error]', err);
-            stopLocationWatching();
+          (error) => {
+            notifyMessage?.('Unable to fetch current location.', 'error');
+            reject(error);
           },
-          defaultOptions
-        );
-
-        /* ---------------- HARD STOP ---------------- */
-        setTimeout(() => {
-          if (!resolved && samples.length) {
-            resolved = true;
-            stopLocationWatching();
-            samples.sort((a, b) => a.accuracy - b.accuracy);
-            resolve(samples[0]);
+          {
+            enableHighAccuracy: true,
+            timeout: 15000,
+            maximumAge: 10000,
+            distanceFilter: 1,
           }
-        }, 5000);
-      } catch (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'
-        ) return Infinity;
-
-        const toRad = deg => deg * Math.PI / 180;
-        const R = 6371e3;
-
-        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 heightDiff = Math.abs(alt1 - alt2);
-        return Math.sqrt(surfaceDistance ** 2 + heightDiff ** 2);
-      } catch {
-        return Infinity;
-      }
-    },
-    []
-  );
-
-  const calculateSafeDistance = useCallback(
-    (p1, p2) => {
-      try {
-        const lat1 = p1.latitude ?? p1.lat;
-        const lon1 = p1.longitude ?? p1.lng ?? p1.lon;
-        const alt1 = p1.altitude ?? p1.alt ?? 0;
-
-        const lat2 = p2.latitude ?? p2.lat;
-        const lon2 = p2.longitude ?? p2.lng ?? p2.lon;
-        const alt2 = p2.altitude ?? p2.alt ?? 0;
-
-        return calculateEnhancedDistance(
-          lat1, lon1, lat2, lon2, alt1, alt2
         );
-      } catch {
-        return Infinity;
-      }
-    },
-    [calculateEnhancedDistance]
+      }),
+    [notifyMessage]
   );
 
-  /* -------------------------------------------------------------------------- */
-  /*                                   API                                       */
-  /* -------------------------------------------------------------------------- */
-  return {
-    requestLocationPermission,
-    getCurrentLocation,
-    stopLocationWatching,
-    getCurrentWatchId: () => locationWatchId.current,
-    calculateEnhancedDistance,
-    calculateSafeDistance,
-  };
+  return { requestLocationPermission, getCurrentLocation };
 };