omnipay-reactnative-sdk 1.2.1 → 1.2.2-beta.2

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

@@ -0,0 +1,588 @@
+package com.omniretail.omnipay;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.ImageFormat;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.YuvImage;
+import android.media.Image;
+import android.util.Base64;
+import android.util.Log;
+import android.view.View;
+import android.Manifest;
+
+import androidx.annotation.NonNull;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.ImageAnalysis;
+import androidx.camera.core.ImageCapture;
+import androidx.camera.core.ImageCaptureException;
+import androidx.camera.core.ImageProxy;
+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.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.mlkit.vision.common.InputImage;
+import com.google.mlkit.vision.face.Face;
+import com.google.mlkit.vision.face.FaceDetection;
+import com.google.mlkit.vision.face.FaceDetector;
+import com.google.mlkit.vision.face.FaceDetectorOptions;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.HashMap;
+import java.util.Map;
+
+public class LivenessDetectionModule extends ReactContextBaseJavaModule {
+    private static final String MODULE_NAME = "LivenessDetection";
+    private static final String TAG = "LivenessDetection";
+    
+    // Events
+    private static final String EVENT_CHALLENGE_START = "onChallengeStart";
+    private static final String EVENT_CHALLENGE_SUCCESS = "onChallengeSuccess";
+    private static final String EVENT_CHALLENGE_FAILURE = "onChallengeFailure";
+    private static final String EVENT_ALL_CHALLENGES_COMPLETE = "onAllChallengesComplete";
+    private static final String EVENT_SCREENSHOT_CAPTURED = "onScreenshotCaptured";
+    
+    // Challenge types
+    public enum ChallengeType {
+        SMILE("smile"),
+        BLINK("blink"),
+        TURN_LEFT("turn_left"),
+        TURN_RIGHT("turn_right");
+        
+        private final String value;
+        ChallengeType(String value) { this.value = value; }
+        public String getValue() { return value; }
+    }
+    
+    // Detection state
+    private boolean isDetectionActive = false;
+    private Queue<ChallengeType> pendingChallenges;
+    private ChallengeType currentChallenge;
+    private long challengeStartTime;
+    private static final long CHALLENGE_TIMEOUT = 10000; // 10 seconds
+    
+    // Camera components
+    private ProcessCameraProvider cameraProvider;
+    private Preview preview;
+    private ImageAnalysis imageAnalysis;
+    private ImageCapture imageCapture;
+    private PreviewView previewView;
+    private ExecutorService cameraExecutor;
+    
+    // ML Kit face detector
+    private FaceDetector faceDetector;
+    
+    // Challenge validation
+    private boolean lastSmileState = false;
+    private boolean lastLeftEyeOpen = true;
+    private boolean lastRightEyeOpen = true;
+    private float lastHeadYaw = 0f;
+    
+    // Detection thresholds
+    private static final float SMILE_THRESHOLD = 0.8f;
+    private static final float EYE_OPEN_THRESHOLD = 0.6f;
+    private static final float HEAD_YAW_THRESHOLD = 15f; // degrees
+    
+    // Permission request code
+    private static final int CAMERA_PERMISSION_REQUEST_CODE = 1001;
+    
+    // Permission promise
+    private Promise mPermissionPromise;
+    
+    private ReactApplicationContext reactContext;
+
+    public LivenessDetectionModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.cameraExecutor = Executors.newSingleThreadExecutor();
+        
+        // Initialize ML Kit face detector
+        FaceDetectorOptions options = new FaceDetectorOptions.Builder()
+                .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST)
+                .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
+                .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
+                .build();
+        
+        this.faceDetector = FaceDetection.getClient(options);
+    }
+
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        constants.put("CHALLENGE_SMILE", ChallengeType.SMILE.getValue());
+        constants.put("CHALLENGE_BLINK", ChallengeType.BLINK.getValue());
+        constants.put("CHALLENGE_TURN_LEFT", ChallengeType.TURN_LEFT.getValue());
+        constants.put("CHALLENGE_TURN_RIGHT", ChallengeType.TURN_RIGHT.getValue());
+        return constants;
+    }
+
+    @ReactMethod
+    public void startLivenessDetection(ReadableArray challenges, Promise promise) {
+        if (isDetectionActive) {
+            promise.reject("ALREADY_ACTIVE", "Liveness detection is already active");
+            return;
+        }
+        
+        // Check camera permission first
+        if (!hasCameraPermission()) {
+            promise.reject("CAMERA_PERMISSION_DENIED", "Camera permission is required for liveness detection");
+            return;
+        }
+        
+        try {
+            // Parse challenges
+            pendingChallenges = new LinkedList<>();
+            for (int i = 0; i < challenges.size(); i++) {
+                String challengeStr = challenges.getString(i);
+                ChallengeType challenge = getChallengeFromString(challengeStr);
+                if (challenge != null) {
+                    pendingChallenges.offer(challenge);
+                }
+            }
+            
+            if (pendingChallenges.isEmpty()) {
+                promise.reject("INVALID_CHALLENGES", "No valid challenges provided");
+                return;
+            }
+            
+            isDetectionActive = true;
+            startCamera();
+            startNextChallenge();
+            promise.resolve("Detection started");
+            
+        } catch (Exception e) {
+            promise.reject("START_ERROR", "Failed to start liveness detection: " + e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void checkCameraPermission(Promise promise) {
+        promise.resolve(hasCameraPermission());
+    }
+
+    @ReactMethod
+    public void requestCameraPermission(Promise promise) {
+        if (hasCameraPermission()) {
+            promise.resolve(true);
+            return;
+        }
+        
+        Activity currentActivity = getCurrentActivity();
+        if (currentActivity == null) {
+            promise.reject("NO_ACTIVITY", "No current activity available");
+            return;
+        }
+        
+        // Store promise for permission result
+        mPermissionPromise = promise;
+        
+        // Request camera permission
+        currentActivity.requestPermissions(
+            new String[]{Manifest.permission.CAMERA},
+            CAMERA_PERMISSION_REQUEST_CODE
+        );
+    }
+
+    @ReactMethod
+    public void stopLivenessDetection() {
+        isDetectionActive = false;
+        currentChallenge = null;
+        if (pendingChallenges != null) {
+            pendingChallenges.clear();
+        }
+        stopCamera();
+    }
+
+    @ReactMethod
+    public void getCameraView(Promise promise) {
+        try {
+            Activity currentActivity = getCurrentActivity();
+            if (currentActivity == null) {
+                promise.reject("NO_ACTIVITY", "No current activity");
+                return;
+            }
+            
+            if (previewView == null) {
+                previewView = new PreviewView(currentActivity);
+            }
+            
+            promise.resolve("Camera view created");
+        } catch (Exception e) {
+            promise.reject("CAMERA_VIEW_ERROR", "Failed to create camera view: " + e.getMessage());
+        }
+    }
+
+    public PreviewView getPreviewView() {
+        return previewView;
+    }
+
+    private void startCamera() {
+        Activity currentActivity = getCurrentActivity();
+        if (currentActivity == null) return;
+        
+        ListenableFuture<ProcessCameraProvider> cameraProviderFuture = 
+            ProcessCameraProvider.getInstance(currentActivity);
+        
+        cameraProviderFuture.addListener(() -> {
+            try {
+                cameraProvider = cameraProviderFuture.get();
+                bindCameraUseCases();
+            } catch (ExecutionException | InterruptedException e) {
+                Log.e(TAG, "Camera initialization failed", e);
+            }
+        }, ContextCompat.getMainExecutor(currentActivity));
+    }
+
+    private void bindCameraUseCases() {
+        Activity currentActivity = getCurrentActivity();
+        if (currentActivity == null || cameraProvider == null) return;
+        
+        // Preview use case
+        preview = new Preview.Builder().build();
+        if (previewView != null) {
+            preview.setSurfaceProvider(previewView.getSurfaceProvider());
+        }
+        
+        // Image capture use case for final screenshot
+        imageCapture = new ImageCapture.Builder().build();
+        
+        // Image analysis use case for face detection
+        imageAnalysis = new ImageAnalysis.Builder()
+                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                .build();
+        
+        imageAnalysis.setAnalyzer(cameraExecutor, this::analyzeImage);
+        
+        // Camera selector (front-facing camera)
+        CameraSelector cameraSelector = CameraSelector.DEFAULT_FRONT_CAMERA;
+        
+        try {
+            // Unbind all use cases before rebinding
+            cameraProvider.unbindAll();
+            
+            // Bind use cases to camera
+            cameraProvider.bindToLifecycle(
+                (LifecycleOwner) currentActivity,
+                cameraSelector,
+                preview,
+                imageAnalysis,
+                imageCapture
+            );
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Camera binding failed", e);
+        }
+    }
+
+    private void analyzeImage(@NonNull ImageProxy imageProxy) {
+        if (!isDetectionActive || currentChallenge == null) {
+            imageProxy.close();
+            return;
+        }
+        
+        @SuppressWarnings("UnsafeOptInUsageError")
+        Image mediaImage = imageProxy.getImage();
+        if (mediaImage != null) {
+            InputImage image = InputImage.fromMediaImage(
+                mediaImage, 
+                imageProxy.getImageInfo().getRotationDegrees()
+            );
+            
+            faceDetector.process(image)
+                .addOnSuccessListener(faces -> {
+                    processFaceDetection(faces);
+                    imageProxy.close();
+                })
+                .addOnFailureListener(e -> {
+                    Log.e(TAG, "Face detection failed", e);
+                    imageProxy.close();
+                });
+        } else {
+            imageProxy.close();
+        }
+    }
+
+    private void processFaceDetection(List<Face> faces) {
+        if (faces.isEmpty()) {
+            // No face detected
+            return;
+        }
+        
+        Face face = faces.get(0); // Use first detected face
+        
+        // Check challenge timeout
+        if (System.currentTimeMillis() - challengeStartTime > CHALLENGE_TIMEOUT) {
+            emitChallengeFailure("Challenge timeout");
+            startNextChallenge();
+            return;
+        }
+        
+        // Validate current challenge
+        boolean challengeSuccess = false;
+        
+        switch (currentChallenge) {
+            case SMILE:
+                challengeSuccess = validateSmileChallenge(face);
+                break;
+            case BLINK:
+                challengeSuccess = validateBlinkChallenge(face);
+                break;
+            case TURN_LEFT:
+                challengeSuccess = validateTurnLeftChallenge(face);
+                break;
+            case TURN_RIGHT:
+                challengeSuccess = validateTurnRightChallenge(face);
+                break;
+        }
+        
+        if (challengeSuccess) {
+            emitChallengeSuccess();
+            startNextChallenge();
+        }
+    }
+
+    private boolean validateSmileChallenge(Face face) {
+        float smilingProbability = face.getSmilingProbability() != null ? 
+            face.getSmilingProbability() : 0f;
+        
+        boolean isSmiling = smilingProbability > SMILE_THRESHOLD;
+        
+        // Detect transition from not smiling to smiling
+        if (isSmiling && !lastSmileState) {
+            lastSmileState = true;
+            return true;
+        }
+        
+        lastSmileState = isSmiling;
+        return false;
+    }
+
+    private boolean validateBlinkChallenge(Face face) {
+        float leftEyeOpen = face.getLeftEyeOpenProbability() != null ? 
+            face.getLeftEyeOpenProbability() : 1f;
+        float rightEyeOpen = face.getRightEyeOpenProbability() != null ? 
+            face.getRightEyeOpenProbability() : 1f;
+        
+        boolean leftClosed = leftEyeOpen < (1f - EYE_OPEN_THRESHOLD);
+        boolean rightClosed = rightEyeOpen < (1f - EYE_OPEN_THRESHOLD);
+        boolean bothClosed = leftClosed && rightClosed;
+        
+        // Detect blink: transition from open to closed and back to open
+        if (lastLeftEyeOpen && lastRightEyeOpen && bothClosed) {
+            // Eyes just closed
+            lastLeftEyeOpen = false;
+            lastRightEyeOpen = false;
+        } else if (!lastLeftEyeOpen && !lastRightEyeOpen && !bothClosed) {
+            // Eyes opened after being closed - blink detected!
+            lastLeftEyeOpen = true;
+            lastRightEyeOpen = true;
+            return true;
+        }
+        
+        return false;
+    }
+
+    private boolean validateTurnLeftChallenge(Face face) {
+        float headYaw = face.getHeadEulerAngleY();
+        
+        // Positive yaw = head turned left (user's left)
+        if (headYaw > HEAD_YAW_THRESHOLD && Math.abs(lastHeadYaw) < HEAD_YAW_THRESHOLD) {
+            lastHeadYaw = headYaw;
+            return true;
+        }
+        
+        lastHeadYaw = headYaw;
+        return false;
+    }
+
+    private boolean validateTurnRightChallenge(Face face) {
+        float headYaw = face.getHeadEulerAngleY();
+        
+        // Negative yaw = head turned right (user's right)
+        if (headYaw < -HEAD_YAW_THRESHOLD && Math.abs(lastHeadYaw) < HEAD_YAW_THRESHOLD) {
+            lastHeadYaw = headYaw;
+            return true;
+        }
+        
+        lastHeadYaw = headYaw;
+        return false;
+    }
+
+    private void startNextChallenge() {
+        if (pendingChallenges == null || pendingChallenges.isEmpty()) {
+            // All challenges completed - take final screenshot
+            captureScreenshot();
+            return;
+        }
+        
+        currentChallenge = pendingChallenges.poll();
+        challengeStartTime = System.currentTimeMillis();
+        
+        // Reset challenge-specific state
+        resetChallengeState();
+        
+        emitChallengeStart();
+    }
+
+    private void resetChallengeState() {
+        lastSmileState = false;
+        lastLeftEyeOpen = true;
+        lastRightEyeOpen = true;
+        lastHeadYaw = 0f;
+    }
+
+    private void captureScreenshot() {
+        if (imageCapture == null) {
+            emitAllChallengesComplete(null);
+            return;
+        }
+        
+        ImageCapture.OutputFileOptions outputFileOptions = 
+            new ImageCapture.OutputFileOptions.Builder(
+                new java.io.File(reactContext.getCacheDir(), "liveness_screenshot.jpg")
+            ).build();
+        
+        imageCapture.takePicture(
+            outputFileOptions,
+            ContextCompat.getMainExecutor(reactContext),
+            new ImageCapture.OnImageSavedCallback() {
+                @Override
+                public void onImageSaved(@NonNull ImageCapture.OutputFileResults output) {
+                    try {
+                        // Read the saved image and convert to base64
+                        java.io.File imageFile = new java.io.File(reactContext.getCacheDir(), "liveness_screenshot.jpg");
+                        byte[] imageBytes = java.nio.file.Files.readAllBytes(imageFile.toPath());
+                        String base64Image = Base64.encodeToString(imageBytes, Base64.DEFAULT);
+                        
+                        emitScreenshotCaptured(base64Image);
+                        emitAllChallengesComplete(base64Image);
+                        
+                        // Clean up
+                        imageFile.delete();
+                        stopLivenessDetection();
+                        
+                    } catch (Exception e) {
+                        Log.e(TAG, "Failed to process screenshot", e);
+                        emitAllChallengesComplete(null);
+                    }
+                }
+                
+                @Override
+                public void onError(@NonNull ImageCaptureException exception) {
+                    Log.e(TAG, "Screenshot capture failed", exception);
+                    emitAllChallengesComplete(null);
+                }
+            }
+        );
+    }
+
+    private void stopCamera() {
+        if (cameraProvider != null) {
+            cameraProvider.unbindAll();
+        }
+    }
+
+    private ChallengeType getChallengeFromString(String challengeStr) {
+        for (ChallengeType challenge : ChallengeType.values()) {
+            if (challenge.getValue().equals(challengeStr)) {
+                return challenge;
+            }
+        }
+        return null;
+    }
+
+    // Event emission methods
+    private void emitChallengeStart() {
+        WritableMap params = Arguments.createMap();
+        params.putString("challenge", currentChallenge.getValue());
+        sendEvent(EVENT_CHALLENGE_START, params);
+    }
+
+    private void emitChallengeSuccess() {
+        WritableMap params = Arguments.createMap();
+        params.putString("challenge", currentChallenge.getValue());
+        sendEvent(EVENT_CHALLENGE_SUCCESS, params);
+    }
+
+    private void emitChallengeFailure(String reason) {
+        WritableMap params = Arguments.createMap();
+        params.putString("challenge", currentChallenge != null ? currentChallenge.getValue() : "unknown");
+        params.putString("reason", reason);
+        sendEvent(EVENT_CHALLENGE_FAILURE, params);
+    }
+
+    private void emitAllChallengesComplete(String screenshot) {
+        WritableMap params = Arguments.createMap();
+        params.putBoolean("success", true);
+        if (screenshot != null) {
+            params.putString("screenshot", screenshot);
+        }
+        sendEvent(EVENT_ALL_CHALLENGES_COMPLETE, params);
+    }
+
+    private void emitScreenshotCaptured(String screenshot) {
+        WritableMap params = Arguments.createMap();
+        params.putString("screenshot", screenshot);
+        sendEvent(EVENT_SCREENSHOT_CAPTURED, params);
+    }
+
+    private void sendEvent(String eventName, WritableMap params) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+            .emit(eventName, params);
+    }
+
+    // Permission helper methods
+    private boolean hasCameraPermission() {
+        return reactContext.checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    // Handle permission request results
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        if (requestCode == CAMERA_PERMISSION_REQUEST_CODE) {
+            if (mPermissionPromise != null) {
+                boolean granted = grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED;
+                mPermissionPromise.resolve(granted);
+                mPermissionPromise = null;
+            }
+        }
+    }
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        if (cameraExecutor != null) {
+            cameraExecutor.shutdown();
+        }
+        stopLivenessDetection();
+    }
+} 

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

@@ -16,12 +16,15 @@ public class OmnipayActivityPackage implements ReactPackage {
     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
         List<NativeModule> modules = new ArrayList<>();
         modules.add(new OmnipayActivityModule(reactContext));
+        modules.add(new LivenessDetectionModule(reactContext));
         return modules;
     }
 
     @Override
     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-        return Collections.emptyList();
+        List<ViewManager> viewManagers = new ArrayList<>();
+        viewManagers.add(new LivenessCameraViewManager(reactContext));
+        return viewManagers;
     }
 
     // Deprecated RN 0.47

package/ios/LivenessCameraView.h

@@ -0,0 +1,22 @@
+//
+//  LivenessCameraView.h
+//  omnipay-reactnative-sdk
+//
+//  Created by React Native Auto-generated
+//
+
+#import <UIKit/UIKit.h>
+#import <React/RCTComponent.h>
+#import <AVFoundation/AVFoundation.h>
+
+@class RCTBridge;
+
+@interface LivenessCameraView : UIView
+
+@property (nonatomic, strong) NSString *scaleType;
+@property (nonatomic, copy) RCTDirectEventBlock onCameraReady;
+@property (nonatomic, copy) RCTDirectEventBlock onCameraError;
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+@end