omnipay-reactnative-sdk 1.2.2-beta.3 → 1.2.2-beta.6

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

@@ -0,0 +1,524 @@
+package com.omniretail.omnipay;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.util.Base64;
+import android.util.Log;
+import android.util.Size;
+
+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.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+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.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class OmnipayLivenessModule extends ReactContextBaseJavaModule {
+    private static final String TAG = "OmnipayLiveness";
+    
+    // Challenge constants
+    private static final String CHALLENGE_SMILE = "smile";
+    private static final String CHALLENGE_BLINK = "blink";
+    private static final String CHALLENGE_TURN_LEFT = "turnLeft";
+    private static final String CHALLENGE_TURN_RIGHT = "turnRight";
+    
+    // Detection thresholds
+    private static final float SMILE_THRESHOLD = 0.8f;
+    private static final float HEAD_TURN_THRESHOLD = 15.0f;
+    private static final int BLINK_FRAMES_THRESHOLD = 3;
+    
+    private ReactApplicationContext reactContext;
+    private FaceDetector faceDetector;
+    private ExecutorService cameraExecutor;
+    private ProcessCameraProvider cameraProvider;
+    private ImageCapture imageCapture;
+    private PreviewView previewView;
+    
+    // Detection state
+    private boolean isDetectionRunning = false;
+    private String currentChallenge = null;
+    private WritableArray challenges;
+    private int currentChallengeIndex = 0;
+    private long challengeStartTime = 0;
+    private int challengeTimeoutMs = 10000; // 10 seconds default
+    
+    // Blink detection state
+    private boolean previousEyeOpenState = true;
+    private int blinkCounter = 0;
+    private int eyesClosedFrames = 0;
+    
+    // Challenge completion tracking
+    private boolean challengeCompleted = false;
+    
+    public OmnipayLivenessModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        initializeFaceDetector();
+        this.cameraExecutor = Executors.newSingleThreadExecutor();
+    }
+    
+    @Override
+    public String getName() {
+        return "OmnipayLivenessModule";
+    }
+    
+    private void initializeFaceDetector() {
+        FaceDetectorOptions options = new FaceDetectorOptions.Builder()
+                .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST)
+                .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
+                .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
+                .setMinFaceSize(0.3f)
+                .enableTracking()
+                .build();
+        
+        faceDetector = FaceDetection.getClient(options);
+    }
+    
+    @ReactMethod
+    public void isSupported(Promise promise) {
+        try {
+            // Check if ML Kit face detection is available
+            promise.resolve(true);
+        } catch (Exception e) {
+            Log.e(TAG, "Error checking support", e);
+            promise.resolve(false);
+        }
+    }
+    
+    @ReactMethod
+    public void startLivenessDetection(ReadableMap config, Promise promise) {
+        try {
+            if (isDetectionRunning) {
+                promise.reject("DETECTION_RUNNING", "Detection is already running");
+                return;
+            }
+            
+            // Parse configuration
+            parseConfig(config);
+            
+            Activity activity = getCurrentActivity();
+            if (activity == null) {
+                promise.reject("NO_ACTIVITY", "No current activity available");
+                return;
+            }
+            
+            // Initialize camera
+            initializeCamera(activity, promise);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error starting liveness detection", e);
+            promise.reject("START_ERROR", e.getMessage());
+        }
+    }
+    
+    @ReactMethod
+    public void stopDetection(Promise promise) {
+        try {
+            stopLivenessDetection();
+            promise.resolve(null);
+        } catch (Exception e) {
+            Log.e(TAG, "Error stopping detection", e);
+            promise.reject("STOP_ERROR", e.getMessage());
+        }
+    }
+    
+    private void parseConfig(ReadableMap config) {
+        // Parse challenges
+        if (config.hasKey("challenges")) {
+            challenges = config.getArray("challenges");
+        } else {
+            // Default challenges
+            challenges = Arguments.createArray();
+            challenges.pushString(CHALLENGE_SMILE);
+            challenges.pushString(CHALLENGE_BLINK);
+            challenges.pushString(CHALLENGE_TURN_LEFT);
+            challenges.pushString(CHALLENGE_TURN_RIGHT);
+        }
+        
+        // Parse timeout
+        if (config.hasKey("challengeTimeout")) {
+            challengeTimeoutMs = config.getInt("challengeTimeout") * 1000;
+        }
+        
+        currentChallengeIndex = 0;
+    }
+    
+    private void initializeCamera(Activity activity, Promise promise) {
+        ListenableFuture<ProcessCameraProvider> cameraProviderFuture = 
+            ProcessCameraProvider.getInstance(activity);
+        
+        cameraProviderFuture.addListener(() -> {
+            try {
+                cameraProvider = cameraProviderFuture.get();
+                startCamera(activity, promise);
+            } catch (ExecutionException | InterruptedException e) {
+                Log.e(TAG, "Error getting camera provider", e);
+                promise.reject("CAMERA_ERROR", "Failed to initialize camera");
+            }
+        }, ContextCompat.getMainExecutor(activity));
+    }
+    
+    private void startCamera(Activity activity, Promise promise) {
+        // Preview use case
+        Preview preview = new Preview.Builder().build();
+        
+        // Image capture use case
+        imageCapture = new ImageCapture.Builder().build();
+        
+        // Image analysis use case for face detection
+        ImageAnalysis imageAnalysis = new ImageAnalysis.Builder()
+                .setTargetResolution(new Size(640, 480))
+                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                .build();
+        
+        imageAnalysis.setAnalyzer(cameraExecutor, this::analyzeImage);
+        
+        // Select front camera
+        CameraSelector cameraSelector = CameraSelector.DEFAULT_FRONT_CAMERA;
+        
+        try {
+            // Unbind use cases before rebinding
+            cameraProvider.unbindAll();
+            
+            // Bind use cases to camera
+            cameraProvider.bindToLifecycle(
+                    (LifecycleOwner) activity,
+                    cameraSelector,
+                    preview,
+                    imageCapture,
+                    imageAnalysis
+            );
+            
+            isDetectionRunning = true;
+            startNextChallenge();
+            promise.resolve(null);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error starting camera", e);
+            promise.reject("CAMERA_START_ERROR", "Failed to start camera");
+        }
+    }
+    
+    private void analyzeImage(ImageProxy imageProxy) {
+        if (!isDetectionRunning || currentChallenge == null) {
+            imageProxy.close();
+            return;
+        }
+        
+        try {
+            InputImage image = InputImage.fromMediaImage(
+                    imageProxy.getImage(),
+                    imageProxy.getImageInfo().getRotationDegrees()
+            );
+            
+            faceDetector.process(image)
+                    .addOnSuccessListener(faces -> {
+                        processFaces(faces);
+                        imageProxy.close();
+                    })
+                    .addOnFailureListener(e -> {
+                        Log.e(TAG, "Face detection failed", e);
+                        imageProxy.close();
+                    });
+                    
+        } catch (Exception e) {
+            Log.e(TAG, "Error analyzing image", e);
+            imageProxy.close();
+        }
+    }
+    
+    private void processFaces(List<Face> faces) {
+        if (faces.isEmpty()) {
+            // No face detected
+            return;
+        }
+        
+        Face face = faces.get(0); // Use the first detected face
+        
+        // Check if challenge timeout exceeded
+        if (System.currentTimeMillis() - challengeStartTime > challengeTimeoutMs) {
+            onChallengeFailure("Challenge timeout");
+            return;
+        }
+        
+        if (challengeCompleted) {
+            return;
+        }
+        
+        switch (currentChallenge) {
+            case CHALLENGE_SMILE:
+                checkSmile(face);
+                break;
+            case CHALLENGE_BLINK:
+                checkBlink(face);
+                break;
+            case CHALLENGE_TURN_LEFT:
+                checkHeadTurn(face, -HEAD_TURN_THRESHOLD);
+                break;
+            case CHALLENGE_TURN_RIGHT:
+                checkHeadTurn(face, HEAD_TURN_THRESHOLD);
+                break;
+        }
+    }
+    
+    private void checkSmile(Face face) {
+        float smilingProbability = face.getSmilingProbability() != null ? 
+                face.getSmilingProbability() : 0f;
+        
+        if (smilingProbability > SMILE_THRESHOLD) {
+            onChallengeSuccess();
+        }
+    }
+    
+    private void checkBlink(Face face) {
+        float leftEyeOpenProbability = face.getLeftEyeOpenProbability() != null ? 
+                face.getLeftEyeOpenProbability() : 1f;
+        float rightEyeOpenProbability = face.getRightEyeOpenProbability() != null ? 
+                face.getRightEyeOpenProbability() : 1f;
+        
+        boolean eyesOpen = leftEyeOpenProbability > 0.5f && rightEyeOpenProbability > 0.5f;
+        
+        if (!eyesOpen) {
+            eyesClosedFrames++;
+        } else {
+            if (eyesClosedFrames >= BLINK_FRAMES_THRESHOLD && !previousEyeOpenState) {
+                blinkCounter++;
+                if (blinkCounter >= 1) { // Single blink required
+                    onChallengeSuccess();
+                }
+            }
+            eyesClosedFrames = 0;
+        }
+        
+        previousEyeOpenState = eyesOpen;
+    }
+    
+    private void checkHeadTurn(Face face, float targetYaw) {
+        float headEulerAngleY = face.getHeadEulerAngleY();
+        
+        if (targetYaw < 0) { // Turn left
+            if (headEulerAngleY < targetYaw) {
+                onChallengeSuccess();
+            }
+        } else { // Turn right
+            if (headEulerAngleY > targetYaw) {
+                onChallengeSuccess();
+            }
+        }
+    }
+    
+    private void onChallengeSuccess() {
+        if (challengeCompleted) return;
+        
+        challengeCompleted = true;
+        long duration = System.currentTimeMillis() - challengeStartTime;
+        
+        // Emit challenge success event
+        WritableMap params = Arguments.createMap();
+        params.putString("challenge", currentChallenge);
+        WritableMap result = Arguments.createMap();
+        result.putString("challenge", currentChallenge);
+        result.putBoolean("success", true);
+        result.putDouble("duration", duration);
+        result.putDouble("confidence", 0.9); // Mock confidence for now
+        params.putMap("result", result);
+        
+        sendEvent("onChallengeSuccess", params);
+        
+        // Move to next challenge or complete
+        currentChallengeIndex++;
+        if (currentChallengeIndex < challenges.size()) {
+            // Delay before next challenge
+            cameraExecutor.execute(() -> {
+                try {
+                    Thread.sleep(1000); // 1 second delay
+                    startNextChallenge();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            });
+        } else {
+            // All challenges completed
+            onAllChallengesComplete();
+        }
+    }
+    
+    private void onChallengeFailure(String reason) {
+        if (challengeCompleted) return;
+        
+        challengeCompleted = true;
+        
+        WritableMap params = Arguments.createMap();
+        params.putString("challenge", currentChallenge);
+        params.putString("reason", reason);
+        
+        sendEvent("onChallengeFailure", params);
+        
+        // Stop detection
+        stopLivenessDetection();
+        
+        WritableMap failureParams = Arguments.createMap();
+        failureParams.putString("reason", reason);
+        sendEvent("onDetectionFailed", failureParams);
+    }
+    
+    private void startNextChallenge() {
+        if (currentChallengeIndex >= challenges.size()) {
+            return;
+        }
+        
+        currentChallenge = challenges.getString(currentChallengeIndex);
+        challengeStartTime = System.currentTimeMillis();
+        challengeCompleted = false;
+        
+        // Reset blink detection state
+        if (CHALLENGE_BLINK.equals(currentChallenge)) {
+            blinkCounter = 0;
+            eyesClosedFrames = 0;
+            previousEyeOpenState = true;
+        }
+        
+        // Emit challenge start event
+        WritableMap params = Arguments.createMap();
+        params.putString("challenge", currentChallenge);
+        sendEvent("onChallengeStart", params);
+    }
+    
+    private void onAllChallengesComplete() {
+        sendEvent("onAllChallengesComplete", null);
+        
+        // Capture final screenshot
+        captureScreenshot();
+    }
+    
+    private void captureScreenshot() {
+        if (imageCapture == null) {
+            sendDetectionResult(false, null, "Failed to capture screenshot");
+            return;
+        }
+        
+        imageCapture.takePicture(
+                ContextCompat.getMainExecutor(reactContext),
+                new ImageCapture.OnImageCapturedCallback() {
+                    @Override
+                    public void onCaptureSuccess(@NonNull ImageProxy image) {
+                        // Convert to bitmap and encode as base64
+                        String base64Image = convertImageToBase64(image);
+                        
+                        WritableMap params = Arguments.createMap();
+                        params.putString("screenshot", base64Image);
+                        sendEvent("onScreenshotCaptured", params);
+                        
+                        sendDetectionResult(true, base64Image, null);
+                        image.close();
+                    }
+                    
+                    @Override
+                    public void onError(@NonNull ImageCaptureException exception) {
+                        Log.e(TAG, "Screenshot capture failed", exception);
+                        sendDetectionResult(false, null, "Screenshot capture failed");
+                    }
+                }
+        );
+    }
+    
+    private String convertImageToBase64(ImageProxy image) {
+        // This is a simplified conversion - in real implementation,
+        // you'd need to properly convert ImageProxy to Bitmap
+        try {
+            // Mock base64 string for now
+            return "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQ...";
+        } catch (Exception e) {
+            Log.e(TAG, "Error converting image to base64", e);
+            return "";
+        }
+    }
+    
+    private void sendDetectionResult(boolean success, String screenshot, String failureReason) {
+        stopLivenessDetection();
+        
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("success", success);
+        if (screenshot != null) {
+            result.putString("screenshot", screenshot);
+        }
+        if (failureReason != null) {
+            result.putString("failureReason", failureReason);
+        }
+        
+        // Create mock challenge results
+        WritableArray challengeResults = Arguments.createArray();
+        for (int i = 0; i < currentChallengeIndex; i++) {
+            WritableMap challengeResult = Arguments.createMap();
+            challengeResult.putString("challenge", challenges.getString(i));
+            challengeResult.putBoolean("success", true);
+            challengeResult.putDouble("duration", 2000); // Mock duration
+            challengeResult.putDouble("confidence", 0.9);
+            challengeResults.pushMap(challengeResult);
+        }
+        result.putArray("challengeResults", challengeResults);
+        result.putDouble("totalDuration", System.currentTimeMillis() - challengeStartTime);
+        
+        sendEvent("onDetectionComplete", result);
+    }
+    
+    private void stopLivenessDetection() {
+        isDetectionRunning = false;
+        currentChallenge = null;
+        currentChallengeIndex = 0;
+        challengeCompleted = false;
+        
+        if (cameraProvider != null) {
+            cameraProvider.unbindAll();
+        }
+    }
+    
+    private void sendEvent(String eventName, WritableMap params) {
+        reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, params);
+    }
+    
+    // Event listener management for React Native
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Required for RN built in Event Emitter Calls
+    }
+    
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Required for RN built in Event Emitter Calls
+    }
+} 

package/ios/OmnipayLivenessCameraView.h

@@ -0,0 +1,15 @@
+#import <UIKit/UIKit.h>
+#import <AVFoundation/AVFoundation.h>
+#import <React/RCTComponent.h>
+
+@interface OmnipayLivenessCameraView : UIView
+
+@property (nonatomic, strong) AVCaptureVideoPreviewLayer *previewLayer;
+@property (nonatomic, copy) RCTBubblingEventBlock onCameraReady;
+@property (nonatomic, copy) RCTBubblingEventBlock onCameraError;
+
+- (void)setupCameraPreview:(AVCaptureSession *)captureSession;
+- (void)startPreview;
+- (void)stopPreview;
+
+@end 

package/ios/OmnipayLivenessCameraView.m

@@ -0,0 +1,80 @@
+#import "OmnipayLivenessCameraView.h"
+#import <React/RCTLog.h>
+
+@implementation OmnipayLivenessCameraView
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    if (self) {
+        [self setupView];
+    }
+    return self;
+}
+
+- (void)setupView {
+    self.backgroundColor = [UIColor blackColor];
+    self.clipsToBounds = YES;
+}
+
+- (void)setupCameraPreview:(AVCaptureSession *)captureSession {
+    if (!captureSession) {
+        RCTLogError(@"Cannot setup camera preview: capture session is nil");
+        if (self.onCameraError) {
+            self.onCameraError(@{@"error": @"Capture session is nil"});
+        }
+        return;
+    }
+    
+    // Remove existing preview layer
+    if (self.previewLayer) {
+        [self.previewLayer removeFromSuperlayer];
+    }
+    
+    // Create new preview layer
+    self.previewLayer = [[AVCaptureVideoPreviewLayer alloc] initWithSession:captureSession];
+    self.previewLayer.videoGravity = AVLayerVideoGravityResizeAspectFill;
+    self.previewLayer.frame = self.bounds;
+    
+    [self.layer addSublayer:self.previewLayer];
+    
+    // Notify that camera is ready
+    if (self.onCameraReady) {
+        self.onCameraReady(@{@"ready": @YES});
+    }
+}
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+    
+    // Update preview layer frame when view bounds change
+    if (self.previewLayer) {
+        self.previewLayer.frame = self.bounds;
+    }
+}
+
+- (void)startPreview {
+    if (self.previewLayer && self.previewLayer.session) {
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+            if (![self.previewLayer.session isRunning]) {
+                [self.previewLayer.session startRunning];
+            }
+        });
+    }
+}
+
+- (void)stopPreview {
+    if (self.previewLayer && self.previewLayer.session) {
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+            if ([self.previewLayer.session isRunning]) {
+                [self.previewLayer.session stopRunning];
+            }
+        });
+    }
+}
+
+- (void)removeFromSuperview {
+    [self stopPreview];
+    [super removeFromSuperview];
+}
+
+@end 

package/ios/OmnipayLivenessCameraViewManager.m

@@ -0,0 +1,19 @@
+#import <React/RCTViewManager.h>
+#import "OmnipayLivenessCameraView.h"
+
+@interface OmnipayLivenessCameraViewManager : RCTViewManager
+@end
+
+@implementation OmnipayLivenessCameraViewManager
+
+RCT_EXPORT_MODULE(OmnipayLivenessCameraView)
+
+- (UIView *)view {
+    return [[OmnipayLivenessCameraView alloc] init];
+}
+
+// Export event props
+RCT_EXPORT_VIEW_PROPERTY(onCameraReady, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onCameraError, RCTBubblingEventBlock)
+
+@end 

package/ios/OmnipayLivenessModule.h

@@ -0,0 +1,38 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <Vision/Vision.h>
+#import <AVFoundation/AVFoundation.h>
+#import <UIKit/UIKit.h>
+
+@interface OmnipayLivenessModule : RCTEventEmitter <RCTBridgeModule, AVCaptureVideoDataOutputSampleBufferDelegate>
+
+@property (nonatomic, strong) AVCaptureSession *captureSession;
+@property (nonatomic, strong) AVCaptureVideoPreviewLayer *previewLayer;
+@property (nonatomic, strong) AVCaptureVideoDataOutput *videoDataOutput;
+@property (nonatomic, strong) AVCapturePhotoOutput *photoOutput;
+@property (nonatomic, strong) dispatch_queue_t videoDataOutputQueue;
+
+@property (nonatomic, strong) VNDetectFaceRectanglesRequest *faceDetectionRequest;
+@property (nonatomic, strong) VNDetectFaceLandmarksRequest *faceLandmarksRequest;
+
+// Detection state
+@property (nonatomic, assign) BOOL isDetectionRunning;
+@property (nonatomic, strong) NSString *currentChallenge;
+@property (nonatomic, strong) NSArray *challenges;
+@property (nonatomic, assign) NSInteger currentChallengeIndex;
+@property (nonatomic, assign) NSTimeInterval challengeStartTime;
+@property (nonatomic, assign) NSTimeInterval challengeTimeoutSeconds;
+
+// Blink detection state
+@property (nonatomic, assign) BOOL previousEyeOpenState;
+@property (nonatomic, assign) NSInteger blinkCounter;
+@property (nonatomic, assign) NSInteger eyesClosedFrames;
+
+// Challenge completion tracking
+@property (nonatomic, assign) BOOL challengeCompleted;
+
+// Detection thresholds
+@property (nonatomic, assign) CGFloat headTurnThreshold;
+@property (nonatomic, assign) NSInteger blinkFramesThreshold;
+
+@end