omnipay-reactnative-sdk 1.2.2-beta.9 → 1.2.3-beta.10

package/src/components/biometrics/useFaceVerification.ts

@@ -0,0 +1,120 @@
+import {
+  useFrameProcessor,
+  VisionCameraProxy,
+} from 'react-native-vision-camera';
+
+export interface FaceVerificationResult {
+  faceDetected: boolean;
+  isSmiling?: boolean;
+  isBlinking?: boolean;
+  leftEyeClosed?: boolean;
+  rightEyeClosed?: boolean;
+  headPose?: {
+    yaw: number; // Left-right movement (-90 to 90)
+    pitch: number; // Up-down movement (-90 to 90)
+    roll: number; // Tilt movement (-180 to 180)
+  };
+  boundingBox?: {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+  };
+  smileProbability?: number;
+  leftEyeOpenProbability?: number;
+  rightEyeOpenProbability?: number;
+  trackingId?: number;
+  error?: string;
+}
+
+// Note: For production use, you would typically use shared values or state management
+// to communicate results from the worklet back to the React component.
+// This simplified version just logs results for debugging.
+
+// Initialize the plugin
+const plugin = VisionCameraProxy.initFrameProcessorPlugin('detectFaces', {});
+
+export const useFaceVerification = () => {
+  const frameProcessor = useFrameProcessor((frame) => {
+    'worklet';
+
+    try {
+      if (plugin == null) {
+        console.error('Failed to load Frame Processor Plugin "detectFaces"!');
+        return null;
+      }
+
+      const result = plugin.call(frame, {}) as any;
+
+      // For debugging - this works in worklets
+      if (result && result.faceDetected) {
+        console.log('Face detected:', result);
+      }
+
+      return result;
+    } catch (error) {
+      console.error('Face verification error:', error);
+      return {
+        faceDetected: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }, []);
+
+  return frameProcessor;
+};
+
+// Utility functions for interpreting results
+export const FaceVerificationUtils = {
+  // Check if head is turned left (yaw > 20 degrees)
+  isHeadTurnedLeft: (result: FaceVerificationResult): boolean => {
+    return result.headPose?.yaw ? result.headPose.yaw > 20 : false;
+  },
+
+  // Check if head is turned right (yaw < -20 degrees)
+  isHeadTurnedRight: (result: FaceVerificationResult): boolean => {
+    return result.headPose?.yaw ? result.headPose.yaw < -20 : false;
+  },
+
+  // Check if head is tilted up (pitch > 10 degrees)
+  isHeadTiltedUp: (result: FaceVerificationResult): boolean => {
+    return result.headPose?.pitch ? result.headPose.pitch > 10 : false;
+  },
+
+  // Check if head is tilted down (pitch < -10 degrees)
+  isHeadTiltedDown: (result: FaceVerificationResult): boolean => {
+    return result.headPose?.pitch ? result.headPose.pitch < -10 : false;
+  },
+
+  // Check if face is centered (within ±10 degrees)
+  isFaceCentered: (result: FaceVerificationResult): boolean => {
+    if (!result.headPose) return false;
+    const { yaw, pitch } = result.headPose;
+    return Math.abs(yaw) <= 10 && Math.abs(pitch) <= 10;
+  },
+
+  // Check if smile is confident (high probability)
+  isConfidentSmile: (result: FaceVerificationResult): boolean => {
+    return result.smileProbability
+      ? result.smileProbability > 0.8
+      : result.isSmiling || false;
+  },
+
+  // Check if both eyes are confidently closed
+  isConfidentBlink: (result: FaceVerificationResult): boolean => {
+    if (
+      result.leftEyeOpenProbability !== undefined &&
+      result.rightEyeOpenProbability !== undefined
+    ) {
+      return (
+        result.leftEyeOpenProbability < 0.2 &&
+        result.rightEyeOpenProbability < 0.2
+      );
+    }
+    return result.isBlinking || false;
+  },
+};

package/src/components/biometrics/useFaceVerificationFlow.ts

@@ -0,0 +1,224 @@
+import { useState, useEffect, useCallback } from 'react';
+import {
+  FaceVerificationResult,
+  FaceVerificationUtils,
+} from './useFaceVerification';
+
+export type VerificationStep =
+  | 'position_face'
+  | 'smile'
+  | 'blink'
+  | 'turn_left'
+  | 'turn_right'
+  | 'completed'
+  | 'failed';
+
+export interface VerificationFlowState {
+  currentStep: VerificationStep;
+  completedSteps: VerificationStep[];
+  stepStartTime: number;
+  totalStartTime: number;
+  isProcessing: boolean;
+  progress: number;
+  instruction: string;
+  error?: string;
+}
+
+export interface VerificationFlowConfig {
+  stepTimeout: number; // Maximum time per step (ms)
+  totalTimeout: number; // Maximum total time (ms)
+  confirmationFrames: number; // Frames needed to confirm action
+  requiredSteps: VerificationStep[]; // Steps to complete
+}
+
+const DEFAULT_CONFIG: VerificationFlowConfig = {
+  stepTimeout: 10000, // 10 seconds per step
+  totalTimeout: 60000, // 1 minute total
+  confirmationFrames: 5, // 5 consecutive frames
+  requiredSteps: ['position_face', 'smile', 'blink', 'turn_left', 'turn_right'],
+};
+
+const STEP_INSTRUCTIONS: Record<VerificationStep, string> = {
+  position_face: 'Position your face in the center of the frame',
+  smile: 'Please smile for the camera',
+  blink: 'Please blink your eyes',
+  turn_left: 'Slowly turn your head to the left',
+  turn_right: 'Slowly turn your head to the right',
+  completed: 'Verification completed successfully!',
+  failed: 'Verification failed. Please try again.',
+};
+
+export const useFaceVerificationFlow = (
+  config: Partial<VerificationFlowConfig> = {}
+) => {
+  const fullConfig = { ...DEFAULT_CONFIG, ...config };
+
+  const [state, setState] = useState<VerificationFlowState>({
+    currentStep: 'position_face',
+    completedSteps: [],
+    stepStartTime: Date.now(),
+    totalStartTime: Date.now(),
+    isProcessing: false,
+    progress: 0,
+    instruction: STEP_INSTRUCTIONS.position_face,
+  });
+
+  const [confirmationCount, setConfirmationCount] = useState(0);
+
+  // Reset verification flow
+  const resetFlow = useCallback(() => {
+    const now = Date.now();
+    setState({
+      currentStep: 'position_face',
+      completedSteps: [],
+      stepStartTime: now,
+      totalStartTime: now,
+      isProcessing: false,
+      progress: 0,
+      instruction: STEP_INSTRUCTIONS.position_face,
+    });
+    setConfirmationCount(0);
+  }, []);
+
+  // Check if current step is completed based on face detection result
+  const checkStepCompletion = useCallback(
+    (result: FaceVerificationResult): boolean => {
+      if (!result.faceDetected) return false;
+
+      switch (state.currentStep) {
+        case 'position_face':
+          return FaceVerificationUtils.isFaceCentered(result);
+
+        case 'smile':
+          return FaceVerificationUtils.isConfidentSmile(result);
+
+        case 'blink':
+          return FaceVerificationUtils.isConfidentBlink(result);
+
+        case 'turn_left':
+          return FaceVerificationUtils.isHeadTurnedLeft(result);
+
+        case 'turn_right':
+          return FaceVerificationUtils.isHeadTurnedRight(result);
+
+        default:
+          return false;
+      }
+    },
+    [state.currentStep]
+  );
+
+  // Get next step in sequence
+  const getNextStep = useCallback(
+    (currentStep: VerificationStep): VerificationStep => {
+      const currentIndex = fullConfig.requiredSteps.indexOf(currentStep);
+      if (
+        currentIndex === -1 ||
+        currentIndex === fullConfig.requiredSteps.length - 1
+      ) {
+        return 'completed';
+      }
+      const nextStep = fullConfig.requiredSteps[currentIndex + 1];
+      return nextStep || 'completed';
+    },
+    [fullConfig.requiredSteps]
+  );
+
+  // Process face detection result
+  const processFaceResult = useCallback(
+    (result: FaceVerificationResult) => {
+      if (state.currentStep === 'completed' || state.currentStep === 'failed') {
+        return;
+      }
+
+      const now = Date.now();
+
+      // Check for timeouts
+      if (now - state.totalStartTime > fullConfig.totalTimeout) {
+        setState((prev) => ({
+          ...prev,
+          currentStep: 'failed',
+          instruction: 'Verification timed out. Please try again.',
+          error: 'Total verification timeout exceeded',
+        }));
+        return;
+      }
+
+      if (now - state.stepStartTime > fullConfig.stepTimeout) {
+        setState((prev) => ({
+          ...prev,
+          currentStep: 'failed',
+          instruction: 'Step timed out. Please try again.',
+          error: 'Step timeout exceeded',
+        }));
+        return;
+      }
+
+      // Check if current step is completed
+      const stepCompleted = checkStepCompletion(result);
+
+      if (stepCompleted) {
+        setConfirmationCount((prev) => prev + 1);
+
+        // Require multiple consecutive confirmations
+        if (confirmationCount + 1 >= fullConfig.confirmationFrames) {
+          const nextStep = getNextStep(state.currentStep);
+          const newCompletedSteps = [
+            ...state.completedSteps,
+            state.currentStep,
+          ];
+          const newProgress =
+            (newCompletedSteps.length / fullConfig.requiredSteps.length) * 100;
+
+          setState((prev) => ({
+            ...prev,
+            currentStep: nextStep,
+            completedSteps: newCompletedSteps,
+            stepStartTime: now,
+            progress: newProgress,
+            instruction: STEP_INSTRUCTIONS[nextStep],
+            isProcessing: nextStep === 'completed',
+          }));
+
+          setConfirmationCount(0);
+        }
+      } else {
+        // Reset confirmation count if step not completed
+        setConfirmationCount(0);
+      }
+    },
+    [
+      state,
+      fullConfig.totalTimeout,
+      fullConfig.stepTimeout,
+      fullConfig.confirmationFrames,
+      fullConfig.requiredSteps.length,
+      confirmationCount,
+      checkStepCompletion,
+      getNextStep,
+    ]
+  );
+
+  // Auto-reset on mount
+  useEffect(() => {
+    resetFlow();
+  }, [resetFlow]);
+
+  return {
+    state,
+    processFaceResult,
+    resetFlow,
+    isCompleted: state.currentStep === 'completed',
+    isFailed: state.currentStep === 'failed',
+    isActive:
+      state.currentStep !== 'completed' && state.currentStep !== 'failed',
+    remainingTime: Math.max(
+      0,
+      fullConfig.stepTimeout - (Date.now() - state.stepStartTime)
+    ),
+    totalRemainingTime: Math.max(
+      0,
+      fullConfig.totalTimeout - (Date.now() - state.totalStartTime)
+    ),
+  };
+};

package/src/index.tsx

@@ -2,11 +2,4 @@ import Omnipay from './components/OmnipayView';
 
 export { OmnipayProvider } from './components/OmnipayProvider';
 export { useOmnipay } from './hooks/useOmnipay';
-
-// Biometric components and utilities
-export { FaceVerification, LivenessDetection } from './components/biometrics';
-
-// Biometric types
-export * from './components/biometrics/types';
-
 export default Omnipay;

package/android/src/main/java/com/omniretail/omnipay/OmnipayLivenessCameraView.java

@@ -1,153 +0,0 @@
-package com.omniretail.omnipay;
-
-import android.content.Context;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.widget.FrameLayout;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.camera.core.CameraSelector;
-import androidx.camera.core.Preview;
-import androidx.camera.lifecycle.ProcessCameraProvider;
-import androidx.camera.view.PreviewView;
-import androidx.core.content.ContextCompat;
-import androidx.lifecycle.LifecycleOwner;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
-import com.google.common.util.concurrent.ListenableFuture;
-
-import java.util.concurrent.ExecutionException;
-
-public class OmnipayLivenessCameraView extends FrameLayout {
-    private static final String TAG = "OmnipayLivenessCameraView";
-    
-    private PreviewView previewView;
-    private ProcessCameraProvider cameraProvider;
-    private Preview preview;
-    private boolean isInitialized = false;
-    
-    public OmnipayLivenessCameraView(@NonNull Context context) {
-        super(context);
-        init();
-    }
-    
-    public OmnipayLivenessCameraView(@NonNull Context context, @Nullable AttributeSet attrs) {
-        super(context, attrs);
-        init();
-    }
-    
-    public OmnipayLivenessCameraView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
-        init();
-    }
-    
-    private void init() {
-        // Create and add PreviewView
-        previewView = new PreviewView(getContext());
-        previewView.setLayoutParams(new FrameLayout.LayoutParams(
-                FrameLayout.LayoutParams.MATCH_PARENT,
-                FrameLayout.LayoutParams.MATCH_PARENT
-        ));
-        previewView.setScaleType(PreviewView.ScaleType.FILL_CENTER);
-        addView(previewView);
-        
-        // Initialize camera
-        initializeCamera();
-    }
-    
-    private void initializeCamera() {
-        ListenableFuture<ProcessCameraProvider> cameraProviderFuture = 
-            ProcessCameraProvider.getInstance(getContext());
-            
-        cameraProviderFuture.addListener(() -> {
-            try {
-                cameraProvider = cameraProviderFuture.get();
-                setupCamera();
-                isInitialized = true;
-                sendEvent("onCameraReady", Arguments.createMap());
-            } catch (ExecutionException | InterruptedException e) {
-                Log.e(TAG, "Error initializing camera", e);
-                WritableMap errorMap = Arguments.createMap();
-                errorMap.putString("error", "Failed to initialize camera: " + e.getMessage());
-                sendEvent("onCameraError", errorMap);
-            }
-        }, ContextCompat.getMainExecutor(getContext()));
-    }
-    
-    private void setupCamera() {
-        if (cameraProvider == null) {
-            return;
-        }
-        
-        // Create preview use case
-        preview = new Preview.Builder().build();
-        
-        // Connect preview to PreviewView
-        preview.setSurfaceProvider(previewView.getSurfaceProvider());
-        
-        // Select front camera
-        CameraSelector cameraSelector = CameraSelector.DEFAULT_FRONT_CAMERA;
-        
-        try {
-            // Unbind all use cases before rebinding
-            cameraProvider.unbindAll();
-            
-            // Bind preview to camera
-            if (getContext() instanceof LifecycleOwner) {
-                cameraProvider.bindToLifecycle(
-                    (LifecycleOwner) getContext(),
-                    cameraSelector,
-                    preview
-                );
-            } else {
-                Log.w(TAG, "Context is not a LifecycleOwner, camera preview may not work properly");
-            }
-        } catch (Exception e) {
-            Log.e(TAG, "Error binding camera", e);
-            WritableMap errorMap = Arguments.createMap();
-            errorMap.putString("error", "Failed to bind camera: " + e.getMessage());
-            sendEvent("onCameraError", errorMap);
-        }
-    }
-    
-    public void setupCameraPreview(ProcessCameraProvider cameraProvider) {
-        this.cameraProvider = cameraProvider;
-        if (isInitialized) {
-            setupCamera();
-        }
-    }
-    
-    public void startPreview() {
-        if (preview != null && cameraProvider != null) {
-            // Camera preview is automatically started when bound to lifecycle
-            Log.d(TAG, "Camera preview started");
-        }
-    }
-    
-    public void stopPreview() {
-        if (cameraProvider != null) {
-            cameraProvider.unbindAll();
-            Log.d(TAG, "Camera preview stopped");
-        }
-    }
-    
-    @Override
-    protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
-        stopPreview();
-    }
-    
-    private void sendEvent(String eventName, WritableMap params) {
-        ReactContext reactContext = (ReactContext) getContext();
-        if (reactContext != null) {
-            reactContext.getJSModule(RCTEventEmitter.class)
-                .receiveEvent(getId(), eventName, params);
-        }
-    }
-} 

package/android/src/main/java/com/omniretail/omnipay/OmnipayLivenessCameraViewManager.java

@@ -1,49 +0,0 @@
-package com.omniretail.omnipay;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.common.MapBuilder;
-import com.facebook.react.uimanager.SimpleViewManager;
-import com.facebook.react.uimanager.ThemedReactContext;
-import com.facebook.react.uimanager.annotations.ReactProp;
-
-import java.util.Map;
-
-public class OmnipayLivenessCameraViewManager extends SimpleViewManager<OmnipayLivenessCameraView> {
-    public static final String REACT_CLASS = "OmnipayLivenessCameraView";
-    
-    private ReactApplicationContext reactContext;
-    
-    public OmnipayLivenessCameraViewManager(ReactApplicationContext reactContext) {
-        this.reactContext = reactContext;
-    }
-    
-    @NonNull
-    @Override
-    public String getName() {
-        return REACT_CLASS;
-    }
-    
-    @NonNull
-    @Override
-    protected OmnipayLivenessCameraView createViewInstance(@NonNull ThemedReactContext reactContext) {
-        return new OmnipayLivenessCameraView(reactContext);
-    }
-    
-    @Nullable
-    @Override
-    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
-        return MapBuilder.<String, Object>builder()
-                .put("onCameraReady", MapBuilder.of("registrationName", "onCameraReady"))
-                .put("onCameraError", MapBuilder.of("registrationName", "onCameraError"))
-                .build();
-    }
-    
-    @Override
-    public void onDropViewInstance(@NonNull OmnipayLivenessCameraView view) {
-        view.stopPreview();
-        super.onDropViewInstance(view);
-    }
-}