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

package/src/components/biometrics/LivenessDetection.ts

@@ -0,0 +1,305 @@
+import { NativeModules, NativeEventEmitter } from 'react-native';
+
+const { LivenessDetection: LivenessDetectionNative } = 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;
+
+  constructor() {
+    if (LivenessDetectionNative) {
+      this.eventEmitter = new NativeEventEmitter(LivenessDetectionNative);
+      this.setupEventListeners();
+    }
+  }
+
+  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
+   */
+  async startLivenessDetection(
+    config: LivenessDetectionConfig,
+    callbacks?: LivenessCallbacks
+  ): Promise<LivenessResult> {
+    if (this.isActive) {
+      throw new Error('Liveness detection is already active');
+    }
+
+    if (!LivenessDetectionNative) {
+      throw new Error('Liveness detection is not available on this platform');
+    }
+
+    // Validate challenges
+    if (!config.challenges || config.challenges.length === 0) {
+      throw new Error('At least one challenge must be specified');
+    }
+
+    const validChallenges = ['smile', 'blink', 'turn_left', 'turn_right'];
+    for (const challenge of config.challenges) {
+      if (!validChallenges.includes(challenge)) {
+        throw new Error(`Invalid challenge: ${challenge}`);
+      }
+    }
+
+    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);
+        }
+      });
+    } catch (error) {
+      this.isActive = false;
+      throw error;
+    }
+  }
+
+  /**
+   * Stop liveness detection
+   */
+  stopDetection(): void {
+    if (LivenessDetectionNative && this.isActive) {
+      LivenessDetectionNative.stopLivenessDetection();
+      this.isActive = false;
+      this.callbacks = {};
+      this.challengeResults = [];
+      console.log('Liveness detection stopped');
+    }
+  }
+
+  /**
+   * Check if liveness detection is currently active
+   */
+  isDetectionActive(): boolean {
+    return this.isActive;
+  }
+
+  /**
+   * Get available challenge types
+   */
+  getAvailableChallenges(): string[] {
+    return ['smile', 'blink', 'turn_left', 'turn_right'];
+  }
+
+  /**
+   * Check if camera permission is granted
+   */
+  async checkCameraPermission(): Promise<boolean> {
+    if (!LivenessDetectionNative) {
+      throw new Error('Liveness detection is not available on this platform');
+    }
+
+    try {
+      return await LivenessDetectionNative.checkCameraPermission();
+    } catch (error) {
+      console.error('Failed to check camera permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Request camera permission from the user
+   */
+  async requestCameraPermission(): Promise<boolean> {
+    if (!LivenessDetectionNative) {
+      throw new Error('Liveness detection is not available on this platform');
+    }
+
+    try {
+      return await LivenessDetectionNative.requestCameraPermission();
+    } catch (error) {
+      console.error('Failed to request camera permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Cleanup - remove all event listeners
+   */
+  cleanup(): void {
+    this.listeners.forEach((listener) => {
+      if (listener && listener.remove) {
+        listener.remove();
+      }
+    });
+    this.listeners = [];
+    this.stopDetection();
+  }
+}
+
+// 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;

package/src/index.tsx

@@ -2,4 +2,22 @@ import Omnipay from './components/OmnipayView';
 
 export { OmnipayProvider } from './components/OmnipayProvider';
 export { useOmnipay } from './hooks/useOmnipay';
+
+// Liveness Detection exports
+export {
+  LivenessDetection,
+  LivenessConstants,
+  type LivenessDetectionConfig,
+  type ChallengeResult,
+  type LivenessResult,
+  type LivenessCallbacks,
+} from './components/biometrics/LivenessDetection';
+
+export {
+  default as LivenessCameraView,
+  type LivenessCameraViewProps,
+} from './components/biometrics/LivenessCameraView';
+
+export { default as FaceVerification } from './components/biometrics/FaceVerification';
+
 export default Omnipay;