omnipay-reactnative-sdk 1.2.2-beta.4 → 1.2.2-beta.7

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 

package/ios/OmnipayLivenessModule.m

@@ -0,0 +1,574 @@
+#import "OmnipayLivenessModule.h"
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+// Challenge constants
+static NSString *const CHALLENGE_SMILE = @"smile";
+static NSString *const CHALLENGE_BLINK = @"blink";
+static NSString *const CHALLENGE_TURN_LEFT = @"turnLeft";
+static NSString *const CHALLENGE_TURN_RIGHT = @"turnRight";
+
+// Detection thresholds
+static const CGFloat HEAD_TURN_THRESHOLD = 15.0;
+static const NSInteger BLINK_FRAMES_THRESHOLD = 3;
+
+@implementation OmnipayLivenessModule
+
+RCT_EXPORT_MODULE(OmnipayLivenessModule)
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        [self initializeDetection];
+    }
+    return self;
+}
+
+- (void)initializeDetection {
+    self.headTurnThreshold = HEAD_TURN_THRESHOLD;
+    self.blinkFramesThreshold = BLINK_FRAMES_THRESHOLD;
+    self.challengeTimeoutSeconds = 10.0; // Default timeout
+    
+    // Initialize video data output queue
+    self.videoDataOutputQueue = dispatch_queue_create("videoDataOutputQueue", DISPATCH_QUEUE_SERIAL);
+    
+    // Initialize Vision requests
+    self.faceDetectionRequest = [[VNDetectFaceRectanglesRequest alloc] initWithCompletionHandler:^(VNRequest *request, NSError *error) {
+        if (error) {
+            RCTLogError(@"Face detection error: %@", error.localizedDescription);
+            return;
+        }
+        [self processFaceDetectionResults:request.results];
+    }];
+    
+    self.faceLandmarksRequest = [[VNDetectFaceLandmarksRequest alloc] initWithCompletionHandler:^(VNRequest *request, NSError *error) {
+        if (error) {
+            RCTLogError(@"Face landmarks error: %@", error.localizedDescription);
+            return;
+        }
+        [self processFaceLandmarksResults:request.results];
+    }];
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+        @"onChallengeStart",
+        @"onChallengeSuccess", 
+        @"onChallengeFailure",
+        @"onAllChallengesComplete",
+        @"onScreenshotCaptured",
+        @"onDetectionFailed",
+        @"onDetectionComplete"
+    ];
+}
+
+RCT_EXPORT_METHOD(isSupported:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    // Check if Vision framework is available and device has camera capability
+    BOOL hasVisionFramework = [VNDetectFaceRectanglesRequest class] != nil;
+    
+    // Check if device has camera (independent of permission status)
+    BOOL hasCamera = NO;
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
+    hasCamera = devices.count > 0;
+    
+    // Additional check for front camera specifically (for selfie mode)
+    if (!hasCamera) {
+        AVCaptureDevice *frontCamera = [AVCaptureDevice defaultDeviceWithDeviceType:AVCaptureDeviceTypeBuiltInWideAngleCamera 
+                                                                           mediaType:AVMediaTypeVideo 
+                                                                            position:AVCaptureDevicePositionFront];
+        hasCamera = frontCamera != nil;
+    }
+    
+    BOOL isSupported = hasVisionFramework && hasCamera;
+    
+    RCTLogInfo(@"Liveness Detection Support Check:");
+    RCTLogInfo(@"  Vision Framework: %@", hasVisionFramework ? @"YES" : @"NO");
+    RCTLogInfo(@"  Camera Available: %@", hasCamera ? @"YES" : @"NO");
+    RCTLogInfo(@"  Overall Support: %@", isSupported ? @"YES" : @"NO");
+    
+    resolve(@(isSupported));
+}
+
+RCT_EXPORT_METHOD(startLivenessDetection:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    
+    if (self.isDetectionRunning) {
+        reject(@"DETECTION_RUNNING", @"Detection is already running", nil);
+        return;
+    }
+    
+    // Parse configuration
+    [self parseConfig:config];
+    
+    // Request camera permission
+    [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (!granted) {
+                reject(@"CAMERA_PERMISSION", @"Camera permission denied", nil);
+                return;
+            }
+            
+            NSError *error;
+            if ([self setupCameraSession:&error]) {
+                [self startCameraSession];
+                self.isDetectionRunning = YES;
+                [self startNextChallenge];
+                resolve(nil);
+            } else {
+                reject(@"CAMERA_SETUP_ERROR", error.localizedDescription ?: @"Failed to setup camera", error);
+            }
+        });
+    }];
+}
+
+RCT_EXPORT_METHOD(stopDetection:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    [self stopLivenessDetection];
+    resolve(nil);
+}
+
+- (void)parseConfig:(NSDictionary *)config {
+    // Parse challenges
+    NSArray *challengesArray = config[@"challenges"];
+    if (challengesArray && challengesArray.count > 0) {
+        self.challenges = challengesArray;
+    } else {
+        // Default challenges
+        self.challenges = @[CHALLENGE_SMILE, CHALLENGE_BLINK, CHALLENGE_TURN_LEFT, CHALLENGE_TURN_RIGHT];
+    }
+    
+    // Parse timeout
+    NSNumber *timeout = config[@"challengeTimeout"];
+    if (timeout) {
+        self.challengeTimeoutSeconds = timeout.doubleValue;
+    }
+    
+    self.currentChallengeIndex = 0;
+}
+
+- (BOOL)setupCameraSession:(NSError **)error {
+    // Create capture session
+    self.captureSession = [[AVCaptureSession alloc] init];
+    self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;
+    
+    // Get front camera
+    AVCaptureDevice *frontCamera = nil;
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
+    for (AVCaptureDevice *device in devices) {
+        if (device.position == AVCaptureDevicePositionFront) {
+            frontCamera = device;
+            break;
+        }
+    }
+    
+    if (!frontCamera) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"OmnipayLiveness" 
+                                         code:1001 
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Front camera not available"}];
+        }
+        return NO;
+    }
+    
+    // Create device input
+    NSError *inputError;
+    AVCaptureDeviceInput *deviceInput = [AVCaptureDeviceInput deviceInputWithDevice:frontCamera error:&inputError];
+    if (!deviceInput) {
+        if (error) *error = inputError;
+        return NO;
+    }
+    
+    if (![self.captureSession canAddInput:deviceInput]) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"OmnipayLiveness" 
+                                         code:1002 
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Cannot add device input"}];
+        }
+        return NO;
+    }
+    [self.captureSession addInput:deviceInput];
+    
+    // Create video data output
+    self.videoDataOutput = [[AVCaptureVideoDataOutput alloc] init];
+    self.videoDataOutput.videoSettings = @{(NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)};
+    [self.videoDataOutput setSampleBufferDelegate:self queue:self.videoDataOutputQueue];
+    
+    if (![self.captureSession canAddOutput:self.videoDataOutput]) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"OmnipayLiveness" 
+                                         code:1003 
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Cannot add video data output"}];
+        }
+        return NO;
+    }
+    [self.captureSession addOutput:self.videoDataOutput];
+    
+    // Create photo output for final screenshot
+    self.photoOutput = [[AVCapturePhotoOutput alloc] init];
+    if ([self.captureSession canAddOutput:self.photoOutput]) {
+        [self.captureSession addOutput:self.photoOutput];
+    }
+    
+    return YES;
+}
+
+- (void)startCameraSession {
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        [self.captureSession startRunning];
+    });
+}
+
+- (void)startNextChallenge {
+    if (self.currentChallengeIndex >= self.challenges.count) {
+        return;
+    }
+    
+    self.currentChallenge = self.challenges[self.currentChallengeIndex];
+    self.challengeStartTime = [[NSDate date] timeIntervalSince1970];
+    self.challengeCompleted = NO;
+    
+    // Reset blink detection state
+    if ([self.currentChallenge isEqualToString:CHALLENGE_BLINK]) {
+        self.blinkCounter = 0;
+        self.eyesClosedFrames = 0;
+        self.previousEyeOpenState = YES;
+    }
+    
+    // Emit challenge start event
+    [self sendEventWithName:@"onChallengeStart" body:@{@"challenge": self.currentChallenge}];
+}
+
+#pragma mark - AVCaptureVideoDataOutputSampleBufferDelegate
+
+- (void)captureOutput:(AVCaptureOutput *)output 
+didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer 
+       fromConnection:(AVCaptureConnection *)connection {
+    
+    if (!self.isDetectionRunning || !self.currentChallenge) {
+        return;
+    }
+    
+    // Check timeout
+    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
+    if (currentTime - self.challengeStartTime > self.challengeTimeoutSeconds) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [self onChallengeFailure:@"Challenge timeout"];
+        });
+        return;
+    }
+    
+    if (self.challengeCompleted) {
+        return;
+    }
+    
+    // Convert sample buffer to CIImage
+    CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+    if (!imageBuffer) return;
+    
+    CIImage *ciImage = [CIImage imageWithCVImageBuffer:imageBuffer];
+    
+    // Create Vision image request handler
+    VNImageRequestHandler *imageRequestHandler = [[VNImageRequestHandler alloc] initWithCIImage:ciImage options:@{}];
+    
+    NSError *error;
+    if ([self.currentChallenge isEqualToString:CHALLENGE_SMILE] || 
+        [self.currentChallenge isEqualToString:CHALLENGE_TURN_LEFT] || 
+        [self.currentChallenge isEqualToString:CHALLENGE_TURN_RIGHT]) {
+        
+        // Use face landmarks for smile and head pose detection
+        [imageRequestHandler performRequests:@[self.faceLandmarksRequest] error:&error];
+    } else {
+        // Use basic face detection for blink detection
+        [imageRequestHandler performRequests:@[self.faceDetectionRequest, self.faceLandmarksRequest] error:&error];
+    }
+    
+    if (error) {
+        RCTLogError(@"Vision request error: %@", error.localizedDescription);
+    }
+}
+
+- (void)processFaceDetectionResults:(NSArray<VNFaceObservation *> *)results {
+    if (results.count == 0) {
+        return; // No face detected
+    }
+    
+    VNFaceObservation *face = results.firstObject;
+    [self processFaceObservation:face];
+}
+
+- (void)processFaceLandmarksResults:(NSArray<VNFaceObservation *> *)results {
+    if (results.count == 0) {
+        return; // No face detected
+    }
+    
+    VNFaceObservation *face = results.firstObject;
+    [self processFaceObservation:face];
+}
+
+- (void)processFaceObservation:(VNFaceObservation *)face {
+    if ([self.currentChallenge isEqualToString:CHALLENGE_SMILE]) {
+        [self checkSmile:face];
+    } else if ([self.currentChallenge isEqualToString:CHALLENGE_BLINK]) {
+        [self checkBlink:face];
+    } else if ([self.currentChallenge isEqualToString:CHALLENGE_TURN_LEFT]) {
+        [self checkHeadTurn:face targetYaw:-self.headTurnThreshold];
+    } else if ([self.currentChallenge isEqualToString:CHALLENGE_TURN_RIGHT]) {
+        [self checkHeadTurn:face targetYaw:self.headTurnThreshold];
+    }
+}
+
+- (void)checkSmile:(VNFaceObservation *)face {
+    if (!face.landmarks) return;
+    
+    // Simplified smile detection based on mouth landmarks
+    VNFaceLandmarkRegion2D *outerLips = face.landmarks.outerLips;
+    if (outerLips && outerLips.pointCount > 0) {
+        // Basic smile detection - check if mouth corners are raised
+        // This is a simplified implementation
+        CGPoint *points = (CGPoint *)outerLips.normalizedPoints;
+        
+        // Get mouth corner points (approximate indices)
+        if (outerLips.pointCount >= 12) {
+            CGPoint leftCorner = points[0];
+            CGPoint rightCorner = points[6];
+            CGPoint topLip = points[3];
+            CGPoint bottomLip = points[9];
+            
+            // Simple smile detection: corners higher than center
+            CGFloat mouthHeight = topLip.y - bottomLip.y;
+            CGFloat cornerElevation = (leftCorner.y + rightCorner.y) / 2.0 - bottomLip.y;
+            
+            if (cornerElevation > mouthHeight * 0.3) { // Smile threshold
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    [self onChallengeSuccess];
+                });
+            }
+        }
+    }
+}
+
+- (void)checkBlink:(VNFaceObservation *)face {
+    if (!face.landmarks) return;
+    
+    // Check eye landmarks for blink detection
+    VNFaceLandmarkRegion2D *leftEye = face.landmarks.leftEye;
+    VNFaceLandmarkRegion2D *rightEye = face.landmarks.rightEye;
+    
+    if (leftEye && rightEye && leftEye.pointCount > 0 && rightEye.pointCount > 0) {
+        // Simplified blink detection based on eye aspect ratio
+        BOOL eyesOpen = [self areEyesOpen:leftEye rightEye:rightEye];
+        
+        if (!eyesOpen) {
+            self.eyesClosedFrames++;
+        } else {
+            if (self.eyesClosedFrames >= self.blinkFramesThreshold && !self.previousEyeOpenState) {
+                self.blinkCounter++;
+                if (self.blinkCounter >= 1) { // Single blink required
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                        [self onChallengeSuccess];
+                    });
+                }
+            }
+            self.eyesClosedFrames = 0;
+        }
+        
+        self.previousEyeOpenState = eyesOpen;
+    }
+}
+
+- (BOOL)areEyesOpen:(VNFaceLandmarkRegion2D *)leftEye rightEye:(VNFaceLandmarkRegion2D *)rightEye {
+    // Calculate eye aspect ratio for both eyes
+    CGFloat leftEAR = [self calculateEyeAspectRatio:leftEye];
+    CGFloat rightEAR = [self calculateEyeAspectRatio:rightEye];
+    
+    // Average eye aspect ratio
+    CGFloat averageEAR = (leftEAR + rightEAR) / 2.0;
+    
+    // Threshold for eye open/closed state
+    return averageEAR > 0.2; // Adjust threshold as needed
+}
+
+- (CGFloat)calculateEyeAspectRatio:(VNFaceLandmarkRegion2D *)eye {
+    if (eye.pointCount < 6) return 1.0; // Default to open
+    
+    CGPoint *points = (CGPoint *)eye.normalizedPoints;
+    
+    // Simplified eye aspect ratio calculation
+    // Get approximate top, bottom, left, right points
+    CGFloat minY = points[0].y, maxY = points[0].y;
+    CGFloat minX = points[0].x, maxX = points[0].x;
+    
+    for (int i = 1; i < eye.pointCount; i++) {
+        if (points[i].y < minY) minY = points[i].y;
+        if (points[i].y > maxY) maxY = points[i].y;
+        if (points[i].x < minX) minX = points[i].x;
+        if (points[i].x > maxX) maxX = points[i].x;
+    }
+    
+    CGFloat height = maxY - minY;
+    CGFloat width = maxX - minX;
+    
+    return width > 0 ? height / width : 1.0;
+}
+
+- (void)checkHeadTurn:(VNFaceObservation *)face targetYaw:(CGFloat)targetYaw {
+    // Vision framework provides yaw directly
+    CGFloat yaw = face.yaw ? face.yaw.floatValue * 180.0 / M_PI : 0.0; // Convert to degrees
+    
+    if (targetYaw < 0) { // Turn left
+        if (yaw < targetYaw) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self onChallengeSuccess];
+            });
+        }
+    } else { // Turn right
+        if (yaw > targetYaw) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self onChallengeSuccess];
+            });
+        }
+    }
+}
+
+- (void)onChallengeSuccess {
+    if (self.challengeCompleted) return;
+    
+    self.challengeCompleted = YES;
+    NSTimeInterval duration = ([[NSDate date] timeIntervalSince1970] - self.challengeStartTime) * 1000; // Convert to ms
+    
+    // Create challenge result
+    NSDictionary *result = @{
+        @"challenge": self.currentChallenge,
+        @"success": @YES,
+        @"duration": @(duration),
+        @"confidence": @(0.9) // Mock confidence
+    };
+    
+    // Emit challenge success event
+    [self sendEventWithName:@"onChallengeSuccess" body:@{
+        @"challenge": self.currentChallenge,
+        @"result": result
+    }];
+    
+    // Move to next challenge or complete
+    self.currentChallengeIndex++;
+    if (self.currentChallengeIndex < self.challenges.count) {
+        // Delay before next challenge
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+            [self startNextChallenge];
+        });
+    } else {
+        // All challenges completed
+        [self onAllChallengesComplete];
+    }
+}
+
+- (void)onChallengeFailure:(NSString *)reason {
+    if (self.challengeCompleted) return;
+    
+    self.challengeCompleted = YES;
+    
+    [self sendEventWithName:@"onChallengeFailure" body:@{
+        @"challenge": self.currentChallenge,
+        @"reason": reason
+    }];
+    
+    // Stop detection
+    [self stopLivenessDetection];
+    
+    [self sendEventWithName:@"onDetectionFailed" body:@{@"reason": reason}];
+}
+
+- (void)onAllChallengesComplete {
+    [self sendEventWithName:@"onAllChallengesComplete" body:nil];
+    
+    // Capture final screenshot
+    [self captureScreenshot];
+}
+
+- (void)captureScreenshot {
+    if (!self.photoOutput) {
+        [self sendDetectionResult:NO screenshot:nil failureReason:@"Failed to capture screenshot"];
+        return;
+    }
+    
+    AVCapturePhotoSettings *settings = [AVCapturePhotoSettings photoSettings];
+    
+    [self.photoOutput capturePhotoWithSettings:settings delegate:(id<AVCapturePhotoCaptureDelegate>)self];
+}
+
+#pragma mark - AVCapturePhotoCaptureDelegate
+
+- (void)captureOutput:(AVCapturePhotoOutput *)output 
+didFinishProcessingPhoto:(AVCapturePhoto *)photo 
+                error:(NSError *)error API_AVAILABLE(ios(11.0)) {
+    
+    if (error) {
+        RCTLogError(@"Photo capture error: %@", error.localizedDescription);
+        [self sendDetectionResult:NO screenshot:nil failureReason:@"Screenshot capture failed"];
+        return;
+    }
+    
+    NSData *imageData = [photo fileDataRepresentation];
+    if (imageData) {
+        NSString *base64String = [imageData base64EncodedStringWithOptions:0];
+        NSString *base64Image = [NSString stringWithFormat:@"data:image/jpeg;base64,%@", base64String];
+        
+        [self sendEventWithName:@"onScreenshotCaptured" body:@{@"screenshot": base64Image}];
+        [self sendDetectionResult:YES screenshot:base64Image failureReason:nil];
+    } else {
+        [self sendDetectionResult:NO screenshot:nil failureReason:@"Failed to process screenshot"];
+    }
+}
+
+- (void)sendDetectionResult:(BOOL)success screenshot:(NSString *)screenshot failureReason:(NSString *)failureReason {
+    [self stopLivenessDetection];
+    
+    NSMutableDictionary *result = [NSMutableDictionary dictionary];
+    result[@"success"] = @(success);
+    
+    if (screenshot) {
+        result[@"screenshot"] = screenshot;
+    }
+    
+    if (failureReason) {
+        result[@"failureReason"] = failureReason;
+    }
+    
+    // Create mock challenge results
+    NSMutableArray *challengeResults = [NSMutableArray array];
+    for (NSInteger i = 0; i < self.currentChallengeIndex; i++) {
+        NSDictionary *challengeResult = @{
+            @"challenge": self.challenges[i],
+            @"success": @YES,
+            @"duration": @(2000), // Mock duration
+            @"confidence": @(0.9)
+        };
+        [challengeResults addObject:challengeResult];
+    }
+    result[@"challengeResults"] = challengeResults;
+    result[@"totalDuration"] = @(([[NSDate date] timeIntervalSince1970] - self.challengeStartTime) * 1000);
+    
+    [self sendEventWithName:@"onDetectionComplete" body:result];
+}
+
+- (void)stopLivenessDetection {
+    self.isDetectionRunning = NO;
+    self.currentChallenge = nil;
+    self.currentChallengeIndex = 0;
+    self.challengeCompleted = NO;
+    
+    if (self.captureSession && self.captureSession.isRunning) {
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+            [self.captureSession stopRunning];
+        });
+    }
+}
+
+@end