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

package/src/components/biometrics/PermissionManager.ts

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

@@ -0,0 +1,11 @@
+// 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

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

package/src/components/views/BvnVerification.tsx

@@ -29,7 +29,7 @@ export const BvnVerification = ({
   onVerificationSuccessful,
   onClose,
   customerRef,
-}: OmnipayProps): JSX.Element => {
+}: OmnipayProps): React.JSX.Element => {
   const webviewRef = useRef<WebView>(null);
   const [webviewStatus, setWebviewStatus] = useState<Status>('loading');
   const webHost = getWebHost();

package/src/components/views/PaylaterAgreement.tsx

@@ -41,7 +41,7 @@ export const PaylaterAgreement = ({
   feesId,
   sublimitId,
   onClose,
-}: OmnipayProps): JSX.Element => {
+}: OmnipayProps): React.JSX.Element => {
   const webviewRef = useRef<WebView>(null);
   const [webviewStatus, setWebviewStatus] = useState<Status>('loading');
   const webHost = getWebHost();

package/src/components/views/Registration.tsx

@@ -39,7 +39,7 @@ export const Registration = ({
   phoneNumber,
   onRegistrationSuccessful,
   onClose,
-}: OmnipayProps): JSX.Element => {
+}: OmnipayProps): React.JSX.Element => {
   const webviewRef = useRef<WebView>(null);
   const [webviewStatus, setWebviewStatus] = useState<Status>('loading');
   const webHost = getWebHost();

package/src/index.tsx

@@ -3,21 +3,10 @@ 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';
+// Biometric components and utilities
+export { FaceVerification, LivenessDetection } from './components/biometrics';
 
-export {
-  default as LivenessCameraView,
-  type LivenessCameraViewProps,
-} from './components/biometrics/LivenessCameraView';
-
-export { default as FaceVerification } from './components/biometrics/FaceVerification';
+// Biometric types
+export * from './components/biometrics/types';
 
 export default Omnipay;

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

@@ -1,116 +0,0 @@
-package com.omniretail.omnipay;
-
-import android.content.Context;
-import android.view.View;
-import android.widget.FrameLayout;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.camera.view.PreviewView;
-
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.common.MapBuilder;
-import com.facebook.react.uimanager.SimpleViewManager;
-import com.facebook.react.uimanager.ThemedReactContext;
-import com.facebook.react.uimanager.annotations.ReactProp;
-
-import java.util.Map;
-
-public class LivenessCameraViewManager extends SimpleViewManager<FrameLayout> {
-    public static final String REACT_CLASS = "LivenessCameraView";
-    private ReactApplicationContext reactContext;
-
-    public LivenessCameraViewManager(ReactApplicationContext reactContext) {
-        this.reactContext = reactContext;
-    }
-
-    @Override
-    @NonNull
-    public String getName() {
-        return REACT_CLASS;
-    }
-
-    @Override
-    @NonNull
-    public FrameLayout createViewInstance(@NonNull ThemedReactContext context) {
-        FrameLayout frameLayout = new FrameLayout(context);
-        frameLayout.setLayoutParams(new FrameLayout.LayoutParams(
-            FrameLayout.LayoutParams.MATCH_PARENT,
-            FrameLayout.LayoutParams.MATCH_PARENT
-        ));
-        
-        // Get the camera preview from the LivenessDetectionModule
-        try {
-            LivenessDetectionModule livenessModule = reactContext.getNativeModule(LivenessDetectionModule.class);
-            if (livenessModule != null) {
-                PreviewView previewView = livenessModule.getPreviewView();
-                if (previewView != null) {
-                    // Remove from any existing parent
-                    if (previewView.getParent() != null) {
-                        ((FrameLayout) previewView.getParent()).removeView(previewView);
-                    }
-                    
-                    frameLayout.addView(previewView, new FrameLayout.LayoutParams(
-                        FrameLayout.LayoutParams.MATCH_PARENT,
-                        FrameLayout.LayoutParams.MATCH_PARENT
-                    ));
-                }
-            }
-        } catch (Exception e) {
-            // Handle gracefully - the camera view will be set up later
-        }
-        
-        return frameLayout;
-    }
-
-    @ReactProp(name = "scaleType")
-    public void setScaleType(FrameLayout view, @Nullable String scaleType) {
-        // Find the PreviewView child and set scale type
-        for (int i = 0; i < view.getChildCount(); i++) {
-            View child = view.getChildAt(i);
-            if (child instanceof PreviewView) {
-                PreviewView previewView = (PreviewView) child;
-                if ("fillStart".equals(scaleType)) {
-                    previewView.setScaleType(PreviewView.ScaleType.FILL_START);
-                } else if ("fillCenter".equals(scaleType)) {
-                    previewView.setScaleType(PreviewView.ScaleType.FILL_CENTER);
-                } else if ("fillEnd".equals(scaleType)) {
-                    previewView.setScaleType(PreviewView.ScaleType.FILL_END);
-                } else if ("fitStart".equals(scaleType)) {
-                    previewView.setScaleType(PreviewView.ScaleType.FIT_START);
-                } else if ("fitCenter".equals(scaleType)) {
-                    previewView.setScaleType(PreviewView.ScaleType.FIT_CENTER);
-                } else if ("fitEnd".equals(scaleType)) {
-                    previewView.setScaleType(PreviewView.ScaleType.FIT_END);
-                } else {
-                    // Default to fill center
-                    previewView.setScaleType(PreviewView.ScaleType.FILL_CENTER);
-                }
-                break;
-            }
-        }
-    }
-
-    @Override
-    public void onDropViewInstance(@NonNull FrameLayout view) {
-        super.onDropViewInstance(view);
-        // Clean up camera resources if needed
-        try {
-            LivenessDetectionModule livenessModule = reactContext.getNativeModule(LivenessDetectionModule.class);
-            if (livenessModule != null) {
-                // The module will handle cleanup when detection stops
-            }
-        } catch (Exception e) {
-            // Handle gracefully
-        }
-    }
-
-    @Override
-    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
-        return MapBuilder.<String, Object>builder()
-            .put("onCameraReady", MapBuilder.of("registrationName", "onCameraReady"))
-            .put("onCameraError", MapBuilder.of("registrationName", "onCameraError"))
-            .build();
-    }
-}