@transfergratis/react-native-sdk 0.1.4 → 0.1.5

package/src/api/axios.ts

@@ -0,0 +1,144 @@
+import axios, {
+    AxiosInstance,
+    AxiosRequestConfig,
+    InternalAxiosRequestConfig,
+    AxiosResponse,
+} from 'axios';
+
+export type ApiConfiguration = {
+    baseURL: string;
+    apiKey?: string;
+    authToken?: string;
+    timeoutMs?: number;
+};
+
+export type ApiErrorData = {
+    message?: string;
+    code?: string | number;
+    details?: unknown;
+};
+
+export class HttpClient {
+    private instance: AxiosInstance;
+    private apiKey?: string;
+    private authToken?: string;
+
+    constructor(configuration: ApiConfiguration) {
+        this.apiKey = configuration.apiKey;
+        this.authToken = configuration.authToken;
+        this.instance = axios.create({
+            baseURL: configuration.baseURL,
+            timeout: configuration.timeoutMs ?? 15000,
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+
+        this.instance.interceptors.request.use(
+            (request: InternalAxiosRequestConfig) => {
+                const headers = request.headers ?? {};
+                if (this.apiKey && !headers['x-api-key']) {
+                    headers['x-api-key'] = this.apiKey;
+                }
+                if (this.authToken && !headers.Authorization) {
+                    headers.Authorization = `Bearer ${this.authToken}`;
+                }
+                request.headers = headers;
+                return request;
+            },
+            (error) => Promise.reject(error)
+        );
+
+        this.instance.interceptors.response.use(
+            (response: AxiosResponse) => response,
+            (error) => {
+                if (!error.response) {
+                    return Promise.reject({
+                        message: 'Network error. Please check your connection.',
+                        code: 'network_error',
+                        details: error?.message,
+                    } as ApiErrorData);
+                }
+                const { status, data } = error.response as AxiosResponse<ApiErrorData>;
+                if (status === 401) {
+                    return Promise.reject({
+                        message: data?.message || 'Unauthorized',
+                        code: 401,
+                        details: data,
+                    } as ApiErrorData);
+                }
+                return Promise.reject({
+                    message: data?.message || 'Request failed',
+                    code: status,
+                    details: data,
+                } as ApiErrorData);
+            }
+        );
+    }
+
+    setAuthToken(token?: string): void {
+        this.authToken = token;
+    }
+
+    setApiKey(key?: string): void {
+        this.apiKey = key;
+    }
+
+    setBaseURL(url: string): void {
+        this.instance.defaults.baseURL = url;
+    }
+
+    async get<T = unknown>(url: string, requestConfig?: AxiosRequestConfig): Promise<T> {
+        const res = await this.instance.get<T>(url, requestConfig);
+        return res.data as T;
+    }
+
+    async post<T = unknown, B = unknown>(
+        url: string,
+        body?: B,
+        requestConfig?: AxiosRequestConfig
+    ): Promise<T> {
+        const res = await this.instance.post<T>(url, body, requestConfig);
+        return res.data as T;
+    }
+
+    async put<T = unknown, B = unknown>(
+        url: string,
+        body?: B,
+        requestConfig?: AxiosRequestConfig
+    ): Promise<T> {
+        const res = await this.instance.put<T>(url, body, requestConfig);
+        return res.data as T;
+    }
+
+    async patch<T = unknown, B = unknown>(
+        url: string,
+        body?: B,
+        requestConfig?: AxiosRequestConfig
+    ): Promise<T> {
+        const res = await this.instance.patch<T>(url, body, requestConfig);
+        return res.data as T;
+    }
+
+    async delete<T = unknown>(url: string, requestConfig?: AxiosRequestConfig): Promise<T> {
+        const res = await this.instance.delete<T>(url, requestConfig);
+        return res.data as T;
+    }
+}
+
+export default HttpClient;
+
+
+// ml service api
+export const mlService = new HttpClient({
+    baseURL: 'https://api.ml.transfergratis.com',
+    apiKey: 'your-api-key',
+});
+// backedn service api
+export const backendService = new HttpClient({
+    baseURL: 'https://api.backend.transfergratis.com',
+    apiKey: 'your-api-key',
+});
+
+

package/src/components/EnhancedCameraView.tsx

@@ -1,39 +1,12 @@
 import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { View, StyleSheet, TouchableOpacity, Text, ViewStyle } from 'react-native';
+import { View, StyleSheet, TouchableOpacity, Text } from 'react-native';
 import { Camera, useCameraDevice } from 'react-native-vision-camera';
 import VisionCameraModule from '../modules/camera/VisionCameraModule';
+import { useI18n } from '../hooks/useI18n';
+import { EnhancedCameraViewProps } from './OverLay/type';
+
+
 
-export interface EnhancedCameraViewProps {
-  instructions?: string;
-  showCamera: boolean;
-  cameraType?: 'front' | 'back';
-  style?: ViewStyle;
-  onCapture?: (result: { success: boolean; path?: string; error?: string }) => void;
-  onError?: (event: { message: string }) => void;
-  onClose?: () => void;
-  enableFlash?: boolean;
-  enableHdr?: boolean;
-  quality?: 'low' | 'medium' | 'high';
-  showCaptureButton?: boolean;
-  showSwitchCamera?: boolean;
-  overlayComponent?: React.ReactNode;
-  bbox?: {
-    xMin: number;
-    yMin: number;
-    xMax: number;
-    yMax: number;
-    borderColor?: string;
-    borderWidth?: number;
-    cornerRadius?: number;
-  };
-  canFlip?: boolean;
-  // Video recording props
-  enableVideo?: boolean;
-  isRecording?: boolean;
-  onVideoRecordingStart?: () => void;
-  onVideoRecordingStop?: (result: { success: boolean; path?: string; error?: string }) => void;
-  videoDuration?: number;
-}
 
 export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   instructions = 'Position yourself in the frame and tap the capture button',
@@ -56,7 +29,10 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   onVideoRecordingStart,
   onVideoRecordingStop,
   videoDuration = 10,
+  onSilentCapture,
+  silentCaptureResult,
 }) => {
+  const { t } = useI18n();
   const camera = useRef<Camera>(null);
   const [cameraType, setCameraType] = useState<'front' | 'back'>(initialCameraType);
   const [hasPermission, setHasPermission] = useState(false);
@@ -64,6 +40,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   const [flash, setFlash] = useState<'off' | 'on' | 'auto'>('off');
 
   const device = useCameraDevice(cameraType);
+  console.log({ setCameraType, setFlash });
 
   // Check permissions on component mount
   useEffect(() => {
@@ -78,14 +55,14 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
       if (!hasAllPermissions) {
         const granted = await VisionCameraModule.requestAllPermissions();
         if (!granted) {
-          onError?.({ message: 'Camera permissions not granted' });
+          onError?.({ message: t('camera.permissionRequired') });
           return;
         }
       }
       setHasPermission(true);
     } catch (error) {
       console.error('Error checking permissions:', error);
-      onError?.({ message: 'Error checking camera permissions' });
+      onError?.({ message: t('camera.errorOccurred') });
     }
   };
 
@@ -96,13 +73,48 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
 
   const onCameraError = useCallback((error: any) => {
     console.error('Camera error:', error);
-    onError?.({ message: error.message || 'Camera error occurred' });
-  }, [onError]);
+    onError?.({ message: error.message || t('camera.errorOccurred') });
+  }, [onError, t]);
+
+  const captureSilentPhoto = useCallback(async () => {
+    if (!camera.current || !isInitialized) {
+      onError?.({ message: t('camera.notReady') });
+      return;
+    }
+    console.log('silentCaptureResult', silentCaptureResult);
+    if (silentCaptureResult?.isAnalyzing || silentCaptureResult?.success) {
+      return;
+    }
+    try {
+      const photo = await camera.current.takePhoto({
+        enableShutterSound: true,
+        flash: enableFlash ? flash : 'off',
+      });
+
+      const result = await VisionCameraModule.processPhotoResult(photo);
+      onSilentCapture?.(result);
+    } catch (error) {
+
+    }
+  }, [isInitialized, onError, onSilentCapture]);
+
+  // Automatically take a silent photo every 5 seconds when ready
+  useEffect(() => {
+    if (!showCamera || !isInitialized) {
+      return;
+    }
+
+    const intervalId = setInterval(() => {
+      captureSilentPhoto();
+    }, 5000);
+
+    return () => clearInterval(intervalId);
+  }, [showCamera, isInitialized, captureSilentPhoto]);
 
   const capturePhoto = useCallback(async () => {
     try {
       if (!camera.current || !isInitialized) {
-        onError?.({ message: 'Camera not ready' });
+        onError?.({ message: t('camera.notReady') });
         return;
       }
 
@@ -111,13 +123,13 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
         flash: enableFlash ? flash : 'off',
       });
 
-      const result =  await VisionCameraModule.processPhotoResult(photo);
+      const result = await VisionCameraModule.processPhotoResult(photo);
       onCapture?.(result);
     } catch (error) {
       console.error('Error taking photo:', error);
       onCapture?.({
         success: false,
-        error: error instanceof Error ? error.message : 'Failed to capture photo',
+        error: error instanceof Error ? error.message : t('camera.failedToCapture'),
       });
     }
   }, [isInitialized, quality, flash, enableFlash, onCapture, onError]);
@@ -125,7 +137,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   const startVideoRecording = useCallback(async () => {
     try {
       if (!camera.current || !isInitialized) {
-        onError?.({ message: 'Camera not ready' });
+        onError?.({ message: t('camera.notReady') });
         return;
       }
 
@@ -140,7 +152,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
           console.error('Recording error:', error);
           onVideoRecordingStop?.({
             success: false,
-            error: error.message || 'Failed to record video',
+            error: error.message || t('camera.failedToStartRecording'),
           });
         },
       });
@@ -150,7 +162,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
       console.error('Error starting video recording:', error);
       onVideoRecordingStop?.({
         success: false,
-        error: error instanceof Error ? error.message : 'Failed to start video recording',
+        error: error instanceof Error ? error.message : t('camera.failedToStartRecording'),
       });
     }
   }, [isInitialized, onVideoRecordingStart, onVideoRecordingStop, onError]);
@@ -158,37 +170,37 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   const stopVideoRecording = useCallback(async () => {
     try {
       if (!camera.current) {
-        onError?.({ message: 'Camera not ready' });
+        onError?.({ message: t('camera.notReady') });
         return;
       }
 
       await camera.current.stopRecording();
     } catch (error) {
       console.error('Error stopping video recording:', error);
-      onError?.({ message: 'Failed to stop video recording' });
+      onError?.({ message: t('camera.failedToStopRecording') });
     }
   }, [onError]);
 
-  const switchCamera = useCallback(() => {
-    setCameraType(current => current === 'front' ? 'back' : 'front');
-  }, []);
+  // const switchCamera = useCallback(() => {
+  //   setCameraType(current => current === 'front' ? 'back' : 'front');
+  // }, []);
 
-  const toggleFlash = useCallback(() => {
-    setFlash(current => {
-      switch (current) {
-        case 'off': return 'on';
-        case 'on': return 'auto';
-        case 'auto': return 'off';
-        default: return 'off';
-      }
-    });
-  }, []);
+  // const toggleFlash = useCallback(() => {
+  //   setFlash(current => {
+  //     switch (current) {
+  //       case 'off': return 'on';
+  //       case 'on': return 'auto';
+  //       case 'auto': return 'off';
+  //       default: return 'off';
+  //     }
+  //   });
+  // }, []);
 
   if (!hasPermission) {
     return (
       <View style={[styles.container, style]}>
         <Text style={styles.permissionMessage}>
-          Camera permission required. Please grant permission to continue.
+          {t('camera.permissionRequired')}
         </Text>
       </View>
     );
@@ -198,7 +210,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
     return (
       <View style={[styles.container, style]}>
         <Text style={styles.errorMessage}>
-          Camera device not available
+          {t('camera.deviceNotAvailable')}
         </Text>
       </View>
     );
@@ -235,20 +247,20 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
       {/* Bounding box overlay */}
       {bbox && (
         <View style={styles.bboxOverlay}>
-                      <View
-              style={[
-                styles.bbox,
-                {
-                  left: `${bbox.xMin}%`,
-                  top: `${bbox.yMin}%`,
-                  width: `${bbox.xMax - bbox.xMin}%`,
-                  height: `${bbox.yMax - bbox.yMin}%`,
-                  borderColor: bbox.borderColor || '#2DBD60',
-                  borderWidth: bbox.borderWidth || 3,
-                  borderRadius: bbox.cornerRadius || 8,
-                }
-              ]}
-            />
+          <View
+            style={[
+              styles.bbox,
+              {
+                left: `${bbox.xMin}%`,
+                top: `${bbox.yMin}%`,
+                width: `${bbox.xMax - bbox.xMin}%`,
+                height: `${bbox.yMax - bbox.yMin}%`,
+                borderColor: bbox.borderColor || '#2DBD60',
+                borderWidth: bbox.borderWidth || 3,
+                borderRadius: bbox.cornerRadius || 8,
+              }
+            ]}
+          />
         </View>
       )}
 
@@ -256,16 +268,16 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
       {/* Camera controls */}
       <View style={styles.controlsContainer}>
         {/* Flash button */}
-        {enableFlash && (
+        {/* {enableFlash && (
           <TouchableOpacity style={styles.controlButton} onPress={toggleFlash}>
             <Text style={styles.controlButtonText}>
               {flash === 'off' ? '⚡' : flash === 'on' ? '⚡️' : '✨'}
             </Text>
           </TouchableOpacity>
-        )}
+        )} */}
 
         {/* Capture button */}
-        {showCaptureButton && !enableVideo && (
+        {showCaptureButton && !enableVideo && silentCaptureResult?.success && (
           <TouchableOpacity
             style={styles.captureButton}
             onPress={capturePhoto}
@@ -279,7 +291,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
         )}
 
         {/* Video recording button */}
-        {showCaptureButton && enableVideo && (
+        {showCaptureButton && enableVideo && silentCaptureResult?.success && (
           <TouchableOpacity
             style={[
               styles.captureButton,
@@ -297,10 +309,16 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
         )}
 
         {/* Switch camera button */}
-        {showSwitchCamera && canFlip && (
+        {/* {showSwitchCamera && canFlip && (
           <TouchableOpacity style={styles.controlButton} onPress={switchCamera}>
             <Text style={styles.controlButtonText}>🔄</Text>
           </TouchableOpacity>
+        )} */}
+
+        {silentCaptureResult?.isAnalyzing && (
+          <View style={{ backgroundColor: 'rgba(0, 0, 0, 0.7)', padding: 10, borderRadius: 10 }}>
+            <Text style={{ color: 'white', fontSize: 16, fontWeight: 'bold' }}>{t('camera.analyzing')}</Text>
+          </View>
         )}
       </View>
     </View>

package/src/components/EnhancedCameraView.web.tsx

@@ -1,37 +1,7 @@
 import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { View, StyleSheet, TouchableOpacity, Text, ViewStyle, Platform } from 'react-native';
-
-export interface EnhancedCameraViewProps {
-  instructions?: string;
-  showCamera: boolean;
-  cameraType?: 'front' | 'back';
-  style?: ViewStyle;
-  onCapture?: (result: { success: boolean; path?: string; error?: string }) => void;
-  onError?: (event: { message: string }) => void;
-  onClose?: () => void;
-  enableFlash?: boolean;
-  enableHdr?: boolean;
-  quality?: 'low' | 'medium' | 'high';
-  showCaptureButton?: boolean;
-  showSwitchCamera?: boolean;
-  overlayComponent?: React.ReactNode;
-  bbox?: {
-    xMin: number;
-    yMin: number;
-    xMax: number;
-    yMax: number;
-    borderColor?: string;
-    borderWidth?: number;
-    cornerRadius?: number;
-  };
-  canFlip?: boolean;
-  // Video recording props
-  enableVideo?: boolean;
-  isRecording?: boolean;
-  onVideoRecordingStart?: () => void;
-  onVideoRecordingStop?: (result: { success: boolean; path?: string; error?: string }) => void;
-  videoDuration?: number;
-}
+import { View, StyleSheet, TouchableOpacity, Text, Platform } from 'react-native';
+import { EnhancedCameraViewProps } from './OverLay/type';
+
 
 export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   instructions = 'Position yourself in the frame and tap the capture button',
@@ -54,6 +24,8 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   onVideoRecordingStart,
   onVideoRecordingStop,
   videoDuration = 10,
+  onSilentCapture,
+  silentCaptureResult,
 }) => {
   // Vérification de plateforme - ce composant est uniquement pour le web
   if (Platform.OS !== 'web') {
@@ -98,7 +70,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
       // Test camera permission
       const stream = await navigator.mediaDevices.getUserMedia({ video: true });
       stream.getTracks().forEach(track => track.stop());
-      
+
       setHasPermission(true);
       await startCamera();
     } catch (error) {
@@ -150,6 +122,21 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
   console.log('isInitialized', onInitialized, onCameraError);
 
   const capturePhoto = useCallback(async () => {
+    try {
+      onCapture && onCapture({
+        success: true
+      })
+    } catch (error) {
+      console.error('Error taking photo:', error);
+      onCapture?.({
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to capture photo',
+      });
+    }
+  }, [isInitialized, onCapture, onError]);
+
+
+  const captureSilentPhoto = useCallback(async () => {
     try {
       if (!videoRef.current || !canvasRef.current || !isInitialized) {
         onError?.({ message: 'Camera not ready' });
@@ -174,8 +161,8 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
 
       // Convert to base64
       const imageDataUrl = canvas.toDataURL('image/jpeg', 0.8);
-      
-      onCapture?.({
+
+      onSilentCapture?.({
         success: true,
         path: imageDataUrl,
       });
@@ -186,7 +173,21 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
         error: error instanceof Error ? error.message : 'Failed to capture photo',
       });
     }
-  }, [isInitialized, onCapture, onError]);
+  }, [isInitialized, onError, onSilentCapture]);
+
+
+  // Automatically take a silent photo every 5 seconds when ready
+  useEffect(() => {
+    if (!showCamera || !isInitialized) {
+      return;
+    }
+
+    const intervalId = setInterval(() => {
+      captureSilentPhoto();
+    }, 5000);
+
+    return () => clearInterval(intervalId);
+  }, [showCamera, isInitialized, captureSilentPhoto]);
 
   const startVideoRecording = useCallback(async () => {
     try {
@@ -211,12 +212,12 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
       recorder.onstop = () => {
         const blob = new Blob(chunks, { type: 'video/webm' });
         const url = URL.createObjectURL(blob);
-        
+
         onVideoRecordingStop?.({
           success: true,
           path: url,
         });
-        
+
         setRecordedChunks([]);
         setIsRecordingVideo(false);
       };
@@ -361,7 +362,7 @@ export const EnhancedCameraView: React.FC<EnhancedCameraViewProps> = ({
         )}
 
         {/* Capture button */}
-        {showCaptureButton && !enableVideo && (
+        {showCaptureButton && !enableVideo && silentCaptureResult?.success && (
           <TouchableOpacity
             style={styles.captureButton}
             onPress={capturePhoto}