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

package/src/components/biometrics/LivenessDetection.ts

@@ -1,178 +0,0 @@
-import { NativeModules, NativeEventEmitter } from 'react-native';
-import type {
-  LivenessConfig,
-  LivenessResult,
-  LivenessChallenge,
-  ChallengeResult,
-  LivenessEventCallbacks,
-} from './types';
-
-const { OmnipayLivenessModule } = NativeModules;
-
-class LivenessDetectionManager {
-  private eventEmitter?: NativeEventEmitter;
-  private eventListeners: { [key: string]: any } = {};
-
-  constructor() {
-    if (OmnipayLivenessModule) {
-      this.eventEmitter = new NativeEventEmitter(OmnipayLivenessModule);
-    }
-  }
-
-  /**
-   * Check if liveness detection is supported on this device
-   */
-  async isSupported(): Promise<boolean> {
-    console.log('🔧 LivenessDetection.isSupported() called');
-
-    if (!OmnipayLivenessModule) {
-      console.log('❌ OmnipayLivenessModule not available in NativeModules');
-      console.log('📋 Available modules:', Object.keys(NativeModules));
-      return false;
-    }
-
-    console.log(
-      '✅ OmnipayLivenessModule found, calling native isSupported...'
-    );
-
-    try {
-      const result = await OmnipayLivenessModule.isSupported();
-      console.log('📋 Native isSupported result:', result);
-      return result;
-    } catch (error) {
-      console.error('💥 Liveness detection support check failed:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Start liveness detection with given configuration
-   */
-  async startDetection(
-    config: LivenessConfig,
-    callbacks?: LivenessEventCallbacks
-  ): Promise<LivenessResult> {
-    if (!OmnipayLivenessModule) {
-      throw new Error('Liveness detection module not available');
-    }
-
-    // Set up event listeners if callbacks provided
-    if (callbacks) {
-      this.setupEventListeners(callbacks);
-    }
-
-    try {
-      const result = await OmnipayLivenessModule.startLivenessDetection(config);
-      return result;
-    } catch (error) {
-      this.cleanupEventListeners();
-      throw error;
-    }
-  }
-
-  /**
-   * Stop the current detection
-   */
-  async stopDetection(): Promise<void> {
-    if (!OmnipayLivenessModule) {
-      return;
-    }
-
-    try {
-      await OmnipayLivenessModule.stopDetection();
-    } finally {
-      this.cleanupEventListeners();
-    }
-  }
-
-  /**
-   * Set up event listeners for detection callbacks
-   */
-  private setupEventListeners(callbacks: LivenessEventCallbacks) {
-    this.cleanupEventListeners(); // Clean up any existing listeners
-
-    if (!this.eventEmitter) {
-      console.warn('Event emitter not available for liveness detection');
-      return;
-    }
-
-    if (callbacks.onChallengeStart) {
-      this.eventListeners.challengeStart = this.eventEmitter.addListener(
-        'onChallengeStart',
-        (challenge: LivenessChallenge) => callbacks.onChallengeStart!(challenge)
-      );
-    }
-
-    if (callbacks.onChallengeSuccess) {
-      this.eventListeners.challengeSuccess = this.eventEmitter.addListener(
-        'onChallengeSuccess',
-        (data: { challenge: LivenessChallenge; result: ChallengeResult }) =>
-          callbacks.onChallengeSuccess!(data.challenge, data.result)
-      );
-    }
-
-    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)
-      );
-    }
-  }
-
-  /**
-   * Clean up all event listeners
-   */
-  private cleanupEventListeners() {
-    Object.values(this.eventListeners).forEach((listener) => {
-      if (listener && listener.remove) {
-        listener.remove();
-      }
-    });
-    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();
-
-// Export types for convenience
-export * from './types';

package/src/components/biometrics/OmnipayLivenessCameraView.tsx

@@ -1,19 +0,0 @@
-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} />;
-};

package/src/components/biometrics/PermissionManager.ts

@@ -1,317 +0,0 @@
-import { Platform, Alert, Linking, PermissionsAndroid } from 'react-native';
-import { LivenessDetection } from './LivenessDetection';
-
-export enum PermissionResult {
-  GRANTED = 'granted',
-  DENIED = 'denied',
-  BLOCKED = 'blocked',
-  UNAVAILABLE = 'unavailable',
-}
-
-export interface PermissionResponse {
-  result: PermissionResult;
-  canRequest: boolean;
-  message?: string;
-}
-
-export class CameraPermissionManager {
-  /**
-   * Check current camera permission status
-   */
-  static async checkCameraPermission(): Promise<PermissionResponse> {
-    try {
-      if (Platform.OS === 'android') {
-        return await this.checkAndroidCameraPermission();
-      } else {
-        // For iOS, we'll check through the native module
-        return await this.checkIOSCameraPermission();
-      }
-    } catch (error) {
-      console.error('Error checking camera permission:', error);
-      return {
-        result: PermissionResult.UNAVAILABLE,
-        canRequest: false,
-        message: 'Unable to check camera permission',
-      };
-    }
-  }
-
-  /**
-   * Request camera permission with user-friendly flow
-   */
-  static async requestCameraPermission(
-    showRationale: boolean = true
-  ): Promise<PermissionResponse> {
-    try {
-      // First check current status
-      const currentStatus = await this.checkCameraPermission();
-
-      if (currentStatus.result === PermissionResult.GRANTED) {
-        return currentStatus;
-      }
-
-      if (currentStatus.result === PermissionResult.BLOCKED) {
-        if (showRationale) {
-          this.showPermissionBlockedAlert();
-        }
-        return currentStatus;
-      }
-
-      // Show rationale if needed
-      if (showRationale && currentStatus.result === PermissionResult.DENIED) {
-        const shouldProceed = await this.showPermissionRationale();
-        if (!shouldProceed) {
-          return {
-            result: PermissionResult.DENIED,
-            canRequest: true,
-            message: 'User declined to grant permission',
-          };
-        }
-      }
-
-      // Request permission based on platform
-      if (Platform.OS === 'android') {
-        return await this.requestAndroidCameraPermission();
-      } else {
-        return await this.requestIOSCameraPermission();
-      }
-    } catch (error) {
-      console.error('Error requesting camera permission:', error);
-      return {
-        result: PermissionResult.UNAVAILABLE,
-        canRequest: false,
-        message: 'Unable to request camera permission',
-      };
-    }
-  }
-
-  /**
-   * Check Android camera permission using PermissionsAndroid
-   */
-  private static async checkAndroidCameraPermission(): Promise<PermissionResponse> {
-    const hasPermission = await PermissionsAndroid.check(
-      PermissionsAndroid.PERMISSIONS.CAMERA
-    );
-
-    if (hasPermission) {
-      return {
-        result: PermissionResult.GRANTED,
-        canRequest: false,
-        message: 'Camera permission granted',
-      };
-    }
-
-    return {
-      result: PermissionResult.DENIED,
-      canRequest: true,
-      message: 'Camera permission not granted',
-    };
-  }
-
-  /**
-   * Request Android camera permission
-   */
-  private static async requestAndroidCameraPermission(): Promise<PermissionResponse> {
-    try {
-      const granted = await PermissionsAndroid.request(
-        PermissionsAndroid.PERMISSIONS.CAMERA,
-        {
-          title: 'Camera Permission Required',
-          message:
-            'Face verification requires camera access to capture your image and perform liveness detection.',
-          buttonNeutral: 'Ask Me Later',
-          buttonNegative: 'Cancel',
-          buttonPositive: 'OK',
-        }
-      );
-
-      switch (granted) {
-        case PermissionsAndroid.RESULTS.GRANTED:
-          return {
-            result: PermissionResult.GRANTED,
-            canRequest: false,
-            message: 'Camera permission granted',
-          };
-
-        case PermissionsAndroid.RESULTS.DENIED:
-          return {
-            result: PermissionResult.DENIED,
-            canRequest: true,
-            message: 'Camera permission denied',
-          };
-
-        case PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN:
-          return {
-            result: PermissionResult.BLOCKED,
-            canRequest: false,
-            message: 'Camera permission permanently blocked',
-          };
-
-        default:
-          return {
-            result: PermissionResult.DENIED,
-            canRequest: true,
-            message: 'Camera permission denied',
-          };
-      }
-    } catch (error) {
-      console.error('Error requesting Android camera permission:', error);
-      return {
-        result: PermissionResult.UNAVAILABLE,
-        canRequest: false,
-        message: 'Unable to request camera permission',
-      };
-    }
-  }
-
-  /**
-   * Check iOS camera permission through native module
-   */
-  private static async checkIOSCameraPermission(): Promise<PermissionResponse> {
-    try {
-      // iOS permissions are handled automatically by AVCaptureDevice
-      // We'll use the liveness detection module to check support
-      const isSupported = await LivenessDetection.isSupported();
-
-      if (isSupported) {
-        return {
-          result: PermissionResult.GRANTED,
-          canRequest: false,
-          message: 'Camera access available',
-        };
-      } else {
-        return {
-          result: PermissionResult.UNAVAILABLE,
-          canRequest: false,
-          message: 'Camera not available',
-        };
-      }
-    } catch (error) {
-      return {
-        result: PermissionResult.UNAVAILABLE,
-        canRequest: false,
-        message: 'Unable to check camera availability',
-      };
-    }
-  }
-
-  /**
-   * Request iOS camera permission through native module
-   */
-  private static async requestIOSCameraPermission(): Promise<PermissionResponse> {
-    // iOS camera permissions are handled automatically by the native module
-    // when startLivenessDetection is called. The system will show the permission
-    // dialog automatically if needed.
-    return {
-      result: PermissionResult.GRANTED,
-      canRequest: false,
-      message: 'iOS camera permission will be requested automatically',
-    };
-  }
-
-  /**
-   * Request permission with retry logic
-   */
-  static async requestWithRetry(
-    maxRetries: number = 2
-  ): Promise<PermissionResponse> {
-    let lastResponse: PermissionResponse;
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const isFirstAttempt = attempt === 0;
-      lastResponse = await this.requestCameraPermission(isFirstAttempt);
-
-      if (lastResponse.result === PermissionResult.GRANTED) {
-        return lastResponse;
-      }
-
-      if (
-        lastResponse.result === PermissionResult.BLOCKED ||
-        lastResponse.result === PermissionResult.UNAVAILABLE
-      ) {
-        break; // No point in retrying
-      }
-
-      // Wait a bit before retry
-      if (attempt < maxRetries) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      }
-    }
-
-    return lastResponse!;
-  }
-
-  /**
-   * Show rationale dialog explaining why camera permission is needed
-   */
-  private static showPermissionRationale(): Promise<boolean> {
-    return new Promise((resolve) => {
-      Alert.alert(
-        'Camera Permission Required',
-        'Face verification requires camera access to capture your image and perform liveness detection. This ensures secure identity verification.',
-        [
-          {
-            text: 'Not Now',
-            style: 'cancel',
-            onPress: () => resolve(false),
-          },
-          {
-            text: 'Allow Camera',
-            onPress: () => resolve(true),
-          },
-        ],
-        { cancelable: false }
-      );
-    });
-  }
-
-  /**
-   * Show alert when permission is permanently blocked
-   */
-  private static showPermissionBlockedAlert(): void {
-    Alert.alert(
-      'Camera Permission Blocked',
-      'Camera access has been blocked. To use face verification, please enable camera permission in your device settings.',
-      [
-        {
-          text: 'Cancel',
-          style: 'cancel',
-        },
-        {
-          text: 'Open Settings',
-          onPress: () => Linking.openSettings(),
-        },
-      ]
-    );
-  }
-
-  /**
-   * Get user-friendly permission status message
-   */
-  static getPermissionStatusMessage(result: PermissionResult): string {
-    switch (result) {
-      case PermissionResult.GRANTED:
-        return 'Camera access granted';
-      case PermissionResult.DENIED:
-        return 'Camera access denied. Tap to allow camera permission.';
-      case PermissionResult.BLOCKED:
-        return 'Camera access blocked. Please enable in device settings.';
-      case PermissionResult.UNAVAILABLE:
-        return 'Camera not available on this device';
-      default:
-        return 'Unknown permission status';
-    }
-  }
-
-  /**
-   * Check if the device has camera capability
-   */
-  static async hasCamera(): Promise<boolean> {
-    try {
-      const status = await this.checkCameraPermission();
-      return status.result !== PermissionResult.UNAVAILABLE;
-    } catch {
-      return false;
-    }
-  }
-}

package/src/components/biometrics/index.ts

@@ -1,11 +0,0 @@
-// Export the main face verification component with liveness detection
-export { default as FaceVerification } from './FaceVerification';
-
-// Export the liveness detection manager
-export { LivenessDetection } from './LivenessDetection';
-
-// Export the native camera view
-export { OmnipayLivenessCameraView } from './OmnipayLivenessCameraView';
-
-// Export all types
-export * from './types';

package/src/components/biometrics/types.ts

@@ -1,86 +0,0 @@
-// Liveness Detection Types
-
-export enum LivenessChallenge {
-  SMILE = 'smile',
-  BLINK = 'blink',
-  TURN_LEFT = 'turnLeft',
-  TURN_RIGHT = 'turnRight',
-}
-
-export interface LivenessConfig {
-  /** Which challenges to include in the detection flow */
-  challenges?: LivenessChallenge[];
-  /** Timeout in seconds for each challenge (default: 10) */
-  challengeTimeout?: number;
-  /** Total timeout in seconds for entire flow (default: 60) */
-  totalTimeout?: number;
-  /** Enable debug mode with visual feedback */
-  debugMode?: boolean;
-}
-
-export interface LivenessResult {
-  /** Whether all challenges were completed successfully */
-  success: boolean;
-  /** Base64 encoded final screenshot after completion */
-  screenshot?: string;
-  /** Results for each individual challenge */
-  challengeResults: ChallengeResult[];
-  /** Total time taken in milliseconds */
-  totalDuration: number;
-  /** Reason for failure if unsuccessful */
-  failureReason?: string;
-}
-
-export interface ChallengeResult {
-  /** The challenge that was performed */
-  challenge: LivenessChallenge;
-  /** Whether this specific challenge was successful */
-  success: boolean;
-  /** Time taken for this challenge in milliseconds */
-  duration: number;
-  /** Confidence score (0-1) if available */
-  confidence?: number;
-}
-
-// Event callback types
-export interface LivenessEventCallbacks {
-  /** Called when a challenge starts */
-  onChallengeStart?: (challenge: LivenessChallenge) => void;
-  /** Called when a challenge is completed successfully */
-  onChallengeSuccess?: (
-    challenge: LivenessChallenge,
-    result: ChallengeResult
-  ) => void;
-  /** Called when a challenge fails */
-  onChallengeFailure?: (challenge: LivenessChallenge, reason: string) => void;
-  /** Called when all challenges are completed */
-  onAllChallengesComplete?: () => void;
-  /** Called when the final screenshot is captured */
-  onScreenshotCaptured?: (screenshot: string) => void;
-  /** Called when detection is cancelled or fails */
-  onDetectionFailed?: (reason: string) => void;
-}
-
-// Native module interface
-export interface LivenessNativeModule {
-  /** Start the liveness detection flow */
-  startLivenessDetection(config: LivenessConfig): Promise<LivenessResult>;
-  /** Stop the current detection */
-  stopDetection(): Promise<void>;
-  /** Check if the device supports liveness detection */
-  isSupported(): Promise<boolean>;
-}
-
-// Component props
-export interface LivenessDetectionProps extends LivenessEventCallbacks {
-  /** Whether the liveness detection modal is visible */
-  visible: boolean;
-  /** Called when user closes the modal */
-  onClose: () => void;
-  /** Called when liveness detection completes successfully */
-  onSuccess: (result: LivenessResult) => void;
-  /** Configuration for the liveness detection */
-  config?: LivenessConfig;
-  /** Primary color for UI elements */
-  primaryColor?: string;
-}