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

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

@@ -1,557 +0,0 @@
-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
-            boolean hasMLKit = true;
-            try {
-                // Try to create ML Kit face detector to verify it's available
-                FaceDetectorOptions options = new FaceDetectorOptions.Builder()
-                    .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST)
-                    .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
-                    .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
-                    .build();
-                FaceDetection.getClient(options);
-            } catch (Exception e) {
-                Log.e(TAG, "ML Kit not available", e);
-                hasMLKit = false;
-            }
-            
-            // Check if device has camera capability (independent of permission)
-            boolean hasCamera = false;
-            try {
-                android.content.Context context = getReactApplicationContext();
-                android.content.pm.PackageManager pm = context.getPackageManager();
-                hasCamera = pm.hasSystemFeature(android.content.pm.PackageManager.FEATURE_CAMERA_ANY) ||
-                           pm.hasSystemFeature(android.content.pm.PackageManager.FEATURE_CAMERA_FRONT);
-            } catch (Exception e) {
-                Log.e(TAG, "Error checking camera features", e);
-                hasCamera = false;
-            }
-            
-            boolean isSupported = hasMLKit && hasCamera;
-            
-            Log.i(TAG, "Liveness Detection Support Check:");
-            Log.i(TAG, "  ML Kit Available: " + hasMLKit);
-            Log.i(TAG, "  Camera Available: " + hasCamera);
-            Log.i(TAG, "  Overall Support: " + isSupported);
-            
-            promise.resolve(isSupported);
-        } 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

@@ -1,15 +0,0 @@
-#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

@@ -1,80 +0,0 @@
-#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

@@ -1,19 +0,0 @@
-#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