react-native-biometric-verifier 0.0.18 → 0.0.20

package/src/hooks/useFaceDetectionFrameProcessor.js

@@ -3,16 +3,20 @@ import { Worklets } from 'react-native-worklets-core';
 import { useFrameProcessor } from 'react-native-vision-camera';
 import { useFaceDetector } from 'react-native-vision-camera-face-detector';
 
-// Tuned constants for liveness detection
+// Tuned constants for liveness detection / stability
 const FACE_STABILITY_THRESHOLD = 3;
 const FACE_MOVEMENT_THRESHOLD = 15;
-const FRAME_PROCESSOR_MIN_INTERVAL_MS = 800;
+const FRAME_PROCESSOR_MIN_INTERVAL_MS = 1000; // increased to reduce load
 const MIN_FACE_SIZE = 0.2;
 
 // Liveness detection constants
-const YAW_LEFT_THRESHOLD = -15; // face turned left (negative yaw)
-const YAW_RIGHT_THRESHOLD = 15; // face turned right (positive yaw)
-const YAW_CENTER_THRESHOLD = 5; // face centered
+const YAW_LEFT_THRESHOLD = -10;
+const YAW_RIGHT_THRESHOLD = 10;
+const YAW_CENTER_THRESHOLD = 5;
+
+// Blink detection constants
+const BLINK_THRESHOLD = 0.3; // Eye closed if below this
+const REQUIRED_BLINKS = 3;
 
 export const useFaceDetectionFrameProcessor = ({
   onStableFaceDetected = () => {},
@@ -21,317 +25,430 @@ export const useFaceDetectionFrameProcessor = ({
   showCodeScanner = false,
   isLoading = false,
   isActive = true,
+  livenessLevel = 3, // 0=no liveness, 1=blink only, 2=face turn only, 3=both
 }) => {
   const { detectFaces } = useFaceDetector({
     performanceMode: 'fast',
     landmarkMode: 'none',
     contourMode: 'none',
-    classificationMode: 'none',
+    classificationMode: livenessLevel === 1 || livenessLevel === 3 ? 'all' : 'none', // Only enable classification for blink detection
     minFaceSize: MIN_FACE_SIZE,
   });
 
   const isMounted = useRef(true);
 
-  const sharedState = useMemo(() =>
-    Worklets.createSharedValue({
-      lastProcessedTime: 0,
-      lastX: 0,
-      lastY: 0,
-      lastW: 0,
-      lastH: 0,
-      stableCount: 0,
-      captured: false,
-      showCodeScanner: showCodeScanner,
-      isActive: isActive,
-      livenessStep: 0, // 0=look straight, 1=left done, 2=right done, 3=ready for capture
-      leftTurnVerified: false,
-      rightTurnVerified: false,
-      currentYaw: 0,
-      yawStableCount: 0,
-    }), []);
-
-  useEffect(() => {
-    if (!isMounted.current) return;
-    
-    sharedState.value = {
-      ...sharedState.value,
-      showCodeScanner: showCodeScanner,
-      isActive: isActive
-    };
-    
-    // Reset when becoming active again
-    if (isActive && sharedState.value.captured) {
-      sharedState.value = {
-        ...sharedState.value,
-        captured: false,
+  const sharedState = useMemo(
+    () =>
+      Worklets.createSharedValue({
+        lastProcessedTime: 0,
+        lastX: 0,
+        lastY: 0,
+        lastW: 0,
+        lastH: 0,
         stableCount: 0,
-        livenessStep: 0,
+        captured: false,
+        showCodeScanner: showCodeScanner,
+        isActive: isActive,
+        livenessLevel: livenessLevel,
+        livenessStep: 0, // 0=center, 1=left/center, 2=right/blink, 3=blink/capture, 4=capture
         leftTurnVerified: false,
         rightTurnVerified: false,
+        currentYaw: 0,
         yawStableCount: 0,
-      };
+        blinkCount: 0,
+        eyeClosed: false,
+      }),
+    []
+  );
+
+  useEffect(() => {
+    if (!isMounted.current) return;
+    // update flags without recreating object
+    sharedState.value.showCodeScanner = !!showCodeScanner;
+    sharedState.value.isActive = !!isActive;
+    sharedState.value.livenessLevel = livenessLevel;
+
+    if (isActive && sharedState.value.captured) {
+      // reset minimal fields
+      sharedState.value.captured = false;
+      sharedState.value.stableCount = 0;
+      sharedState.value.livenessStep = 0;
+      sharedState.value.leftTurnVerified = false;
+      sharedState.value.rightTurnVerified = false;
+      sharedState.value.yawStableCount = 0;
+      sharedState.value.blinkCount = 0;
+      sharedState.value.eyeClosed = false;
     }
-  }, [showCodeScanner, isActive, sharedState]);
+  }, [showCodeScanner, isActive, livenessLevel, sharedState]);
 
-  const runOnStable = useMemo(() =>
-    Worklets.createRunOnJS((faceRect) => {
-      try {
-        onStableFaceDetected?.(faceRect);
-      } catch (error) {
-        console.error('Error in runOnStable:', error);
-      }
-    }), [onStableFaceDetected]
+  // Throttled JS callbacks to avoid flooding the JS thread
+  const lastFacesEventTimeRef = useRef(0);
+  const lastLivenessEventTimeRef = useRef(0);
+  const FACES_EVENT_INTERVAL_MS = 800;
+  const LIVENESS_EVENT_INTERVAL_MS = 700;
+
+  const runOnStable = useMemo(
+    () =>
+      Worklets.createRunOnJS((faceRect) => {
+        try {
+          onStableFaceDetected?.(faceRect);
+        } catch (error) {
+          console.error('Error in runOnStable:', error);
+        }
+      }),
+    [onStableFaceDetected]
   );
 
-  const runOnFaces = useMemo(() =>
-    Worklets.createRunOnJS((count, progress, step) => {
-      try {
-        onFacesUpdate?.({ count, progress, step });
-      } catch (error) {
-        console.error('Error in runOnFaces:', error);
-      }
-    }), [onFacesUpdate]
+  const runOnFaces = useMemo(
+    () =>
+      Worklets.createRunOnJS((count, progress, step) => {
+        try {
+          const now = Date.now();
+          if (now - lastFacesEventTimeRef.current > FACES_EVENT_INTERVAL_MS) {
+            lastFacesEventTimeRef.current = now;
+            onFacesUpdate?.({ count, progress, step });
+          }
+        } catch (error) {
+          console.error('Error in runOnFaces:', error);
+        }
+      }),
+    [onFacesUpdate]
   );
 
-  const runOnLiveness = useMemo(() =>
-    Worklets.createRunOnJS((step) => {
+  const runOnLiveness = useMemo(
+    () =>
+      Worklets.createRunOnJS((step, extra) => {
+        try {
+          const now = Date.now();
+          if (now - lastLivenessEventTimeRef.current > LIVENESS_EVENT_INTERVAL_MS) {
+            lastLivenessEventTimeRef.current = now;
+            onLivenessUpdate?.(step, extra);
+          }
+        } catch (error) {
+          console.error('Error in runOnLiveness:', error);
+        }
+      }),
+    [onLivenessUpdate]
+  );
+
+  const frameProcessor = useFrameProcessor(
+    (frame) => {
+      'worklet';
+      const state = sharedState.value;
+
+      // quick exits — do not call frame.release here; we'll release in finally
+      if (state.showCodeScanner || state.captured || isLoading || !state.isActive) {
+        frame.release?.();
+        return;
+      }
+
+      const now = frame?.timestamp ? frame.timestamp / 1e6 : Date.now();
+      if (now - state.lastProcessedTime < FRAME_PROCESSOR_MIN_INTERVAL_MS) {
+        frame.release?.();
+        return;
+      }
+
+      let detected = null;
       try {
-        onLivenessUpdate?.(step);
-      } catch (error) {
-        console.error('Error in runOnLiveness:', error);
+        // Keep try/finally around detection to ensure release
+        detected = detectFaces?.(frame);
+      } catch (err) {
+        // detection failed; update timestamp to avoid spin and return
+        state.lastProcessedTime = now;
+        frame.release?.();
+        return;
       }
-    }), [onLivenessUpdate]
-  );
 
-  const frameProcessor = useFrameProcessor((frame) => {
-    'worklet';
-    const state = sharedState.value;
+      try {
+        if (!detected || detected.length === 0) {
+          state.stableCount = 0;
+          state.yawStableCount = 0;
+          state.lastProcessedTime = now;
+          runOnFaces(0, 0, state.livenessStep);
+          return;
+        }
 
-    // Early return conditions
-    if (state.showCodeScanner || state.captured || isLoading || !state.isActive) {
-      frame.release?.();
-      return;
-    }
+        if (detected.length === 1 && !state.captured) {
+          const face = detected[0];
+          if (!face?.bounds || face.yawAngle === undefined) {
+            runOnFaces(0, 0, state.livenessStep);
+            return;
+          }
 
-    const now = frame?.timestamp ? frame.timestamp / 1e6 : Date.now();
-    if (now - state.lastProcessedTime < FRAME_PROCESSOR_MIN_INTERVAL_MS) {
-      frame.release?.();
-      return;
-    }
+          const yaw = face.yawAngle;
+          const x = Math.max(0, face.bounds.x);
+          const y = Math.max(0, face.bounds.y);
+          const width = Math.max(0, face.bounds.width);
+          const height = Math.max(0, face.bounds.height);
 
-    let detected;
-    try {
-      detected = detectFaces?.(frame);
-      frame.release?.();
-    } catch (error) {
-      frame.release?.();
-      return;
-    }
+          // read values locally and then write back to shared state fields
+          let {
+            livenessStep,
+            leftTurnVerified,
+            rightTurnVerified,
+            yawStableCount,
+            blinkCount,
+            eyeClosed,
+            livenessLevel,
+          } = state;
 
-    if (!detected || detected.length === 0) {
-      sharedState.value = { 
-        ...state, 
-        stableCount: 0, 
-        lastProcessedTime: now,
-        yawStableCount: 0
-      };
-      runOnFaces(0, 0, state.livenessStep);
-      return;
-    }
+          // ---- Liveness Logic Based on Level ----
+          if (livenessLevel === 0) {
+            // No liveness check - only stability
+            // Skip all liveness steps and go directly to capture when stable
+            livenessStep = 0;
+          } 
+          else if (livenessLevel === 1) {
+            // Blink detection only
+            if (livenessStep === 0) {
+              // Center face first
+              if (Math.abs(yaw) < YAW_CENTER_THRESHOLD) {
+                yawStableCount++;
+                if (yawStableCount >= 2) {
+                  livenessStep = 1; // Move to blink step
+                  runOnLiveness(livenessStep);
+                  yawStableCount = 0;
+                }
+              } else yawStableCount = 0;
+            }
+            // Blink detection
+            else if (livenessStep === 1) {
+              const leftEye = face.leftEyeOpenProbability ?? 1;
+              const rightEye = face.rightEyeOpenProbability ?? 1;
+              const eyesClosed = leftEye < BLINK_THRESHOLD && rightEye < BLINK_THRESHOLD;
 
-    if (detected.length === 1 && !state.captured) {
-      const face = detected[0];
-      if (!face?.bounds || face.yawAngle === undefined) {
-        runOnFaces(0, 0, state.livenessStep);
-        return;
-      }
+              if (eyesClosed && !eyeClosed) {
+                blinkCount++;
+                eyeClosed = true;
+                runOnLiveness(livenessStep, { blinkCount });
+              } else if (!eyesClosed && eyeClosed) {
+                eyeClosed = false;
+              }
 
-      const yaw = face.yawAngle;
-      const x = Math.max(0, face.bounds.x);
-      const y = Math.max(0, face.bounds.y);
-      const width = Math.max(0, face.bounds.width);
-      const height = Math.max(0, face.bounds.height);
-
-      let newLivenessStep = state.livenessStep;
-      let newLeftTurnVerified = state.leftTurnVerified;
-      let newRightTurnVerified = state.rightTurnVerified;
-      let newYawStableCount = state.yawStableCount;
-
-      // Liveness detection logic
-      if (newLivenessStep === 0) {
-        // Step 0: Wait for face to be centered and stable
-        if (Math.abs(yaw) < YAW_CENTER_THRESHOLD) {
-          newYawStableCount++;
-          if (newYawStableCount >= 2) {
-            newLivenessStep = 1; // Ready for left turn
-            runOnLiveness(newLivenessStep);
-            newYawStableCount = 0;
+              if (blinkCount >= REQUIRED_BLINKS) {
+                livenessStep = 2; // Ready for capture
+                runOnLiveness(livenessStep);
+              }
+            }
           }
-        } else {
-          newYawStableCount = 0;
-        }
-      } 
-      else if (newLivenessStep === 1 && !newLeftTurnVerified) {
-        // Step 1: Detect left turn
-        if (yaw < YAW_LEFT_THRESHOLD) {
-          newYawStableCount++;
-          if (newYawStableCount >= 2) {
-            newLeftTurnVerified = true;
-            newLivenessStep = 2; // Ready for right turn
-            runOnLiveness(newLivenessStep);
-            newYawStableCount = 0;
+          else if (livenessLevel === 2) {
+            // Face turn detection only
+            if (livenessStep === 0) {
+              if (Math.abs(yaw) < YAW_CENTER_THRESHOLD) {
+                yawStableCount++;
+                if (yawStableCount >= 2) {
+                  livenessStep = 1; // Move to left turn
+                  runOnLiveness(livenessStep);
+                  yawStableCount = 0;
+                }
+              } else yawStableCount = 0;
+            } else if (livenessStep === 1 && !leftTurnVerified) {
+              if (yaw < YAW_LEFT_THRESHOLD) {
+                yawStableCount++;
+                if (yawStableCount >= 2) {
+                  leftTurnVerified = true;
+                  livenessStep = 2; // Move to right turn
+                  runOnLiveness(livenessStep);
+                  yawStableCount = 0;
+                }
+              } else yawStableCount = Math.max(0, yawStableCount - 0.5);
+            } else if (livenessStep === 2 && leftTurnVerified && !rightTurnVerified) {
+              if (yaw > YAW_RIGHT_THRESHOLD) {
+                yawStableCount++;
+                if (yawStableCount >= 2) {
+                  rightTurnVerified = true;
+                  livenessStep = 3; // Ready for capture
+                  runOnLiveness(livenessStep);
+                  yawStableCount = 0;
+                }
+              } else yawStableCount = Math.max(0, yawStableCount - 0.5);
+            }
           }
-        } else {
-          newYawStableCount = Math.max(0, newYawStableCount - 0.5);
-        }
-      } 
-      else if (newLivenessStep === 2 && newLeftTurnVerified && !newRightTurnVerified) {
-        // Step 2: Detect right turn
-        if (yaw > YAW_RIGHT_THRESHOLD) {
-          newYawStableCount++;
-          if (newYawStableCount >= 2) {
-            newRightTurnVerified = true;
-            newLivenessStep = 3; // Ready for capture
-            runOnLiveness(newLivenessStep);
-            newYawStableCount = 0;
+          else if (livenessLevel === 3) {
+            // Both blink and face turn detection
+            if (livenessStep === 0) {
+              if (Math.abs(yaw) < YAW_CENTER_THRESHOLD) {
+                yawStableCount++;
+                if (yawStableCount >= 2) {
+                  livenessStep = 1; // Move to left turn
+                  runOnLiveness(livenessStep);
+                  yawStableCount = 0;
+                }
+              } else yawStableCount = 0;
+            } else if (livenessStep === 1 && !leftTurnVerified) {
+              if (yaw < YAW_LEFT_THRESHOLD) {
+                yawStableCount++;
+                if (yawStableCount >= 2) {
+                  leftTurnVerified = true;
+                  livenessStep = 2; // Move to right turn
+                  runOnLiveness(livenessStep);
+                  yawStableCount = 0;
+                }
+              } else yawStableCount = Math.max(0, yawStableCount - 0.5);
+            } else if (livenessStep === 2 && leftTurnVerified && !rightTurnVerified) {
+              if (yaw > YAW_RIGHT_THRESHOLD) {
+                yawStableCount++;
+                if (yawStableCount >= 2) {
+                  rightTurnVerified = true;
+                  livenessStep = 3; // Move to blink step
+                  runOnLiveness(livenessStep);
+                  yawStableCount = 0;
+                }
+              } else yawStableCount = Math.max(0, yawStableCount - 0.5);
+            }
+            // Blink detection
+            else if (livenessStep === 3 && leftTurnVerified && rightTurnVerified) {
+              const leftEye = face.leftEyeOpenProbability ?? 1;
+              const rightEye = face.rightEyeOpenProbability ?? 1;
+              const eyesClosed = leftEye < BLINK_THRESHOLD && rightEye < BLINK_THRESHOLD;
+
+              if (eyesClosed && !eyeClosed) {
+                blinkCount++;
+                eyeClosed = true;
+                runOnLiveness(livenessStep, { blinkCount });
+              } else if (!eyesClosed && eyeClosed) {
+                eyeClosed = false;
+              }
+
+              if (blinkCount >= REQUIRED_BLINKS) {
+                livenessStep = 4; // Ready for capture
+                runOnLiveness(livenessStep);
+              }
+            }
           }
-        } else {
-          newYawStableCount = Math.max(0, newYawStableCount - 0.5);
-        }
-      } 
-      else if (newLivenessStep === 3 && newLeftTurnVerified && newRightTurnVerified) {
-        // Step 3: Wait for face to return to center for capture
-        if (Math.abs(yaw) < YAW_CENTER_THRESHOLD) {
-          newYawStableCount++;
-        } else {
-          newYawStableCount = 0;
-        }
-      }
 
-      // Calculate face stability for capture
-      let newStableCount = state.stableCount;
-      if (state.lastX === 0 && state.lastY === 0) {
-        newStableCount = 1;
-      } else {
-        const dx = Math.abs(x - state.lastX);
-        const dy = Math.abs(y - state.lastY);
-        if (dx < FACE_MOVEMENT_THRESHOLD && dy < FACE_MOVEMENT_THRESHOLD) {
-          newStableCount = state.stableCount + 1;
+          // ---- Face stability check ----
+          let newStableCount = state.stableCount;
+          if (state.lastX === 0 && state.lastY === 0) newStableCount = 1;
+          else {
+            const dx = Math.abs(x - state.lastX);
+            const dy = Math.abs(y - state.lastY);
+            if (dx < FACE_MOVEMENT_THRESHOLD && dy < FACE_MOVEMENT_THRESHOLD)
+              newStableCount = state.stableCount + 1;
+            else newStableCount = 1;
+          }
+
+          // Mutate sharedState fields directly (avoid object reallocation)
+          state.lastProcessedTime = now;
+          state.lastX = x;
+          state.lastY = y;
+          state.lastW = width;
+          state.lastH = height;
+          state.stableCount = newStableCount;
+          state.livenessStep = livenessStep;
+          state.leftTurnVerified = leftTurnVerified;
+          state.rightTurnVerified = rightTurnVerified;
+          state.currentYaw = yaw;
+          state.yawStableCount = yawStableCount;
+          state.blinkCount = blinkCount;
+          state.eyeClosed = eyeClosed;
+
+          const progress = Math.min(100, (newStableCount / FACE_STABILITY_THRESHOLD) * 100);
+          runOnFaces(1, progress, livenessStep);
+
+          // Capture condition based on liveness level
+          let shouldCapture = false;
+          
+          if (livenessLevel === 0) {
+            // No liveness - capture when stable
+            shouldCapture = newStableCount >= FACE_STABILITY_THRESHOLD;
+          }
+          else if (livenessLevel === 1) {
+            // Blink only - capture after blinks and stable
+            shouldCapture = livenessStep === 2 && blinkCount >= REQUIRED_BLINKS && newStableCount >= FACE_STABILITY_THRESHOLD;
+          }
+          else if (livenessLevel === 2) {
+            // Face turn only - capture after turns and stable
+            shouldCapture = livenessStep === 3 && leftTurnVerified && rightTurnVerified && newStableCount >= FACE_STABILITY_THRESHOLD;
+          }
+          else if (livenessLevel === 3) {
+            // Both - capture after turns, blinks and stable
+            shouldCapture = livenessStep === 4 && blinkCount >= REQUIRED_BLINKS && newStableCount >= FACE_STABILITY_THRESHOLD;
+          }
+
+          if (shouldCapture && !state.captured) {
+            state.captured = true;
+            runOnStable({ x, y, width, height });
+          }
         } else {
-          newStableCount = 1;
+          // multiple faces — reset stability but keep liveness step
+          state.stableCount = 0;
+          state.lastProcessedTime = now;
+          state.yawStableCount = 0;
+          runOnFaces(detected.length, 0, state.livenessStep);
         }
+      } catch (err) {
+        // protect worklet from throwing
+        try {
+          console.error('FrameProcessor worklet error:', err);
+        } catch (e) {}
+      } finally {
+        // Always release the frame exactly once
+        frame.release?.();
       }
+    },
+    [detectFaces, isLoading]
+  );
 
-      // Update shared state
-      sharedState.value = {
-        ...state,
-        lastProcessedTime: now,
-        lastX: x,
-        lastY: y,
-        lastW: width,
-        lastH: height,
-        stableCount: newStableCount,
-        livenessStep: newLivenessStep,
-        leftTurnVerified: newLeftTurnVerified,
-        rightTurnVerified: newRightTurnVerified,
-        currentYaw: yaw,
-        yawStableCount: newYawStableCount,
-      };
-
-      // Calculate progress for UI
-      const progress = Math.min(100, (newStableCount / FACE_STABILITY_THRESHOLD) * 100);
-      runOnFaces(1, progress, newLivenessStep);
-
-      // Capture conditions: liveness complete + face stable + face centered
-      if (newLivenessStep === 3 && 
-          newLeftTurnVerified && 
-          newRightTurnVerified && 
-          newStableCount >= FACE_STABILITY_THRESHOLD &&
-          Math.abs(yaw) < YAW_CENTER_THRESHOLD &&
-          newYawStableCount >= 2) {
-        
-        sharedState.value = {
-          ...sharedState.value,
-          captured: true
-        };
-        runOnStable({ x, y, width, height });
-      }
-
-    } else {
-      // Multiple faces or other conditions
-      sharedState.value = { 
-        ...state, 
-        stableCount: 0, 
-        lastProcessedTime: now,
-        yawStableCount: 0
-      };
-      runOnFaces(detected.length, 0, state.livenessStep);
-    }
-  }, [detectFaces, isLoading]);
-
+  // Reset and cleanup logic
   const resetCaptureState = useCallback(() => {
-    sharedState.value = {
-      ...sharedState.value,
-      lastProcessedTime: 0,
-      lastX: 0,
-      lastY: 0,
-      lastW: 0,
-      lastH: 0,
-      stableCount: 0,
-      captured: false,
-      livenessStep: 0,
-      leftTurnVerified: false,
-      rightTurnVerified: false,
-      currentYaw: 0,
-      yawStableCount: 0,
-    };
+    const state = sharedState.value;
+    state.lastProcessedTime = 0;
+    state.lastX = 0;
+    state.lastY = 0;
+    state.lastW = 0;
+    state.lastH = 0;
+    state.stableCount = 0;
+    state.captured = false;
+    state.livenessStep = 0;
+    state.leftTurnVerified = false;
+    state.rightTurnVerified = false;
+    state.currentYaw = 0;
+    state.yawStableCount = 0;
+    state.blinkCount = 0;
+    state.eyeClosed = false;
   }, [sharedState]);
 
   const forceResetCaptureState = useCallback(() => {
-    sharedState.value = {
-      lastProcessedTime: 0,
-      lastX: 0,
-      lastY: 0,
-      lastW: 0,
-      lastH: 0,
-      stableCount: 0,
-      captured: false,
-      showCodeScanner: sharedState.value.showCodeScanner,
-      isActive: sharedState.value.isActive,
-      livenessStep: 0,
-      leftTurnVerified: false,
-      rightTurnVerified: false,
-      currentYaw: 0,
-      yawStableCount: 0,
-    };
+    const show = sharedState.value.showCodeScanner;
+    const active = sharedState.value.isActive;
+    const level = sharedState.value.livenessLevel;
+    sharedState.value.lastProcessedTime = 0;
+    sharedState.value.lastX = 0;
+    sharedState.value.lastY = 0;
+    sharedState.value.lastW = 0;
+    sharedState.value.lastH = 0;
+    sharedState.value.stableCount = 0;
+    sharedState.value.captured = false;
+    sharedState.value.showCodeScanner = show;
+    sharedState.value.isActive = active;
+    sharedState.value.livenessLevel = level;
+    sharedState.value.livenessStep = 0;
+    sharedState.value.leftTurnVerified = false;
+    sharedState.value.rightTurnVerified = false;
+    sharedState.value.currentYaw = 0;
+    sharedState.value.yawStableCount = 0;
+    sharedState.value.blinkCount = 0;
+    sharedState.value.eyeClosed = false;
   }, [sharedState]);
 
   const updateShowCodeScanner = useCallback(
     (value) => {
-      sharedState.value = { 
-        ...sharedState.value, 
-        showCodeScanner: !!value 
-      };
-    }, 
+      sharedState.value.showCodeScanner = !!value;
+    },
     [sharedState]
   );
 
   const updateIsActive = useCallback(
     (active) => {
-      sharedState.value = { 
-        ...sharedState.value, 
-        isActive: active,
-        // Reset capture state when deactivating
-        captured: active ? sharedState.value.captured : false
-      };
-    }, 
+      sharedState.value.isActive = !!active;
+      if (!active) sharedState.value.captured = false;
+    },
     [sharedState]
   );
 
-  // Cleanup on unmount
   useEffect(() => {
     isMounted.current = true;
-    
     return () => {
       isMounted.current = false;
       forceResetCaptureState();