react-native-biometric-verifier 0.0.7 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-biometric-verifier",
-  "version": "0.0.7",
+  "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/index.js

@@ -45,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 () => {
@@ -58,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 }));
     }
   }, []);
 
@@ -72,100 +89,95 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback,
     resetCountdown();
   }, [resetCountdown, updateState]);
 
+  const handleProcessError = useCallback(
+    (message, errorObj = null) => {
+      if (errorObj) console.error(message, errorObj);
+      notifyMessage(message, 'error');
+      updateState({ animationState: ANIMATION_STATES.ERROR });
+      setTimeout(resetState, 1200);
+    },
+    [notifyMessage, resetState, updateState]
+  );
+
   const handleCountdownFinish = useCallback(() => {
-    notifyMessage('Time is up! Please try again.', 'error');
-    updateState({
-      modalVisible: false,
-      animationState: ANIMATION_STATES.ERROR,
-    });
-    resetState();
+    handleProcessError('Time is up! Please try again.');
+    updateState({ modalVisible: false });
     if (navigation.canGoBack()) navigation.goBack();
-  }, [navigation, notifyMessage, resetState, updateState]);
+  }, [handleProcessError, navigation, updateState]);
 
   const validateApiUrl = useCallback(() => {
     if (!apiurl || typeof apiurl !== 'string') {
-      notifyMessage('Invalid API URL configuration.', 'error');
-      updateState({ animationState: ANIMATION_STATES.ERROR });
+      handleProcessError('Invalid API URL configuration.');
       return false;
     }
     return true;
-  }, [apiurl, notifyMessage, updateState]);
-
-  const uploadFaceScan = useCallback(async (selfie) => {
-    if (!validateApiUrl()) return;
-
-    const currentData = dataRef.current;
-    if (!currentData) {
-      notifyMessage('Employee data not found.', 'error');
-      updateState({ animationState: ANIMATION_STATES.ERROR });
-      return;
-    }
+  }, [apiurl, handleProcessError]);
 
-    let base64;
-    try {
-      base64 = await convertImageToBase64(selfie?.uri);
-    } catch (err) {
-      notifyMessage('Image conversion failed.', 'error');
-      updateState({ animationState: ANIMATION_STATES.ERROR });
-      return;
-    }
-
-    if (!base64) {
-      notifyMessage('Failed to process image.', 'error');
-      updateState({ animationState: ANIMATION_STATES.ERROR });
-      return;
-    }
-
-    updateState({
-      isLoading: true,
-      animationState: ANIMATION_STATES.PROCESSING,
-    });
-
-    try {
-      const body = { image: base64 };
-      const header = { faceid: currentData };
-      const buttonapi = `${apiurl}python/recognize`;
+  const uploadFaceScan = useCallback(
+    async (selfie) => {
+      if (!validateApiUrl()) return;
 
-      console.log("buttonapi--------------------", buttonapi);
+      const currentData = dataRef.current;
+      if (!currentData) {
+        handleProcessError('Employee data not found.');
+        return;
+      }
 
-      const response = await networkServiceCall("POST", buttonapi, header, body);
+      let base64;
+      try {
+        base64 = await convertImageToBase64(selfie?.uri);
+      } catch (err) {
+        handleProcessError('Image conversion failed.', err);
+        return;
+      }
 
-      if (response?.httpstatus === 200) {
-        notifyMessage('Identity verified successfully!', 'success');
-        updateState({
-          employeeData: response.data?.data || null,
-          animationState: ANIMATION_STATES.SUCCESS,
-        });
+      if (!base64) {
+        handleProcessError('Failed to process image.');
+        return;
+      }
 
-        if (qrscan) {
-          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 {
-          setTimeout(() => {
-            try {
-              callback?.(dataRef.current);
-            } catch (err) {
-              console.error("Callback execution failed:", err);
-              notifyMessage('Unexpected error after verification.', 'error');
-            }
-            updateState({ modalVisible: false });
-            resetState();
-          }, 1500);
+          handleProcessError(
+            response?.data?.error?.message || 'Face not recognized. Please try again.'
+          );
         }
-      } else {
-        notifyMessage(
-          response?.data?.error?.message || 'Face not recognized. Please try again.',
-          'error'
-        );
-        updateState({ animationState: ANIMATION_STATES.ERROR });
+      } catch (error) {
+        handleProcessError('Connection error. Please check your network.', error);
+      } finally {
+        updateState({ isLoading: false });
       }
-    } catch (error) {
-      console.error("Face recognition API error:", error);
-      notifyMessage('Connection error. Please check your network.', 'error');
-      updateState({ animationState: ANIMATION_STATES.ERROR });
-    } finally {
-      updateState({ isLoading: false });
-    }
-  }, [convertImageToBase64, notifyMessage, qrscan, resetState, updateState, callback, validateApiUrl]);
+    },
+    [convertImageToBase64, notifyMessage, qrscan, resetState, updateState, validateApiUrl, safeCallback]
+  );
 
   const handleStartFaceScan = useCallback(() => {
     updateState({
@@ -192,74 +204,62 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback,
     });
   }, [navigation, updateState]);
 
-  const handleQRScanned = useCallback(async (qrCodeData) => {
-    if (!validateApiUrl()) return;
+  const handleQRScanned = useCallback(
+    async (qrCodeData) => {
+      if (!validateApiUrl()) return;
 
-    updateState({
-      animationState: ANIMATION_STATES.PROCESSING,
-      isLoading: true,
-    });
+      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;
-      }
+      try {
+        const hasPermission = await requestLocationPermission();
+        if (!hasPermission) {
+          handleProcessError('Location permission not granted.');
+          return;
+        }
 
-      const location = await getCurrentLocation();
-      const [latStr, lngStr] = qrString.split(',');
-      const lat = parseFloat(latStr);
-      const lng = parseFloat(lngStr);
+        const qrString = typeof qrCodeData === 'object' ? qrCodeData?.data : qrCodeData;
+        if (!qrString || typeof qrString !== 'string') {
+          handleProcessError('Invalid QR code. Please try again.');
+          return;
+        }
 
-      const validCoords = !isNaN(lat) && !isNaN(lng);
-      const validDev = !isNaN(location?.latitude) && !isNaN(location?.longitude);
+        const location = await getCurrentLocation();
+        const [latStr, lngStr] = qrString.split(',');
+        const lat = parseFloat(latStr);
+        const lng = parseFloat(lngStr);
 
-      if (validCoords && validDev) {
-        const distance = getDistanceInMeters(lat, lng, location.latitude, location.longitude);
+        const validCoords = !isNaN(lat) && !isNaN(lng);
+        const validDev = !isNaN(location?.latitude) && !isNaN(location?.longitude);
 
-        if (distance <= MAX_DISTANCE_METERS) {
-          try {
-            callback?.(dataRef.current);
-          } catch (err) {
-            console.error("Callback execution failed:", err);
-            notifyMessage('Unexpected error during location verification.', 'error');
-          }
+        if (validCoords && validDev) {
+          const distance = getDistanceInMeters(lat, lng, location.latitude, location.longitude);
 
-          notifyMessage('Location verified successfully!', 'success');
-          updateState({ animationState: ANIMATION_STATES.SUCCESS });
+          if (distance <= MAX_DISTANCE_METERS) {
+            safeCallback(responseRef.current);
+            notifyMessage('Location verified successfully!', 'success');
+            updateState({ animationState: ANIMATION_STATES.SUCCESS });
 
-          setTimeout(() => {
-            updateState({ modalVisible: false });
-            resetState();
-          }, 1500);
+            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) {
-      console.error("QR scan handling failed:", 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, validateApiUrl]);
+    },
+    [getCurrentLocation, notifyMessage, requestLocationPermission, resetState, updateState, validateApiUrl, safeCallback]
+  );
 
   const startProcess = useCallback(() => {
     startCountdown(COUNTDOWN_DURATION, handleCountdownFinish);
@@ -303,10 +303,7 @@ const BiometricVerificationModal = React.memo(({ data, qrscan = false, callback,
         <StateIndicator state={state.animationState} size={120} />
 
         {state.employeeData && (
-          <EmployeeCard
-            employeeData={state.employeeData}
-            apiurl={apiurl}
-          />
+          <EmployeeCard employeeData={state.employeeData} apiurl={apiurl} />
         )}
 
         <Notification
@@ -315,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, apiurl) && (
-          <Loader source={getLoaderGif(state.animationState, state.currentStep, apiurl)} />
-        )}
+        {state.isLoading &&
+          getLoaderGif(state.animationState, state.currentStep, apiurl) && (
+            <Loader source={getLoaderGif(state.animationState, state.currentStep, apiurl)} />
+          )}
       </View>
     </Modal>
   );