react-native-biometric-verifier 0.0.6 → 0.0.8

package/package.json

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

package/src/components/EmployeeCard.js

@@ -2,10 +2,10 @@ import React, { useState } from 'react';
 import { View, Text, Image } from 'react-native';
 import Icon from 'react-native-vector-icons/MaterialIcons';
 import PropTypes from 'prop-types';
-import { COLORS ,GIF_URL,IMAGE_URL} from '../utils/constants';
+import { COLORS} from '../utils/constants';
 import { styles } from './styles';
 
-export const EmployeeCard = ({ employeeData }) => {
+export const EmployeeCard = ({ employeeData,apiurl }) => {
   const [imageError, setImageError] = useState(false);
 
   if (!employeeData || typeof employeeData !== 'object') {
@@ -18,8 +18,8 @@ export const EmployeeCard = ({ employeeData }) => {
   const employeeName = facename || 'Unknown Employee';
   const employeeId = faceid || 'N/A';
   const imageSource = !imageError && imageurl
-    ? { uri: `${IMAGE_URL}${imageurl}` }
-    : { uri: `${GIF_URL}camera.png` }; // Add a local fallback image in assets
+    ? { uri: `${apiurl}file/filedownload/photo/${imageurl}` }
+    : { uri: `${apiurl}file/getCommonFile/image/camera.png` }; // Add a local fallback image in assets
 
   return (
     <View style={styles.employeeCard}>

package/src/index.js

@@ -16,7 +16,6 @@ import {
   COLORS,
   COUNTDOWN_DURATION,
   MAX_DISTANCE_METERS,
-  RECOGNIZE_URL,
 } from './utils/constants';
 import Loader from './components/Loader';
 import { CountdownTimer } from './components/CountdownTimer';
@@ -28,9 +27,9 @@ import { useNavigation } from '@react-navigation/native';
 import networkServiceCall from './utils/NetworkServiceCall';
 import { getLoaderGif } from './utils/getLoaderGif';
 
-const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback }) => {
+const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback, apiurl }) => {
   const navigation = useNavigation();
-  
+
   const { countdown, startCountdown, resetCountdown } = useCountdown();
   const { requestLocationPermission, getCurrentLocation } = useGeolocation();
   const { convertImageToBase64 } = useImageProcessing();
@@ -46,6 +45,23 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback
 
   const dataRef = useRef(data);
   const mountedRef = useRef(true);
+  const responseRef = useRef(null);
+
+  const safeCallback = useCallback(
+    (response) => {
+      if (typeof callback === 'function') {
+        try {
+          callback(response);
+        } catch (err) {
+          console.error('Callback execution failed:', err);
+          notifyMessage('Unexpected error while processing callback.', 'error');
+        }
+      } else {
+        console.log('Biometric Verification Response:', response);
+      }
+    },
+    [callback, notifyMessage]
+  );
 
   useEffect(() => {
     return () => {
@@ -59,7 +75,7 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback
 
   const updateState = useCallback((newState) => {
     if (mountedRef.current) {
-      setState(prev => ({ ...prev, ...newState }));
+      setState((prev) => ({ ...prev, ...newState }));
     }
   }, []);
 
@@ -73,68 +89,95 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback
     resetCountdown();
   }, [resetCountdown, updateState]);
 
-  const handleCountdownFinish = useCallback(() => {
-    notifyMessage('Time is up! Please try again.', 'error');
-    updateState({
-      modalVisible: false,
-      animationState: ANIMATION_STATES.ERROR,
-    });
-    resetState();
-    navigation.goBack();
-  }, [navigation, notifyMessage, resetState, updateState]);
-
-  const uploadFaceScan = useCallback(async (selfie) => {
-    const currentData = dataRef.current;
-    const base64 = await convertImageToBase64(selfie.uri);
-    if (!currentData) {
-      notifyMessage('Employee data not found.', 'error');
-      updateState({ animationState: ANIMATION_STATES.ERROR });
-      return;
-    }
-    if (!base64) {
-      notifyMessage('convert Image To Base64 Failed.', 'error');
+  const handleProcessError = useCallback(
+    (message, errorObj = null) => {
+      if (errorObj) console.error(message, errorObj);
+      notifyMessage(message, 'error');
       updateState({ animationState: ANIMATION_STATES.ERROR });
-      return;
+      setTimeout(resetState, 1200);
+    },
+    [notifyMessage, resetState, updateState]
+  );
+
+  const handleCountdownFinish = useCallback(() => {
+    handleProcessError('Time is up! Please try again.');
+    updateState({ modalVisible: false });
+    if (navigation.canGoBack()) navigation.goBack();
+  }, [handleProcessError, navigation, updateState]);
+
+  const validateApiUrl = useCallback(() => {
+    if (!apiurl || typeof apiurl !== 'string') {
+      handleProcessError('Invalid API URL configuration.');
+      return false;
     }
+    return true;
+  }, [apiurl, handleProcessError]);
 
-    updateState({
-      isLoading: true,
-      animationState: ANIMATION_STATES.PROCESSING,
-    });
+  const uploadFaceScan = useCallback(
+    async (selfie) => {
+      if (!validateApiUrl()) return;
+
+      const currentData = dataRef.current;
+      if (!currentData) {
+        handleProcessError('Employee data not found.');
+        return;
+      }
+
+      let base64;
+      try {
+        base64 = await convertImageToBase64(selfie?.uri);
+      } catch (err) {
+        handleProcessError('Image conversion failed.', err);
+        return;
+      }
+
+      if (!base64) {
+        handleProcessError('Failed to process image.');
+        return;
+      }
 
-    try {
-      const body = { image: base64 }
-      const header = { faceid: currentData }
-      const response = await networkServiceCall("POST",RECOGNIZE_URL,header,body);
-      if (response.httpstatus === 200) {
-        notifyMessage('Identity verified successfully!', 'success');
-        updateState({
-          employeeData: response.data?.data,
-          animationState: ANIMATION_STATES.SUCCESS,
-        });
-
-        if (qrscan) {
-          // If QR scanning is required, continue with QR Scan
-          setTimeout(() => startQRCodeScan(), 1500);
+      updateState({
+        isLoading: true,
+        animationState: ANIMATION_STATES.PROCESSING,
+      });
+
+      try {
+        const body = { image: base64 };
+        const header = { faceid: currentData };
+        const buttonapi = `${apiurl}python/recognize`;
+        console.log('buttonapi', buttonapi);
+        const response = await networkServiceCall('POST', buttonapi, header, body);
+
+        if (response?.httpstatus === 200) {
+          responseRef.current = response;
+          updateState({
+            employeeData: response.data?.data || null,
+            animationState: ANIMATION_STATES.SUCCESS,
+          });
+          notifyMessage('Identity verified successfully!', 'success');
+
+          if (qrscan) {
+            setTimeout(() => startQRCodeScan(), 1500);
+          } else {
+            setTimeout(() => {
+              safeCallback(responseRef.current);
+              updateState({ modalVisible: false });
+              resetState();
+            }, 1500);
+          }
         } else {
-          // If only Face recognition → finish process
-          setTimeout(() => {
-            callback?.(dataRef.current);
-            updateState({ modalVisible: false });
-            resetState();
-          }, 1500);
+          handleProcessError(
+            response?.data?.error?.message || 'Face not recognized. Please try again.'
+          );
         }
-      } else {
-        updateState({ animationState: ANIMATION_STATES.ERROR });
-        notifyMessage(response.data?.error?.message || 'Face not recognized. Please try again.', 'error');
+      } catch (error) {
+        handleProcessError('Connection error. Please check your network.', error);
+      } finally {
+        updateState({ isLoading: false });
       }
-    } catch (error) {
-      updateState({ animationState: ANIMATION_STATES.ERROR });
-      notifyMessage('Connection error. Please check your network.', 'error');
-    } finally {
-      updateState({ isLoading: false });
-    }
-  }, [convertImageToBase64, notifyMessage, qrscan, resetState, updateState, callback]);
+    },
+    [convertImageToBase64, notifyMessage, qrscan, resetState, updateState, validateApiUrl, safeCallback]
+  );
 
   const handleStartFaceScan = useCallback(() => {
     updateState({
@@ -161,70 +204,62 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback
     });
   }, [navigation, updateState]);
 
-  const handleQRScanned = useCallback(async (qrCodeData) => {
-    updateState({ 
-      animationState: ANIMATION_STATES.PROCESSING,
-      isLoading: true 
-    });
-
-    try {
-      const hasPermission = await requestLocationPermission();
-      if (!hasPermission) {
-        notifyMessage('Location permission not granted.', 'error');
-        updateState({ animationState: ANIMATION_STATES.ERROR });
-        return;
-      }
-
-      const qrString = typeof qrCodeData === 'object' ? qrCodeData.data : qrCodeData;
-      if (!qrString || typeof qrString !== 'string') {
-        notifyMessage('Invalid QR code. Please try again.', 'error');
-        updateState({ animationState: ANIMATION_STATES.ERROR });
-        return;
-      }
-
-      const location = await getCurrentLocation();
-      const [latStr, lngStr] = qrString.split(',');
-      const lat = parseFloat(latStr);
-      const lng = parseFloat(lngStr);
+  const handleQRScanned = useCallback(
+    async (qrCodeData) => {
+      if (!validateApiUrl()) return;
 
-      const validCoords = !isNaN(lat) && !isNaN(lng);
-      const validDev = !isNaN(location.latitude) && !isNaN(location.longitude);
+      updateState({
+        animationState: ANIMATION_STATES.PROCESSING,
+        isLoading: true,
+      });
 
-      if (validCoords && validDev) {
-        const distance = getDistanceInMeters(
-          lat,
-          lng,
-          location.latitude,
-          location.longitude
-        );
+      try {
+        const hasPermission = await requestLocationPermission();
+        if (!hasPermission) {
+          handleProcessError('Location permission not granted.');
+          return;
+        }
 
-        if (distance <= MAX_DISTANCE_METERS) {
-          callback?.(dataRef.current);
-          notifyMessage('Location verified successfully!', 'success');
-          updateState({ animationState: ANIMATION_STATES.SUCCESS });
+        const qrString = typeof qrCodeData === 'object' ? qrCodeData?.data : qrCodeData;
+        if (!qrString || typeof qrString !== 'string') {
+          handleProcessError('Invalid QR code. Please try again.');
+          return;
+        }
 
-          setTimeout(() => {
-            updateState({ modalVisible: false });
-            resetState();
-          }, 1500);
+        const location = await getCurrentLocation();
+        const [latStr, lngStr] = qrString.split(',');
+        const lat = parseFloat(latStr);
+        const lng = parseFloat(lngStr);
+
+        const validCoords = !isNaN(lat) && !isNaN(lng);
+        const validDev = !isNaN(location?.latitude) && !isNaN(location?.longitude);
+
+        if (validCoords && validDev) {
+          const distance = getDistanceInMeters(lat, lng, location.latitude, location.longitude);
+
+          if (distance <= MAX_DISTANCE_METERS) {
+            safeCallback(responseRef.current);
+            notifyMessage('Location verified successfully!', 'success');
+            updateState({ animationState: ANIMATION_STATES.SUCCESS });
+
+            setTimeout(() => {
+              updateState({ modalVisible: false });
+              resetState();
+            }, 1500);
+          } else {
+            handleProcessError(`Location mismatch (${distance.toFixed(0)}m away).`);
+          }
         } else {
-          notifyMessage(`Location mismatch (${distance.toFixed(0)}m away).`, 'error');
-          updateState({ animationState: ANIMATION_STATES.ERROR });
-          resetState();
+          handleProcessError('Invalid coordinates in QR code.');
         }
-      } else {
-        notifyMessage('Invalid coordinates in QR code.', 'error');
-        updateState({ animationState: ANIMATION_STATES.ERROR });
-        resetState();
+      } catch (error) {
+        handleProcessError('Unable to verify location. Please try again.', error);
+      } finally {
+        updateState({ isLoading: false });
       }
-    } catch (error) {
-      notifyMessage('Unable to verify location. Please try again.', 'error');
-      updateState({ animationState: ANIMATION_STATES.ERROR });
-      resetState();
-    } finally {
-      updateState({ isLoading: false });
-    }
-  }, [callback, getCurrentLocation, notifyMessage, requestLocationPermission, resetState, updateState]);
+    },
+    [getCurrentLocation, notifyMessage, requestLocationPermission, resetState, updateState, validateApiUrl, safeCallback]
+  );
 
   const startProcess = useCallback(() => {
     startCountdown(COUNTDOWN_DURATION, handleCountdownFinish);
@@ -268,10 +303,7 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback
         <StateIndicator state={state.animationState} size={120} />
 
         {state.employeeData && (
-          <EmployeeCard
-            employeeData={state.employeeData}
-            hrenemp={dataRef.current?.data?.userdata?.hrenemp}
-          />
+          <EmployeeCard employeeData={state.employeeData} apiurl={apiurl} />
         )}
 
         <Notification
@@ -280,14 +312,12 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback
           slideAnim={slideAnim}
         />
 
-        <CountdownTimer
-          duration={COUNTDOWN_DURATION}
-          currentTime={countdown}
-        />
+        <CountdownTimer duration={COUNTDOWN_DURATION} currentTime={countdown} />
 
-        {state.isLoading && getLoaderGif(state.animationState, state.currentStep) && (
-          <Loader source={getLoaderGif(state.animationState, state.currentStep)} />
-        )}
+        {state.isLoading &&
+          getLoaderGif(state.animationState, state.currentStep, apiurl) && (
+            <Loader source={getLoaderGif(state.animationState, state.currentStep, apiurl)} />
+          )}
       </View>
     </Modal>
   );

package/src/utils/constants.js

@@ -1,15 +1,3 @@
-import { Global } from "./Global";
-
-// ====== BASE CONFIG ======
-export const BASE_URL = Global.ipAddress;
-export const PORT = Global.port;
-export const APIURL = `http://${BASE_URL}:${PORT}/`;
-
-// ====== API ENDPOINTS ======
-export const RECOGNIZE_URL = APIURL + "python/recognize";
-export const IMAGE_URL = APIURL + "file/filedownload/photo/";
-export const GIF_URL = APIURL + "file/getCommonFile/image/";
-
 
 // ====== COLORS ======
 export const COLORS = {

package/src/utils/getLoaderGif.js

@@ -1,4 +1,4 @@
-import { ANIMATION_STATES, GIF_URL } from '../utils/constants';
+import { ANIMATION_STATES} from '../utils/constants';
 
 /**
  * Decides which GIF should be shown based on animationState or currentStep
@@ -6,11 +6,11 @@ import { ANIMATION_STATES, GIF_URL } from '../utils/constants';
  * @param {string} currentStep - Current step of verification
  * @returns {any} - Gif image source or null
  */
-export const getLoaderGif = (animationState, currentStep) => {
+export const getLoaderGif = (animationState, currentStep,APIURL) => {
   const FaceGifUrl =
-    `${GIF_URL}Face.gif`;
+    `${APIURL}file/getCommonFile/image/Face.gif`;
   const LocationGifUrl =
-    `${GIF_URL}Location.gif`;
+    `${APIURL}file/getCommonFile/image/Location.gif`;
 
   if (
     animationState === ANIMATION_STATES.FACE_SCAN ||

package/src/utils/Global.js

@@ -1,6 +0,0 @@
-export class Global {
-    static ipAddress = "api.amalaplus.org";
-    static port = "9090";
-
-}
-