@transfergratis/react-native-sdk 0.1.2

package/src/modules/camera/VisionCameraModule.web.ts

@@ -0,0 +1,661 @@
+import { Platform } from 'react-native';
+
+export interface CameraCaptureResult {
+  success: boolean;
+  path?: string;
+  error?: string;
+}
+
+export interface CameraPermissions {
+  camera: 'granted' | 'denied' | 'restricted' | 'not-determined';
+  microphone: 'granted' | 'denied' | 'restricted' | 'not-determined';
+}
+
+export interface CameraDevice {
+  id: string;
+  name: string;
+  position: 'front' | 'back';
+  hasFlash: boolean;
+  hasTorch: boolean;
+  supportsLowLightBoost: boolean;
+  supportsFocus: boolean;
+  supportsVideoStabilization: boolean;
+  supportsVideoHDR: boolean;
+  supportsPhotoHDR: boolean;
+  supportsDepthCapture: boolean;
+  supportsPortraitEffectsMatteDelivery: boolean;
+  supportsRawCapture: boolean;
+  supportsZoom: boolean;
+}
+
+export interface PhotoFile {
+  path: string;
+  width: number;
+  height: number;
+  isRawPhoto: boolean;
+  metadata?: any;
+}
+
+export class VisionCameraModule {
+  private static instance: VisionCameraModule;
+  private videoElement: HTMLVideoElement | null = null;
+  private canvasElement: HTMLCanvasElement | null = null;
+  private stream: MediaStream | null = null;
+  private isCameraActive = false;
+  
+  public static getInstance(): VisionCameraModule {
+    if (!VisionCameraModule.instance) {
+      VisionCameraModule.instance = new VisionCameraModule();
+    }
+    return VisionCameraModule.instance;
+  }
+
+  constructor() {
+    console.log('VisionCameraModule.web constructor called');
+    console.log('Platform:', Platform.OS);
+    
+    // Créer les éléments DOM nécessaires
+    this.createVideoElements();
+  }
+
+  private createVideoElements() {
+    // Créer un élément vidéo caché pour la capture
+    this.videoElement = document.createElement('video');
+    this.videoElement.style.position = 'absolute';
+    this.videoElement.style.left = '-9999px';
+    this.videoElement.style.top = '-9999px';
+    this.videoElement.autoplay = true;
+    this.videoElement.muted = true;
+    this.videoElement.playsInline = true;
+
+    // Créer un canvas caché pour la capture d'image
+    this.canvasElement = document.createElement('canvas');
+    this.canvasElement.style.position = 'absolute';
+    this.canvasElement.style.left = '-9999px';
+    this.canvasElement.style.top = '-9999px';
+
+    // Ajouter les éléments au DOM
+    document.body.appendChild(this.videoElement);
+    document.body.appendChild(this.canvasElement);
+  }
+
+  /**
+   * Get available camera devices (web simulation)
+   */
+  async getCameraDevices(): Promise<CameraDevice[]> {
+    try {
+      if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) {
+        return [];
+      }
+
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const videoDevices = devices.filter(device => device.kind === 'videoinput');
+      
+      return videoDevices.map((device, index) => ({
+        id: device.deviceId || `web_camera_${index}`,
+        name: device.label || `Camera ${index + 1}`,
+        position: index === 0 ? 'front' : 'back', // Première caméra = front, autres = back
+        hasFlash: false,
+        hasTorch: false,
+        supportsLowLightBoost: false,
+        supportsFocus: true,
+        supportsVideoStabilization: false,
+        supportsVideoHDR: false,
+        supportsPhotoHDR: false,
+        supportsDepthCapture: false,
+        supportsPortraitEffectsMatteDelivery: false,
+        supportsRawCapture: false,
+        supportsZoom: true,
+      }));
+    } 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 {
+      if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+        console.warn('getUserMedia not supported');
+        return false;
+      }
+
+      const stream = await navigator.mediaDevices.getUserMedia({ 
+        video: { 
+          facingMode: 'user',
+          width: { ideal: 1280 },
+          height: { ideal: 720 }
+        } 
+      });
+      
+      // Libérer le stream de test
+      stream.getTracks().forEach(track => track.stop());
+      
+      return true;
+    } catch (error) {
+      console.error('Error requesting camera permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Request microphone permissions
+   */
+  async requestMicrophonePermission(): Promise<boolean> {
+    try {
+      if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+        console.warn('getUserMedia not supported');
+        return false;
+      }
+
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      
+      // Libérer le stream de test
+      stream.getTracks().forEach(track => track.stop());
+      
+      return true;
+    } catch (error) {
+      console.error('Error requesting microphone permission:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get current permission status
+   */
+  async getPermissionStatus(): Promise<CameraPermissions> {
+    try {
+      const cameraGranted = await this.requestCameraPermission();
+      const microphoneGranted = await this.requestMicrophonePermission();
+      
+      return {
+        camera: cameraGranted ? 'granted' : 'denied',
+        microphone: microphoneGranted ? 'granted' : 'denied',
+      };
+    } 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') {
+        const devices = await this.getCameraDevices();
+        return devices.length > 0;
+      }
+      
+      return false; // Sur le web, on utilise notre implémentation
+    } 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',
+        };
+      }
+
+      // Démarrer la caméra
+      await this.startCamera();
+
+      // Créer une interface utilisateur pour la capture
+      const captureResult = await this.showCameraInterface(instructions);
+      
+      // Arrêter la caméra
+      await this.stopCamera();
+
+      return captureResult;
+    } catch (error) {
+      console.error('Error in openCameraWithInstructions:', error);
+      await this.stopCamera();
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  /**
+   * Démarre la caméra
+   */
+  private async startCamera(): Promise<void> {
+    try {
+      if (this.isCameraActive) {
+        return;
+      }
+
+      this.stream = await navigator.mediaDevices.getUserMedia({
+        video: {
+          facingMode: 'user',
+          width: { ideal: 1280 },
+          height: { ideal: 720 }
+        }
+      });
+
+      if (this.videoElement) {
+        this.videoElement.srcObject = this.stream;
+        await this.videoElement.play();
+        this.isCameraActive = true;
+      }
+    } catch (error) {
+      console.error('Error starting camera:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Arrête la caméra
+   */
+  private async stopCamera(): Promise<void> {
+    try {
+      if (this.stream) {
+        this.stream.getTracks().forEach(track => track.stop());
+        this.stream = null;
+      }
+      
+      if (this.videoElement) {
+        this.videoElement.srcObject = null;
+      }
+      
+      this.isCameraActive = false;
+    } catch (error) {
+      console.error('Error stopping camera:', error);
+    }
+  }
+
+  /**
+   * Affiche l'interface de la caméra
+   */
+  private async showCameraInterface(instructions: string): Promise<CameraCaptureResult> {
+    return new Promise((resolve) => {
+      // Créer l'interface utilisateur
+      const overlay = this.createCameraOverlay(instructions);
+      
+      // Ajouter au DOM
+      document.body.appendChild(overlay);
+
+      // Gérer la capture
+      const captureButton = overlay.querySelector('.capture-btn') as HTMLButtonElement;
+      const cancelButton = overlay.querySelector('.cancel-btn') as HTMLButtonElement;
+
+      captureButton.addEventListener('click', async () => {
+        const result = await this.captureImage();
+        document.body.removeChild(overlay);
+        resolve(result);
+      });
+
+      cancelButton.addEventListener('click', () => {
+        document.body.removeChild(overlay);
+        resolve({
+          success: false,
+          error: 'Capture cancelled by user'
+        });
+      });
+    });
+  }
+
+  /**
+   * Crée l'overlay de la caméra
+   */
+  private createCameraOverlay(instructions: string): HTMLElement {
+    const overlay = document.createElement('div');
+    overlay.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100vw;
+      height: 100vh;
+      background: rgba(0, 0, 0, 0.9);
+      z-index: 10000;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      font-family: Arial, sans-serif;
+      color: white;
+    `;
+
+    // Instructions
+    const instructionsDiv = document.createElement('div');
+    instructionsDiv.style.cssText = `
+      text-align: center;
+      margin-bottom: 20px;
+      padding: 20px;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 10px;
+      max-width: 400px;
+    `;
+    instructionsDiv.innerHTML = `
+      <h3 style="margin: 0 0 10px 0;">Instructions</h3>
+      <p style="margin: 0;">${instructions}</p>
+    `;
+
+    // Aperçu vidéo
+    const videoPreview = document.createElement('div');
+    videoPreview.style.cssText = `
+      width: 400px;
+      height: 300px;
+      background: #000;
+      border-radius: 10px;
+      margin-bottom: 20px;
+      overflow: hidden;
+      position: relative;
+    `;
+
+    if (this.videoElement) {
+      this.videoElement.style.cssText = `
+        position: relative;
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+      `;
+      videoPreview.appendChild(this.videoElement);
+    }
+
+    // Boutons
+    const buttonContainer = document.createElement('div');
+    buttonContainer.style.cssText = `
+      display: flex;
+      gap: 20px;
+    `;
+
+    const captureBtn = document.createElement('button');
+    captureBtn.className = 'capture-btn';
+    captureBtn.textContent = '📸 Capturer';
+    captureBtn.style.cssText = `
+      padding: 15px 30px;
+      font-size: 16px;
+      background: #007AFF;
+      color: white;
+      border: none;
+      border-radius: 25px;
+      cursor: pointer;
+      font-weight: bold;
+    `;
+
+    const cancelBtn = document.createElement('button');
+    cancelBtn.className = 'cancel-btn';
+    cancelBtn.textContent = '❌ Annuler';
+    cancelBtn.style.cssText = `
+      padding: 15px 30px;
+      font-size: 16px;
+      background: #FF3B30;
+      color: white;
+      border: none;
+      border-radius: 25px;
+      cursor: pointer;
+      font-weight: bold;
+    `;
+
+    buttonContainer.appendChild(captureBtn);
+    buttonContainer.appendChild(cancelBtn);
+
+    overlay.appendChild(instructionsDiv);
+    overlay.appendChild(videoPreview);
+    overlay.appendChild(buttonContainer);
+
+    return overlay;
+  }
+
+  /**
+   * Capture une image depuis la vidéo
+   */
+  private async captureImage(): Promise<CameraCaptureResult> {
+    try {
+      if (!this.videoElement || !this.canvasElement) {
+        return {
+          success: false,
+          error: 'Video or canvas element not available'
+        };
+      }
+
+      // Configurer le canvas
+      this.canvasElement.width = this.videoElement.videoWidth;
+      this.canvasElement.height = this.videoElement.videoHeight;
+
+      // Dessiner la frame actuelle sur le canvas
+      const context = this.canvasElement.getContext('2d');
+      if (!context) {
+        return {
+          success: false,
+          error: 'Canvas context not available'
+        };
+      }
+
+      context.drawImage(this.videoElement, 0, 0);
+
+      // Convertir en base64
+      const imageDataUrl = this.canvasElement.toDataURL('image/jpeg', 0.8);
+      
+      // Créer un nom de fichier unique
+      const timestamp = new Date().getTime();
+      const filename = `web_capture_${timestamp}.jpg`;
+      console.log('imageDataUrl', imageDataUrl, filename);
+
+      return {
+        success: true,
+        path: imageDataUrl,
+      };
+    } catch (error) {
+      console.error('Error capturing image:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Test simple du module web
+   */
+  async testModule(): Promise<string> {
+    try {
+      const hasCamera = await this.isCameraAvailable();
+      if (hasCamera) {
+        return 'Web VisionCameraModule working';
+      } else {
+        return 'No camera available';
+      }
+    } catch (error) {
+      console.error('Error testing web module:', error);
+      return 'Test failed';
+    }
+  }
+
+  /**
+   * Ouvre le sélecteur de fichiers
+   */
+  async openFilePicker(allowedTypes: string[] = ['*/*']): Promise<{ success: boolean; uri?: string; path?: string; error?: string }> {
+    try {
+      // Créer un input file caché
+      const input = document.createElement('input');
+      input.type = 'file';
+      input.accept = allowedTypes.join(',');
+      input.style.position = 'absolute';
+      input.style.left = '-9999px';
+      input.style.top = '-9999px';
+
+      document.body.appendChild(input);
+
+      return new Promise((resolve) => {
+        input.onchange = (event) => {
+          const target = event.target as HTMLInputElement;
+          const file = target.files?.[0];
+
+          if (file) {
+            const reader = new FileReader();
+            reader.onload = () => {
+              const result = reader.result as string;
+              document.body.removeChild(input);
+              resolve({
+                success: true,
+                uri: result,
+                path: result
+              });
+            };
+            reader.readAsDataURL(file);
+          } else {
+            document.body.removeChild(input);
+            resolve({
+              success: false,
+              error: 'No file selected'
+            });
+          }
+        };
+
+        input.click();
+      });
+    } 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 (simulation pour le web)
+   */
+  onCameraCapture(callback: (event: any) => void) {
+    console.log('onCameraCapture listener added (web simulation)');
+    return { remove: () => {} };
+  }
+
+  /**
+   * Écoute les événements de sélection de fichiers (simulation pour le web)
+   */
+  onFileSelected(callback: (event: any) => void) {
+    console.log('onFileSelected listener added (web simulation)');
+    return { remove: () => {} };
+  }
+
+  /**
+   * Écoute les erreurs (simulation pour le web)
+   */
+  onError(callback: (event: any) => void) {
+    console.log('onError listener added (web simulation)');
+    return { remove: () => {} };
+  }
+
+  /**
+   * Nettoyage des ressources
+   */
+  destroy() {
+    this.stopCamera();
+    if (this.videoElement && this.videoElement.parentNode) {
+      this.videoElement.parentNode.removeChild(this.videoElement);
+    }
+    if (this.canvasElement && this.canvasElement.parentNode) {
+      this.canvasElement.parentNode.removeChild(this.canvasElement);
+    }
+  }
+}
+
+export default VisionCameraModule.getInstance();

package/src/modules/camera/index.ts

@@ -0,0 +1,6 @@
+export { default as NativeCameraModule } from './NativeCameraModule';
+export { default as VisionCameraModule } from './VisionCameraModule';
+export { default as UnifiedCameraModule } from './UnifiedCameraModule';
+
+// Types communs
+export type { CameraCaptureResult, FilePickerResult } from './UnifiedCameraModule';