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

package/src/components/biometrics/LivenessDetection.ts

@@ -1,305 +1,168 @@
 import { NativeModules, NativeEventEmitter } from 'react-native';
+import type {
+  LivenessConfig,
+  LivenessResult,
+  LivenessChallenge,
+  ChallengeResult,
+  LivenessEventCallbacks,
+} from './types';
 
-const { LivenessDetection: LivenessDetectionNative } = NativeModules;
+const { OmnipayLivenessModule } = NativeModules;
 
-// TypeScript interfaces matching PRD specifications
-export interface LivenessDetectionConfig {
-  challenges: ('smile' | 'blink' | 'turn_left' | 'turn_right')[];
-  timeout?: number; // Optional timeout in milliseconds
-}
-
-export interface ChallengeResult {
-  challenge: string;
-  success: boolean;
-  timestamp: number;
-  duration?: number; // Time taken to complete challenge
-}
-
-export interface LivenessResult {
-  success: boolean;
-  screenshot?: string; // Base64 encoded image
-  challengeResults: ChallengeResult[];
-  error?: string;
-}
-
-// Event callback types
-export interface LivenessCallbacks {
-  onChallengeStart?: (challenge: string) => void;
-  onChallengeSuccess?: (challenge: string) => void;
-  onChallengeFailure?: (challenge: string, reason: string) => void;
-  onAllChallengesComplete?: (result: LivenessResult) => void;
-  onScreenshotCaptured?: (screenshot: string) => void;
-}
-
-// Main LivenessDetection class
 class LivenessDetectionManager {
-  private eventEmitter: NativeEventEmitter | null = null;
-  private listeners: any[] = [];
-  private callbacks: LivenessCallbacks = {};
-  private isActive = false;
-  private challengeResults: ChallengeResult[] = [];
-  private startTime: number = 0;
+  private eventEmitter?: NativeEventEmitter;
+  private eventListeners: { [key: string]: any } = {};
 
   constructor() {
-    if (LivenessDetectionNative) {
-      this.eventEmitter = new NativeEventEmitter(LivenessDetectionNative);
-      this.setupEventListeners();
+    if (OmnipayLivenessModule) {
+      this.eventEmitter = new NativeEventEmitter(OmnipayLivenessModule);
     }
   }
 
-  private setupEventListeners() {
-    if (!this.eventEmitter) return;
-
-    // Challenge start event
-    this.listeners.push(
-      this.eventEmitter.addListener('onChallengeStart', (event) => {
-        console.log('Liveness: Challenge started -', event.challenge);
-        if (this.callbacks.onChallengeStart) {
-          this.callbacks.onChallengeStart(event.challenge);
-        }
-      })
-    );
-
-    // Challenge success event
-    this.listeners.push(
-      this.eventEmitter.addListener('onChallengeSuccess', (event) => {
-        console.log('Liveness: Challenge completed -', event.challenge);
-
-        // Record challenge result
-        const result: ChallengeResult = {
-          challenge: event.challenge,
-          success: true,
-          timestamp: Date.now(),
-          duration: Date.now() - this.startTime,
-        };
-        this.challengeResults.push(result);
-
-        if (this.callbacks.onChallengeSuccess) {
-          this.callbacks.onChallengeSuccess(event.challenge);
-        }
-      })
-    );
-
-    // Challenge failure event
-    this.listeners.push(
-      this.eventEmitter.addListener('onChallengeFailure', (event) => {
-        console.log(
-          'Liveness: Challenge failed -',
-          event.challenge,
-          event.reason
-        );
-
-        // Record failed challenge result
-        const result: ChallengeResult = {
-          challenge: event.challenge,
-          success: false,
-          timestamp: Date.now(),
-          duration: Date.now() - this.startTime,
-        };
-        this.challengeResults.push(result);
-
-        if (this.callbacks.onChallengeFailure) {
-          this.callbacks.onChallengeFailure(event.challenge, event.reason);
-        }
-      })
-    );
-
-    // All challenges complete event
-    this.listeners.push(
-      this.eventEmitter.addListener('onAllChallengesComplete', (event) => {
-        console.log('Liveness: All challenges completed', event);
-
-        const result: LivenessResult = {
-          success: event.success,
-          screenshot: event.screenshot,
-          challengeResults: this.challengeResults,
-        };
-
-        this.isActive = false;
-
-        if (this.callbacks.onAllChallengesComplete) {
-          this.callbacks.onAllChallengesComplete(result);
-        }
-      })
-    );
-
-    // Screenshot captured event
-    this.listeners.push(
-      this.eventEmitter.addListener('onScreenshotCaptured', (event) => {
-        console.log('Liveness: Screenshot captured');
-
-        if (this.callbacks.onScreenshotCaptured) {
-          this.callbacks.onScreenshotCaptured(event.screenshot);
-        }
-      })
-    );
-  }
-
   /**
-   * Start liveness detection with specified challenges
-   * @param config - Configuration including challenges array
-   * @param callbacks - Event callbacks
-   * @returns Promise resolving to LivenessResult
+   * Check if liveness detection is supported on this device
    */
-  async startLivenessDetection(
-    config: LivenessDetectionConfig,
-    callbacks?: LivenessCallbacks
-  ): Promise<LivenessResult> {
-    if (this.isActive) {
-      throw new Error('Liveness detection is already active');
+  async isSupported(): Promise<boolean> {
+    if (!OmnipayLivenessModule) {
+      return false;
     }
 
-    if (!LivenessDetectionNative) {
-      throw new Error('Liveness detection is not available on this platform');
+    try {
+      return await OmnipayLivenessModule.isSupported();
+    } catch (error) {
+      console.warn('Liveness detection support check failed:', error);
+      return false;
     }
+  }
 
-    // Validate challenges
-    if (!config.challenges || config.challenges.length === 0) {
-      throw new Error('At least one challenge must be specified');
+  /**
+   * Start liveness detection with given configuration
+   */
+  async startDetection(
+    config: LivenessConfig,
+    callbacks?: LivenessEventCallbacks
+  ): Promise<LivenessResult> {
+    if (!OmnipayLivenessModule) {
+      throw new Error('Liveness detection module not available');
     }
 
-    const validChallenges = ['smile', 'blink', 'turn_left', 'turn_right'];
-    for (const challenge of config.challenges) {
-      if (!validChallenges.includes(challenge)) {
-        throw new Error(`Invalid challenge: ${challenge}`);
-      }
+    // Set up event listeners if callbacks provided
+    if (callbacks) {
+      this.setupEventListeners(callbacks);
     }
 
     try {
-      // Check camera permission first
-      const hasPermission = await this.checkCameraPermission();
-      if (!hasPermission) {
-        throw new Error(
-          'Camera permission is required. Please call requestCameraPermission() first.'
-        );
-      }
-
-      // Set callbacks
-      this.callbacks = callbacks || {};
-      this.challengeResults = [];
-      this.startTime = Date.now();
-      this.isActive = true;
-
-      // Start detection on native side
-      const result = await LivenessDetectionNative.startLivenessDetection(
-        config.challenges
-      );
-      console.log('Liveness detection started:', result);
-
-      // Return a promise that resolves when all challenges are complete
-      return new Promise((resolve, reject) => {
-        const originalOnComplete = this.callbacks.onAllChallengesComplete;
-
-        this.callbacks.onAllChallengesComplete = (
-          livenessResult: LivenessResult
-        ) => {
-          // Call original callback if provided
-          if (originalOnComplete) {
-            originalOnComplete(livenessResult);
-          }
-
-          // Resolve the promise
-          resolve(livenessResult);
-        };
-
-        // Set up timeout if specified
-        if (config.timeout) {
-          setTimeout(() => {
-            if (this.isActive) {
-              this.stopDetection();
-              reject(new Error('Liveness detection timed out'));
-            }
-          }, config.timeout);
-        }
-      });
+      const result = await OmnipayLivenessModule.startLivenessDetection(config);
+      return result;
     } catch (error) {
-      this.isActive = false;
+      this.cleanupEventListeners();
       throw error;
     }
   }
 
   /**
-   * Stop liveness detection
+   * Stop the current detection
    */
-  stopDetection(): void {
-    if (LivenessDetectionNative && this.isActive) {
-      LivenessDetectionNative.stopLivenessDetection();
-      this.isActive = false;
-      this.callbacks = {};
-      this.challengeResults = [];
-      console.log('Liveness detection stopped');
+  async stopDetection(): Promise<void> {
+    if (!OmnipayLivenessModule) {
+      return;
     }
-  }
 
-  /**
-   * Check if liveness detection is currently active
-   */
-  isDetectionActive(): boolean {
-    return this.isActive;
+    try {
+      await OmnipayLivenessModule.stopDetection();
+    } finally {
+      this.cleanupEventListeners();
+    }
   }
 
   /**
-   * Get available challenge types
+   * Set up event listeners for detection callbacks
    */
-  getAvailableChallenges(): string[] {
-    return ['smile', 'blink', 'turn_left', 'turn_right'];
-  }
+  private setupEventListeners(callbacks: LivenessEventCallbacks) {
+    this.cleanupEventListeners(); // Clean up any existing listeners
 
-  /**
-   * Check if camera permission is granted
-   */
-  async checkCameraPermission(): Promise<boolean> {
-    if (!LivenessDetectionNative) {
-      throw new Error('Liveness detection is not available on this platform');
+    if (!this.eventEmitter) {
+      console.warn('Event emitter not available for liveness detection');
+      return;
     }
 
-    try {
-      return await LivenessDetectionNative.checkCameraPermission();
-    } catch (error) {
-      console.error('Failed to check camera permission:', error);
-      return false;
+    if (callbacks.onChallengeStart) {
+      this.eventListeners.challengeStart = this.eventEmitter.addListener(
+        'onChallengeStart',
+        (challenge: LivenessChallenge) => callbacks.onChallengeStart!(challenge)
+      );
     }
-  }
 
-  /**
-   * Request camera permission from the user
-   */
-  async requestCameraPermission(): Promise<boolean> {
-    if (!LivenessDetectionNative) {
-      throw new Error('Liveness detection is not available on this platform');
+    if (callbacks.onChallengeSuccess) {
+      this.eventListeners.challengeSuccess = this.eventEmitter.addListener(
+        'onChallengeSuccess',
+        (data: { challenge: LivenessChallenge; result: ChallengeResult }) =>
+          callbacks.onChallengeSuccess!(data.challenge, data.result)
+      );
     }
 
-    try {
-      return await LivenessDetectionNative.requestCameraPermission();
-    } catch (error) {
-      console.error('Failed to request camera permission:', error);
-      return false;
+    if (callbacks.onChallengeFailure) {
+      this.eventListeners.challengeFailure = this.eventEmitter.addListener(
+        'onChallengeFailure',
+        (data: { challenge: LivenessChallenge; reason: string }) =>
+          callbacks.onChallengeFailure!(data.challenge, data.reason)
+      );
+    }
+
+    if (callbacks.onAllChallengesComplete) {
+      this.eventListeners.allComplete = this.eventEmitter.addListener(
+        'onAllChallengesComplete',
+        () => callbacks.onAllChallengesComplete!()
+      );
+    }
+
+    if (callbacks.onScreenshotCaptured) {
+      this.eventListeners.screenshot = this.eventEmitter.addListener(
+        'onScreenshotCaptured',
+        (screenshot: string) => callbacks.onScreenshotCaptured!(screenshot)
+      );
+    }
+
+    if (callbacks.onDetectionFailed) {
+      this.eventListeners.failed = this.eventEmitter.addListener(
+        'onDetectionFailed',
+        (reason: string) => callbacks.onDetectionFailed!(reason)
+      );
     }
   }
 
   /**
-   * Cleanup - remove all event listeners
+   * Clean up all event listeners
    */
-  cleanup(): void {
-    this.listeners.forEach((listener) => {
+  private cleanupEventListeners() {
+    Object.values(this.eventListeners).forEach((listener) => {
       if (listener && listener.remove) {
         listener.remove();
       }
     });
-    this.listeners = [];
-    this.stopDetection();
+    this.eventListeners = {};
+  }
+
+  /**
+   * Get default configuration
+   */
+  getDefaultConfig(): LivenessConfig {
+    return {
+      challenges: [
+        'smile',
+        'blink',
+        'turnLeft',
+        'turnRight',
+      ] as LivenessChallenge[],
+      challengeTimeout: 10,
+      totalTimeout: 60,
+      debugMode: __DEV__,
+    };
   }
 }
 
 // Export singleton instance
 export const LivenessDetection = new LivenessDetectionManager();
 
-// Types are already exported above
-
-// Constants from native module
-export const LivenessConstants = {
-  CHALLENGE_SMILE: 'smile',
-  CHALLENGE_BLINK: 'blink',
-  CHALLENGE_TURN_LEFT: 'turn_left',
-  CHALLENGE_TURN_RIGHT: 'turn_right',
-} as const;
+// Export types for convenience
+export * from './types';

package/src/components/biometrics/OmnipayLivenessCameraView.tsx

@@ -0,0 +1,19 @@
+import React from 'react';
+import { requireNativeComponent, ViewStyle } from 'react-native';
+
+interface OmnipayLivenessCameraViewProps {
+  style?: ViewStyle;
+  onCameraReady?: (event: { nativeEvent: { ready: boolean } }) => void;
+  onCameraError?: (event: { nativeEvent: { error: string } }) => void;
+}
+
+const NativeOmnipayLivenessCameraView =
+  requireNativeComponent<OmnipayLivenessCameraViewProps>(
+    'OmnipayLivenessCameraView'
+  );
+
+export const OmnipayLivenessCameraView: React.FC<
+  OmnipayLivenessCameraViewProps
+> = (props) => {
+  return <NativeOmnipayLivenessCameraView {...props} />;
+};