react-native-biometric-verifier 0.0.39 → 0.0.41

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "react-native-biometric-verifier",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "A React Native module for biometric verification with face recognition and QR code scanning",
   "main": "src/index.js",
+  "private": false,
+  "license": "UNLICENSED",
+  "author": "PRAFUL DAS M M",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -13,8 +16,18 @@
     "face-recognition",
     "qr-code"
   ],
-  "author": "PRAFULDAS M M",
-  "license": "JESCON TECHNOLOGIES PVT LTD",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jescon-technologies/react-native-biometric-verifier"
+  },
+  "bugs": {
+    "url": "https://github.com/jescon-technologies/react-native-biometric-verifier/issues"
+  },
+  "homepage": "https://github.com/jescon-technologies/react-native-biometric-verifier#readme",
+  "files": [
+    "src",
+    "README.md"
+  ],
   "peerDependencies": {
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
     "react-native": ">=0.60.0",

package/src/components/CaptureImageWithoutEdit.js

@@ -24,7 +24,7 @@ const CaptureImageWithoutEdit = React.memo(
     showCodeScanner = false,
     isLoading = false,
     frameProcessorFps = 1,
-    livenessLevel = 0,
+    livenessLevel = 0, // 0 = anti-spoof only, 1 = anti-spoof + blinking
   }) => {
     const cameraRef = useRef(null);
     const [cameraDevice, setCameraDevice] = useState(null);
@@ -42,7 +42,6 @@ const CaptureImageWithoutEdit = React.memo(
     const [antiSpoofConfidence, setAntiSpoofConfidence] = useState(0);
     const [isFaceCentered, setIsFaceCentered] = useState(false);
     const [hasSingleFace, setHasSingleFace] = useState(false);
-    const [recognitionImageBase64, setRecognitionImageBase64] = useState(null);
 
     const captured = useRef(false);
     const isMounted = useRef(true);
@@ -61,7 +60,6 @@ const CaptureImageWithoutEdit = React.memo(
       setAntiSpoofConfidence(0);
       setIsFaceCentered(false);
       setHasSingleFace(false);
-      setRecognitionImageBase64(null);
     }, []);
 
     const codeScanner = useCodeScanner({
@@ -78,13 +76,38 @@ const CaptureImageWithoutEdit = React.memo(
     });
 
     const onStableFaceDetected = useCallback(
-      async (faceRect, Result) => {
+      async (faceRect) => {
         if (!isMounted.current) return;
         if (captured.current) return;
+
         captured.current = true;
         setFaces([faceRect]);
+
         try {
-          onCapture(Result?.recognitionImageBase64);
+          if (!cameraRef.current) {
+            throw new Error('Camera ref not available');
+          }
+
+          const photo = await cameraRef.current.takePhoto({
+            flash: 'off',
+            qualityPrioritization: 'quality',
+            enableShutterSound: false,
+            skipMetadata: true,
+          });
+
+          if (!photo || !photo.path) {
+            throw new Error('Failed to capture photo - no path returned');
+          }
+
+          const photopath = `file://${photo.path}`;
+          const fileName = photopath.substr(photopath.lastIndexOf('/') + 1);
+          const photoData = {
+            uri: photopath,
+            filename: fileName,
+            filetype: 'image/jpeg',
+          };
+
+          onCapture(photoData, faceRect);
         } catch (e) {
           console.error('Capture error:', e);
           captured.current = false;
@@ -107,7 +130,6 @@ const CaptureImageWithoutEdit = React.memo(
           setAntiSpoofConfidence(antiSpoofState.confidence || 0);
           setIsFaceCentered(antiSpoofState.isFaceCentered || false);
           setHasSingleFace(antiSpoofState.hasSingleFace || false);
-          setRecognitionImageBase64(antiSpoofState.recognitionImageBase64 || null);
         }
 
         if (count === 1) {
@@ -141,11 +163,6 @@ const CaptureImageWithoutEdit = React.memo(
     const onAntiSpoofUpdate = useCallback((result) => {
       if (!isMounted.current) return;
       try {
-        // Update recognition image when available
-        if (result?.recognitionImageBase64) {
-          setRecognitionImageBase64(result.recognitionImageBase64);
-        }
-
         // Animate live indicator when face becomes live
         if (result?.isLive && !isFaceLive) {
           Animated.spring(liveIndicatorAnim, {

package/src/hooks/useFaceDetectionFrameProcessor.js

@@ -109,7 +109,6 @@ export const useFaceDetectionFrameProcessor = ({
           lastResult: null,
           isLive: false,
           confidence: 0,
-          recognitionImageBase64: null, // Added to store base64 image
         },
         
         // Face centering
@@ -148,7 +147,6 @@ export const useFaceDetectionFrameProcessor = ({
       state.antiSpoof.lastResult = null;
       state.antiSpoof.isLive = false;
       state.antiSpoof.confidence = 0;
-      state.antiSpoof.recognitionImageBase64 = null; // Reset base64 image
       state.flags.hasSingleFace = false;
       state.centering.centeredFrames = 0;
       state.flags.isFaceCentered = false;
@@ -302,7 +300,6 @@ export const useFaceDetectionFrameProcessor = ({
             consecutiveLiveFrames: 0,
             isFaceCentered: false,
             hasSingleFace: false,
-            recognitionImageBase64: null,
           });
           return;
         }
@@ -317,7 +314,6 @@ export const useFaceDetectionFrameProcessor = ({
               consecutiveLiveFrames: 0,
               isFaceCentered: false,
               hasSingleFace: false,
-              recognitionImageBase64: null,
             });
             return;
           }
@@ -364,28 +360,19 @@ export const useFaceDetectionFrameProcessor = ({
           if (state.flags.isFaceCentered) {
             try {
               antiSpoofResult = faceAntiSpoofFrameProcessor?.(frame);
-              
               if (antiSpoofResult != null) {
                 state.antiSpoof.lastResult = antiSpoofResult;
 
                 const isLive = antiSpoofResult.isLive === true;
                 const confidence = antiSpoofResult.combinedScore || antiSpoofResult.neuralNetworkScore || 0;
-                const recognitionImageBase64 = antiSpoofResult.recognitionImageBase64 || null;
 
-                // Store the base64 image when face is live
                 if (isLive && confidence > ANTI_SPOOF_CONFIDENCE_THRESHOLD) {
                   state.antiSpoof.consecutiveLiveFrames = Math.min(
                     REQUIRED_CONSECUTIVE_LIVE_FRAMES,
                     state.antiSpoof.consecutiveLiveFrames + 1
                   );
-                  // Store the base64 image when we have a live face
-                  if (recognitionImageBase64) {
-                    state.antiSpoof.recognitionImageBase64 = recognitionImageBase64;
-                  }
                 } else {
                   state.antiSpoof.consecutiveLiveFrames = Math.max(0, state.antiSpoof.consecutiveLiveFrames - 1);
-                  // Clear base64 image if face is not live
-                  state.antiSpoof.recognitionImageBase64 = null;
                 }
                 state.antiSpoof.isLive = state.antiSpoof.consecutiveLiveFrames >= REQUIRED_CONSECUTIVE_LIVE_FRAMES;
                 state.antiSpoof.confidence = confidence;
@@ -398,19 +385,16 @@ export const useFaceDetectionFrameProcessor = ({
                     rawResult: antiSpoofResult,
                     consecutiveLiveFrames: state.antiSpoof.consecutiveLiveFrames,
                     isFaceCentered: state.flags.isFaceCentered,
-                    recognitionImageBase64: state.antiSpoof.recognitionImageBase64,
                   });
                 }
               }
             } catch (antiSpoofError) {
               // Silent error handling
-              console.log('Anti-spoof error:', antiSpoofError);
             }
           } else {
             // Reset anti-spoof if face not centered
             state.antiSpoof.consecutiveLiveFrames = 0;
             state.antiSpoof.isLive = false;
-            state.antiSpoof.recognitionImageBase64 = null;
           }
 
           // Liveness logic - optimized
@@ -477,7 +461,6 @@ export const useFaceDetectionFrameProcessor = ({
               consecutiveLiveFrames: state.antiSpoof.consecutiveLiveFrames,
               isFaceCentered: state.flags.isFaceCentered,
               hasSingleFace: true,
-              recognitionImageBase64: state.antiSpoof.recognitionImageBase64,
             });
           }
 
@@ -496,13 +479,9 @@ export const useFaceDetectionFrameProcessor = ({
 
           if (shouldCapture) {
             state.flags.captured = true;
-            // Include the base64 image in the stable face detection callback
             runOnStable(
               { x, y, width, height },
-              {
-                ...state.antiSpoof.lastResult,
-                recognitionImageBase64: state.antiSpoof.recognitionImageBase64
-              }
+              state.antiSpoof.lastResult
             );
           }
         } else {
@@ -513,7 +492,6 @@ export const useFaceDetectionFrameProcessor = ({
           state.flags.hasSingleFace = false;
           state.centering.centeredFrames = 0;
           state.flags.isFaceCentered = false;
-          state.antiSpoof.recognitionImageBase64 = null;
           
           runOnFaces(detected.length, 0, state.liveness.step, false, {
             isLive: false,
@@ -521,12 +499,10 @@ export const useFaceDetectionFrameProcessor = ({
             consecutiveLiveFrames: 0,
             isFaceCentered: false,
             hasSingleFace: false,
-            recognitionImageBase64: null,
           });
         }
       } catch (err) {
         // Error boundary - ensure frame is released
-        console.log('Frame processor error:', err);
       } finally {
         frame.release?.();
       }
@@ -551,7 +527,6 @@ export const useFaceDetectionFrameProcessor = ({
     state.antiSpoof.lastResult = null;
     state.antiSpoof.isLive = false;
     state.antiSpoof.confidence = 0;
-    state.antiSpoof.recognitionImageBase64 = null; // Reset base64 image
     state.flags.hasSingleFace = false;
     state.centering.centeredFrames = 0;
     state.flags.isFaceCentered = false;
@@ -586,7 +561,6 @@ export const useFaceDetectionFrameProcessor = ({
         lastResult: null,
         isLive: false,
         confidence: 0,
-        recognitionImageBase64: null, // Reset base64 image
       },
       centering: {
         centeredFrames: 0,
@@ -638,7 +612,6 @@ export const useFaceDetectionFrameProcessor = ({
       lastResult: sharedState.value.antiSpoof.lastResult,
       hasSingleFace: sharedState.value.flags.hasSingleFace,
       isFaceCentered: sharedState.value.flags.isFaceCentered,
-      recognitionImageBase64: sharedState.value.antiSpoof.recognitionImageBase64,
     },
   };
 };

package/src/hooks/useImageProcessing.js

@@ -0,0 +1,64 @@
+import { useCallback } from 'react';
+import ImageResizer from 'react-native-image-resizer';
+import RNFS from 'react-native-fs';
+import { Global } from '../utils/Global';
+
+/**
+ * Custom hook to process images: resize and convert to Base64.
+ *
+ * @returns {Object} { convertImageToBase64 }
+ */
+export const useImageProcessing = () => {
+  /**
+   * Converts an image URI to a Base64 string after resizing.
+   *
+   * @param {string} uri - Image file URI.
+   * @param {boolean} includeMimeType - Whether to include MIME type in the result.
+   * @returns {Promise<string>} Base64 string of the image.
+   */
+  const convertImageToBase64 = useCallback(async (uri, includeMimeType = false) => {
+    try {
+      if (!uri || typeof uri !== 'string') {
+        throw new Error('Invalid image URI provided.');
+      }
+
+      // Optional: Check file info
+      try {
+        await RNFS.stat(uri);
+      } catch {
+        // Skip warnings; silently ignore
+      }
+
+      // Resize image
+      const resizedImage = await ImageResizer.createResizedImage(
+        uri,
+        Global.ImageResize.width,
+        Global.ImageResize.height,
+        Global.ImageResize.format,  // 'JPEG' or 'PNG'
+        Global.ImageResize.quality, // e.g., 80
+        0,                    // Rotation
+        undefined,            // Output path
+        false                 // Keep EXIF metadata
+      );
+
+      if (!resizedImage?.uri) {
+        throw new Error('Image resizing returned an invalid result.');
+      }
+
+      // Convert resized image to Base64
+      let base64Data = await RNFS.readFile(resizedImage.uri, 'base64');
+
+      if (includeMimeType) {
+        const mimeType = Global.ImageResize.format.toLowerCase() === 'png' ? 'image/png' : 'image/jpeg';
+        base64Data = `data:${mimeType};base64,${base64Data}`;
+      }
+
+      return base64Data;
+    } catch (error) {
+      console.error('Error in convertImageToBase64:', error.message || error);
+      throw error; // Rethrow for caller handling
+    }
+  }, []);
+
+  return { convertImageToBase64 };
+};

package/src/index.js

@@ -10,6 +10,7 @@ import {
   TouchableOpacity,
   Text,
   Modal,
+  InteractionManager,
   StyleSheet,
   Platform,
   Animated,
@@ -20,6 +21,7 @@ import { useNavigation } from "@react-navigation/native";
 // Custom hooks
 import { useCountdown } from "./hooks/useCountdown";
 import { useGeolocation } from "./hooks/useGeolocation";
+import { useImageProcessing } from "./hooks/useImageProcessing";
 import { useNotifyMessage } from "./hooks/useNotifyMessage";
 import { useSafeCallback } from "./hooks/useSafeCallback";
 
@@ -44,6 +46,7 @@ const BiometricModal = React.memo(
     // Custom hooks
     const { countdown, startCountdown, resetCountdown, pauseCountdown, resumeCountdown } = useCountdown();
     const { requestLocationPermission, getCurrentLocation } = useGeolocation();
+    const { convertImageToBase64 } = useImageProcessing();
     const { notification, fadeAnim, slideAnim, notifyMessage, clearNotification } = useNotifyMessage();
     const safeCallback = useSafeCallback(callback, notifyMessage);
 
@@ -213,7 +216,7 @@ const BiometricModal = React.memo(
 
     // Face scan upload
     const uploadFaceScan = useCallback(
-      async (base64) => {
+      async (selfie) => {
         if (!validateApiUrl()) return;
         const currentData = dataRef.current;
 
@@ -228,68 +231,84 @@ const BiometricModal = React.memo(
           animationState: Global.AnimationStates.processing,
         });
 
-        if (!base64) {
-          handleProcessError("Failed to process image.");
-          return;
-        }
+        InteractionManager.runAfterInteractions(async () => {
+          let base64;
 
-        try {
-          const body = { image: base64 };
-          const header = { faceid: currentData };
-          const buttonapi = `${apiurl}python/recognize`;
+          try {
+            updateState({
+              loadingType: Global.LoadingTypes.imageProcessing,
+            });
 
-          updateState({
-            loadingType: Global.LoadingTypes.networkRequest,
-          });
-          console.log("API URL:", buttonapi);
-          console.log("Sending request to API...", JSON.stringify(body));
-          const response = await networkServiceCall(
-            "POST",
-            buttonapi,
-            header,
-            body
-          );
-          console.log("API Response:", JSON.stringify(response));
-          if (response?.httpstatus === 200 && response?.data?.data) {
-            responseRef.current = response;
+            base64 = await convertImageToBase64(selfie?.uri);
+          } catch (err) {
+            console.error("Image conversion failed:", 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 buttonapi = `${apiurl}python/recognize`;
 
             updateState({
-              employeeData: response.data?.data || null,
-              animationState: Global.AnimationStates.success,
-              isLoading: false,
-              loadingType: Global.LoadingTypes.none,
+              loadingType: Global.LoadingTypes.networkRequest,
             });
 
-            notifyMessage("Identity verified successfully!", "success");
+            const response = await networkServiceCall(
+              "POST",
+              buttonapi,
+              header,
+              body
+            );
 
-            if (qrscan) {
-              setTimeout(() => startQRCodeScan(), 1200);
-            } else {
-              safeCallback(responseRef.current);
+            if (response?.httpstatus === 200) {
+              responseRef.current = response;
 
-              if (resetTimeoutRef.current) {
-                clearTimeout(resetTimeoutRef.current);
-              }
+              updateState({
+                employeeData: response.data?.data || null,
+                animationState: Global.AnimationStates.success,
+                isLoading: false,
+                loadingType: Global.LoadingTypes.none,
+              });
 
-              resetTimeoutRef.current = setTimeout(() => {
-                resetState();
-              }, 1200);
+              notifyMessage("Identity verified successfully!", "success");
+
+              if (qrscan) {
+                setTimeout(() => startQRCodeScan(), 1200);
+              } else {
+                safeCallback(responseRef.current);
+
+                if (resetTimeoutRef.current) {
+                  clearTimeout(resetTimeoutRef.current);
+                }
+
+                resetTimeoutRef.current = setTimeout(() => {
+                  resetState();
+                }, 1200);
+              }
+            } else {
+              handleProcessError(
+                response?.data?.message ||
+                "Face not recognized. Please try again."
+              );
             }
-          } else {
+          } catch (error) {
+            console.error("Network request failed:", error);
             handleProcessError(
-              response?.data?.message ||
-              "Face not recognized. Please try again."
+              "Connection error. Please check your network.",
+              error
             );
           }
-        } catch (error) {
-          console.error("Network request failed:", error);
-          handleProcessError(
-            "Connection error. Please check your network.",
-            error
-          );
-        }
+        });
       },
       [
+        convertImageToBase64,
         notifyMessage,
         qrscan,
         resetState,
@@ -357,7 +376,28 @@ const BiometricModal = React.memo(
             );
 
             if (distance <= Global.MaxDistanceMeters) {
+              const locationDetails = {
+                qrLocation: {
+                  latitude: lat,
+                  longitude: lng,
+                },
+                deviceLocation: {
+                  latitude: location.latitude,
+                  longitude: location.longitude,
+                  accuracy: location.accuracy,
+                },
+                distanceMeters: distance,
+                verified: true,
+                verifiedAt: new Date().toISOString(),
+              };
+
+              responseRef.current = {
+                ...(responseRef.current || {}), // existing faceData
+                location: locationDetails,
+              };
+
               safeCallback(responseRef.current);
+
               notifyMessage("Location verified successfully!", "success");
 
               updateState({
@@ -373,7 +413,8 @@ const BiometricModal = React.memo(
               resetTimeoutRef.current = setTimeout(() => {
                 resetState();
               }, 1200);
-            } else {
+            }
+            else {
               handleProcessError(
                 `Location mismatch (${distance.toFixed(0)}m away).`
               );