react-native-biometric-verifier 0.0.50 → 0.0.52

package/package.json

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

package/src/components/CaptureImageWithoutEdit.js

@@ -118,6 +118,7 @@ const CaptureImageWithoutEdit = React.memo(
     );
 
     const onFacesUpdate = useCallback((payload) => {
+      console.log('qqqqqq',JSON.stringify(payload))
       if (!isMounted.current) return;
       try {
         const { count, progress, antiSpoofState } = payload;

package/src/hooks/useFaceDetectionFrameProcessor.js

@@ -7,7 +7,29 @@ import {
   initializeFaceAntiSpoof,
   isFaceAntiSpoofAvailable,
 } from 'react-native-vision-camera-spoof-detector';
-import { Global } from 'react-native-biometric-verifier/src/utils/Global';
+
+// Optimized constants - tuned for performance
+const FACE_STABILITY_THRESHOLD = 3;
+const FACE_MOVEMENT_THRESHOLD = 15;
+const FRAME_PROCESSOR_MIN_INTERVAL_MS = 500;
+const MIN_FACE_SIZE = 0.2;
+
+// Blink detection
+const BLINK_THRESHOLD = 0.3;
+const REQUIRED_BLINKS = 3;
+
+// Anti-spoofing
+const ANTI_SPOOF_CONFIDENCE_THRESHOLD = 7;
+const REQUIRED_CONSECUTIVE_LIVE_FRAMES = 3;
+
+// Face centering
+const FACE_CENTER_THRESHOLD_X = 0.2;
+const FACE_CENTER_THRESHOLD_Y = 0.15;
+const MIN_FACE_CENTERED_FRAMES = 2;
+
+// Performance optimization constants
+const MAX_FRAME_PROCESSING_TIME_MS = 500;
+const BATCH_UPDATE_THRESHOLD = 3;
 
 export const useFaceDetectionFrameProcessor = ({
   onStableFaceDetected = () => { },
@@ -24,7 +46,7 @@ export const useFaceDetectionFrameProcessor = ({
     landmarkMode: 'none',
     contourMode: 'none',
     classificationMode: livenessLevel === 1 ? 'all' : 'none',
-    minFaceSize: Global.MIN_FACE_SIZE,
+    minFaceSize: MIN_FACE_SIZE,
   });
 
   const isMounted = useRef(true);
@@ -208,8 +230,8 @@ export const useFaceDetectionFrameProcessor = ({
     const frameCenterY = frameHeight / 2;
 
     return (
-      Math.abs(faceCenterX - frameCenterX) <= frameWidth * Global.FACE_CENTER_THRESHOLD_X &&
-      Math.abs(faceCenterY - frameCenterY) <= frameHeight * Global.FACE_CENTER_THRESHOLD_Y
+      Math.abs(faceCenterX - frameCenterX) <= frameWidth * FACE_CENTER_THRESHOLD_X &&
+      Math.abs(faceCenterY - frameCenterY) <= frameHeight * FACE_CENTER_THRESHOLD_Y
     );
   });
 
@@ -221,7 +243,7 @@ export const useFaceDetectionFrameProcessor = ({
       state.flags.captured ||
       isLoading ||
       !state.flags.isActive ||
-      (now - state.lastProcessedTime < Global.FACE_MOVEMENT_THRESHOLD)
+      (now - state.lastProcessedTime < FRAME_PROCESSOR_MIN_INTERVAL_MS)
     );
   });
 
@@ -243,7 +265,7 @@ export const useFaceDetectionFrameProcessor = ({
       }
 
       // Performance guard - don't process if taking too long
-      if (processingStart - frameProcessingStartTime.current < Global.MAX_FRAME_PROCESSING_TIME_MS) {
+      if (processingStart - frameProcessingStartTime.current < MAX_FRAME_PROCESSING_TIME_MS) {
         frame.release?.();
         return;
       }
@@ -326,13 +348,13 @@ export const useFaceDetectionFrameProcessor = ({
 
           if (centered) {
             state.centering.centeredFrames = Math.min(
-              Global.MIN_FACE_CENTERED_FRAMES,
+              MIN_FACE_CENTERED_FRAMES,
               state.centering.centeredFrames + 1
             );
           } else {
             state.centering.centeredFrames = 0;
           }
-          state.flags.isFaceCentered = state.centering.centeredFrames >= Global.MIN_FACE_CENTERED_FRAMES;
+          state.flags.isFaceCentered = state.centering.centeredFrames >= MIN_FACE_CENTERED_FRAMES;
 
           // Anti-spoof detection only when face is centered and single
           if (state.flags.isFaceCentered) {
@@ -344,19 +366,19 @@ export const useFaceDetectionFrameProcessor = ({
                 const isLive = antiSpoofResult.isLive === true;
                 const confidence = antiSpoofResult.combinedScore || antiSpoofResult.neuralNetworkScore || 0;
 
-                if (isLive && confidence > Global.ANTI_SPOOF_CONFIDENCE_THRESHOLD) {
+                if (isLive && confidence > ANTI_SPOOF_CONFIDENCE_THRESHOLD) {
                   state.antiSpoof.consecutiveLiveFrames = Math.min(
-                    Global.REQUIRED_CONSECUTIVE_LIVE_FRAMES,
+                    REQUIRED_CONSECUTIVE_LIVE_FRAMES,
                     state.antiSpoof.consecutiveLiveFrames + 1
                   );
                 } else {
                   state.antiSpoof.consecutiveLiveFrames = Math.max(0, state.antiSpoof.consecutiveLiveFrames - 1);
                 }
-                state.antiSpoof.isLive = state.antiSpoof.consecutiveLiveFrames >= Global.REQUIRED_CONSECUTIVE_LIVE_FRAMES;
+                state.antiSpoof.isLive = state.antiSpoof.consecutiveLiveFrames >= REQUIRED_CONSECUTIVE_LIVE_FRAMES;
                 state.antiSpoof.confidence = confidence;
 
                 // Batch anti-spoof updates
-                if (state.performance.batchCounter % Global.BATCH_UPDATE_THRESHOLD === 0) {
+                if (state.performance.batchCounter % BATCH_UPDATE_THRESHOLD === 0) {
                   runOnAntiSpoof({
                     isLive: state.antiSpoof.isLive,
                     confidence: state.antiSpoof.confidence,
@@ -388,7 +410,7 @@ export const useFaceDetectionFrameProcessor = ({
             else if (newLivenessStep === 1) {
               const leftEye = face.leftEyeOpenProbability ?? 1;
               const rightEye = face.rightEyeOpenProbability ?? 1;
-              const eyesClosed = leftEye < Global.BLINK_THRESHOLD && rightEye < Global.BLINK_THRESHOLD;
+              const eyesClosed = leftEye < BLINK_THRESHOLD && rightEye < BLINK_THRESHOLD;
 
               if (eyesClosed && !newEyeClosed) {
                 newBlinkCount++;
@@ -398,7 +420,7 @@ export const useFaceDetectionFrameProcessor = ({
                 newEyeClosed = false;
               }
 
-              if (newBlinkCount >= Global.REQUIRED_BLINKS) {
+              if (newBlinkCount >= REQUIRED_BLINKS) {
                 newLivenessStep = 2;
                 runOnLiveness(newLivenessStep);
               }
@@ -412,7 +434,7 @@ export const useFaceDetectionFrameProcessor = ({
           } else {
             const dx = Math.abs(x - state.faceTracking.lastX);
             const dy = Math.abs(y - state.faceTracking.lastY);
-            newStableCount = (dx < Global.FACE_MOVEMENT_THRESHOLD && dy < Global.FACE_MOVEMENT_THRESHOLD) 
+            newStableCount = (dx < FACE_MOVEMENT_THRESHOLD && dy < FACE_MOVEMENT_THRESHOLD) 
               ? state.faceTracking.stableCount + 1 
               : 1;
           }
@@ -429,10 +451,10 @@ export const useFaceDetectionFrameProcessor = ({
           state.flags.eyeClosed = newEyeClosed;
           state.performance.batchCounter++;
 
-          const progress = Math.min(100, (newStableCount / Global.FACE_STABILITY_THRESHOLD) * 100);
+          const progress = Math.min(100, (newStableCount / FACE_STABILITY_THRESHOLD) * 100);
           
           // Batch face updates
-          if (state.performance.batchCounter % Global.BATCH_UPDATE_THRESHOLD === 0) {
+          if (state.performance.batchCounter % BATCH_UPDATE_THRESHOLD === 0) {
             runOnFaces(1, progress, newLivenessStep, state.flags.isFaceCentered, {
               isLive: state.antiSpoof.isLive,
               confidence: state.antiSpoof.confidence,
@@ -444,14 +466,14 @@ export const useFaceDetectionFrameProcessor = ({
 
           // Capture condition - optimized
           const shouldCapture = !state.flags.captured && (
-            newStableCount >= Global.FACE_STABILITY_THRESHOLD &&
+            newStableCount >= FACE_STABILITY_THRESHOLD &&
             state.antiSpoof.isLive &&
-            state.antiSpoof.consecutiveLiveFrames >= Global.REQUIRED_CONSECUTIVE_LIVE_FRAMES &&
+            state.antiSpoof.consecutiveLiveFrames >= REQUIRED_CONSECUTIVE_LIVE_FRAMES &&
             state.flags.isFaceCentered &&
             (localState.livenessLevel === 0 || (
               localState.livenessLevel === 1 && 
               newLivenessStep === 2 && 
-              newBlinkCount >= Global.REQUIRED_BLINKS
+              newBlinkCount >= REQUIRED_BLINKS
             ))
           );
 

package/src/utils/Global.js

@@ -42,27 +42,5 @@ export class Global {
     format: 'JPEG', // 'PNG' or 'JPEG'
     quality: 85, // 0–100
   };
-  // Optimized constants - tuned for performance
-  static FACE_STABILITY_THRESHOLD = 3;
-  static FACE_MOVEMENT_THRESHOLD = 15;
-  static FRAME_PROCESSOR_MIN_INTERVAL_MS = 500;
-  static MIN_FACE_SIZE = 0.2;
-
-  // Blink detection
-  static BLINK_THRESHOLD = 0.3;
-  static REQUIRED_BLINKS = 3;
-
-  // Anti-spoofing
-  static ANTI_SPOOF_CONFIDENCE_THRESHOLD = 0.7;
-  static REQUIRED_CONSECUTIVE_LIVE_FRAMES = 3;
-
-  // Face centering
-  static FACE_CENTER_THRESHOLD_X = 0.2;
-  static FACE_CENTER_THRESHOLD_Y = 0.15;
-  static MIN_FACE_CENTERED_FRAMES = 2;
-
-  // Performance optimization constants
-  static MAX_FRAME_PROCESSING_TIME_MS = 500;
-  static BATCH_UPDATE_THRESHOLD = 3;
 
 }