@transfergratis/react-native-sdk 0.1.2

package/src/modules/camera/UnifiedCameraModule.ts

@@ -0,0 +1,160 @@
+import { Platform } from "react-native";
+import NativeCameraModule from "./NativeCameraModule";
+import VisionCameraModule from "./VisionCameraModule";
+
+export interface CameraCaptureResult {
+  success: boolean;
+  path?: string;
+  error?: string;
+}
+
+export interface FilePickerResult {
+  success: boolean;
+  uri?: string;
+  path?: string;
+  error?: string;
+}
+
+// Define a shared interface for the methods UnifiedCameraModule relies on
+interface CameraModuleApi {
+  testModule?: () => Promise<string>;
+  requestCameraPermission: () => Promise<boolean>;
+  openCameraWithInstructions: (instructions: string) => Promise<CameraCaptureResult>;
+  openFilePicker: (allowedTypes?: string[]) => Promise<FilePickerResult>;
+  onCameraCapture?: (callback: (event: any) => void) => { remove: () => void } | void;
+  onFileSelected?: (callback: (event: any) => void) => { remove: () => void } | void;
+  onError?: (callback: (event: any) => void) => { remove: () => void } | void;
+  destroy?: () => void;
+}
+
+export class UnifiedCameraModule {
+  private nativeModule: CameraModuleApi;
+  private webModule: CameraModuleApi;
+  private isWeb: boolean;
+
+  constructor() {
+    this.isWeb = Platform.OS === 'web';
+    // Cast to the shared interface which contains the subset of methods we use
+    this.nativeModule = NativeCameraModule as unknown as CameraModuleApi;
+    this.webModule = VisionCameraModule as unknown as CameraModuleApi;
+    
+    console.log('UnifiedCameraModule initialized for:', Platform.OS);
+  }
+
+  /**
+   * Retourne le module approprié selon la plateforme
+   */
+  private getModule(): CameraModuleApi {
+    return this.isWeb ? this.webModule : this.nativeModule;
+  }
+
+  /**
+   * Test simple du module
+   */
+  async testModule(): Promise<string> {
+    try {
+      const module = this.getModule();
+      if (module.testModule) {
+        return await module.testModule();
+      }
+      return 'No test available';
+    } catch (error) {
+      console.error('Error testing module:', error);
+      return 'Test failed';
+    }
+  }
+
+  /**
+   * Demande les permissions de caméra
+   */
+  async requestCameraPermission(): Promise<boolean> {
+    try {
+      const module = this.getModule();
+      return await module.requestCameraPermission();
+    } catch (error) {
+      console.error('Error requesting camera permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Ouvre la caméra avec des instructions personnalisées
+   */
+  async openCameraWithInstructions(instructions: string): Promise<CameraCaptureResult> {
+    try {
+      const module = this.getModule();
+      return await module.openCameraWithInstructions(instructions);
+    } catch (error) {
+      console.error('Error opening camera:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Ouvre le sélecteur de fichiers
+   */
+  async openFilePicker(allowedTypes: string[] = ['*/*']): Promise<FilePickerResult> {
+    try {
+      const module = this.getModule();
+      return await module.openFilePicker(allowedTypes);
+    } catch (error) {
+      console.error('Error opening file picker:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Écoute les événements de la caméra
+   */
+  onCameraCapture(callback: (event: any) => void) {
+    const module = this.getModule();
+    return module?.onCameraCapture?.(callback);
+  }
+
+  /**
+   * Écoute les événements de sélection de fichiers
+   */
+  onFileSelected(callback: (event: any) => void) {
+    const module = this.getModule();
+    return module.onFileSelected?.(callback);
+  }
+
+  /**
+   * Écoute les erreurs
+   */
+  onError(callback: (event: any) => void) {
+    const module = this.getModule();
+    return module.onError?.(callback);
+  }
+
+  /**
+   * Nettoyage des ressources (spécifique au web)
+   */
+  destroy() {
+    if (this.isWeb) {
+      this.webModule.destroy?.();
+    }
+  }
+
+  /**
+   * Vérifie si on est sur le web
+   */
+  isWebPlatform(): boolean {
+    return this.isWeb;
+  }
+
+  /**
+   * Vérifie si on est sur mobile natif
+   */
+  isNativePlatform(): boolean {
+    return !this.isWeb;
+  }
+}
+
+export default new UnifiedCameraModule(); 

package/src/modules/camera/VisionCameraModule.ts

@@ -0,0 +1,217 @@
+import { Platform } from 'react-native';
+import { Camera, CameraDevice, CameraPermissionStatus, PhotoFile } from 'react-native-vision-camera';
+
+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();
+      return status.camera === 'granted' && status.microphone === '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
+   */
+  processPhotoResult(photo: PhotoFile): CameraCaptureResult {
+    try {
+      return {
+        success: true,
+        path: photo.path,
+      };
+    } 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();