@sanctum-key/react-native-sdk 1.0.0

package/src/modules/camera/VisionCameraModule.ts

@@ -0,0 +1,334 @@
+import { Platform } from 'react-native';
+import { Camera, CameraDevice, CameraPermissionStatus, PhotoFile } from 'react-native-vision-camera';
+
+/**
+ * Backward-compatible file copy function
+ * Tries new File API first (Expo SDK 54+), then legacy API, then regular import for SDK 53
+ */
+async function copyFileCompat(from: string, to: string): Promise<void> {
+  // Try new File API first (Expo SDK 54+)
+  try {
+    // @ts-ignore - File API might not be in types yet
+    const { File } = require('expo-file-system');
+    if (File && typeof File === 'function') {
+      const sourceFile = new File(from);
+      const destFile = new File(to);
+      // File.copy() is synchronous but may throw
+      sourceFile.copy(destFile);
+      return;
+    }
+  } catch (error) {
+    // New API not available or failed, try legacy
+    // Continue to legacy API
+  }
+
+  // Try legacy API from expo-file-system/legacy (Expo SDK 54+)
+  // This is the recommended way to avoid deprecation warnings
+  try {
+    // @ts-ignore - legacy export might not be in types
+    const LegacyFileSystem = require('expo-file-system');
+    if (LegacyFileSystem && LegacyFileSystem.copyAsync && typeof LegacyFileSystem.copyAsync === 'function') {
+      await LegacyFileSystem.copyAsync({ from, to });
+      return;
+    }
+  } catch (error) {
+    // Legacy not available (SDK 53 or earlier), fall through to regular import
+    // Check if it's a "module not found" error (SDK 53) vs other error
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes('Cannot find module') || errorMessage.includes('Module not found')) {
+      // SDK 53 or earlier - use regular import as fallback
+      // This will show a deprecation warning on SDK 54+, but is necessary for SDK 53 compatibility
+    } else {
+      // Other error, re-throw
+      throw new Error(`Unable to copy file: legacy FileSystem API error. Error: ${errorMessage}`);
+    }
+  }
+
+  // Fallback to regular import for SDK 53 and earlier
+  // Note: This will show a deprecation warning on SDK 54+, but is necessary for backward compatibility
+  try {
+    // @ts-ignore
+    const FileSystem = require('expo-file-system');
+    if (FileSystem && FileSystem.copyAsync && typeof FileSystem.copyAsync === 'function') {
+      await FileSystem.copyAsync({ from, to });
+      return;
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Unable to copy file: all FileSystem APIs failed. Last error: ${errorMessage}`);
+  }
+
+  throw new Error('Unable to copy file: no compatible FileSystem API found');
+}
+
+/**
+ * Get document directory path in a backward-compatible way
+ * Supports SDK 53 (regular import) and SDK 54+ (legacy or new API)
+ */
+function getDocumentDirectory(): string {
+  try {
+    // Try new Paths API first (Expo SDK 54+)
+    // @ts-ignore
+    const { Paths } = require('expo-file-system');
+    if (Paths?.document) {
+      return Paths.document.uri;
+    }
+  } catch (_) {
+    // New API not available, try legacy
+  }
+
+  // Try legacy API from expo-file-system/legacy (Expo SDK 54+)
+  // This is the recommended way to avoid deprecation warnings
+  try {
+    // @ts-ignore
+    const LegacyFileSystem = require('expo-file-system');
+    if (LegacyFileSystem && LegacyFileSystem.documentDirectory) {
+      return LegacyFileSystem.documentDirectory;
+    }
+  } catch (error) {
+    // Legacy not available (SDK 53 or earlier), fall through to regular import
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes('Cannot find module') || errorMessage.includes('Module not found')) {
+      // SDK 53 or earlier - use regular import as fallback
+      // This will show a deprecation warning on SDK 54+, but is necessary for SDK 53 compatibility
+    } else {
+      // Other error, continue to fallback
+    }
+  }
+
+  // Fallback to regular import for SDK 53 and earlier
+  // Note: This will show a deprecation warning on SDK 54+, but is necessary for backward compatibility
+  try {
+    // @ts-ignore
+    const FileSystem = require('expo-file-system');
+    if (FileSystem && FileSystem.documentDirectory) {
+      return FileSystem.documentDirectory;
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Unable to get document directory: all FileSystem APIs failed. Last error: ${errorMessage}`);
+  }
+
+  throw new Error('Unable to get document directory: no compatible FileSystem API found');
+}
+
+export interface CameraCaptureResult {
+  success: boolean;
+  path?: string;
+  error?: string;
+}
+
+export interface CameraPermissions {
+  camera: CameraPermissionStatus;
+  microphone: CameraPermissionStatus;
+}
+
+export class VisionCameraModule {
+  private static instance: VisionCameraModule;
+
+  public static getInstance(): VisionCameraModule {
+    if (!VisionCameraModule.instance) {
+      VisionCameraModule.instance = new VisionCameraModule();
+    }
+    return VisionCameraModule.instance;
+  }
+
+  /**
+   * Get available camera devices
+   */
+  async getCameraDevices(): Promise<CameraDevice[]> {
+    try {
+      const devices = Camera.getAvailableCameraDevices();
+      return devices;
+    } catch (error) {
+      console.error('Error getting camera devices:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get the best available device for selfies (front camera)
+   */
+  async getFrontCameraDevice(): Promise<CameraDevice | null> {
+    try {
+      const devices = await this.getCameraDevices();
+      const frontCamera = devices.find(device => device.position === 'front');
+      return frontCamera || null;
+    } catch (error) {
+      console.error('Error getting front camera:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get the best available device for document capture (back camera)
+   */
+  async getBackCameraDevice(): Promise<CameraDevice | null> {
+    try {
+      const devices = await this.getCameraDevices();
+      const backCamera = devices.find(device => device.position === 'back');
+      return backCamera || null;
+    } catch (error) {
+      console.error('Error getting back camera:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Request camera permissions
+   */
+  async requestCameraPermission(): Promise<boolean> {
+    try {
+      const permission = await Camera.requestCameraPermission();
+      return permission === 'granted';
+    } catch (error) {
+      console.error('Error requesting camera permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Request microphone permissions
+   */
+  async requestMicrophonePermission(): Promise<boolean> {
+    try {
+      const permission = await Camera.requestMicrophonePermission();
+      return permission === 'granted';
+    } catch (error) {
+      console.error('Error requesting microphone permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get current permission status
+   */
+  async getPermissionStatus(): Promise<CameraPermissions> {
+    try {
+      const cameraStatus = await Camera.getCameraPermissionStatus();
+      const microphoneStatus = await Camera.getMicrophonePermissionStatus();
+
+      return {
+        camera: cameraStatus,
+        microphone: microphoneStatus,
+      };
+    } catch (error) {
+      console.error('Error getting permission status:', error);
+      return {
+        camera: 'denied',
+        microphone: 'denied',
+      };
+    }
+  }
+
+  /**
+   * Check if all required permissions are granted
+   */
+  async hasAllPermissions(): Promise<boolean> {
+    try {
+      const status = await this.getPermissionStatus();
+      console.log('status', status);
+      return status.camera === 'granted';
+    } catch (error) {
+      console.error('Error checking permissions:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Request all required permissions
+   */
+  async requestAllPermissions(): Promise<boolean> {
+    try {
+      const [cameraGranted, microphoneGranted] = await Promise.all([
+        this.requestCameraPermission(),
+        this.requestMicrophonePermission(),
+      ]);
+
+      return cameraGranted && microphoneGranted;
+    } catch (error) {
+      console.error('Error requesting permissions:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if camera is available
+   */
+  async isCameraAvailable(): Promise<boolean> {
+    try {
+      if (Platform.OS === 'web') {
+        return false; // Vision Camera doesn't support web
+      }
+
+      const devices = await this.getCameraDevices();
+      return devices.length > 0;
+    } catch (error) {
+      console.error('Error checking camera availability:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Process photo capture result
+   */
+  async processPhotoResult(photo: PhotoFile): Promise<CameraCaptureResult> {
+    try {
+      const documentDir = getDocumentDirectory();
+      const newPath = documentDir + `photo_${Date.now()}.jpg`;
+
+      await copyFileCompat(`file://${photo.path}`, newPath);
+
+      return {
+        success: true,
+        path: newPath,
+      };
+    } catch (error) {
+      console.error('Error processing photo result:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error processing photo',
+      };
+    }
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use VisionCameraView component instead
+   */
+  async openCameraWithInstructions(instructions: string): Promise<CameraCaptureResult> {
+    console.warn('openCameraWithInstructions is deprecated. Use VisionCameraView component instead.');
+
+    try {
+      const hasPermissions = await this.requestAllPermissions();
+      if (!hasPermissions) {
+        return {
+          success: false,
+          error: 'Camera permissions not granted',
+        };
+      }
+
+      const isAvailable = await this.isCameraAvailable();
+      if (!isAvailable) {
+        return {
+          success: false,
+          error: 'Camera not available',
+        };
+      }
+
+      // Return a placeholder result since this should be handled by the component
+      return {
+        success: true,
+        path: `mock_photo_${Date.now()}.jpg`,
+      };
+    } catch (error) {
+      console.error('Error in openCameraWithInstructions:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+}
+
+export default VisionCameraModule.getInstance();