@onairos/react-native 3.1.16 → 3.1.18

package/src/services/imageCompressionService.ts

@@ -1,303 +1,303 @@
-import ImageResizer from '@bam.tech/react-native-image-resizer';
-
-/**
- * Comprehensive image compression service for React Native
- * Supports iterative compression to meet specific size targets
- */
-
-interface CompressionOptions {
-  maxSizeKB?: number;
-  maxWidth?: number;
-  maxHeight?: number;
-  quality?: number;
-  format?: 'JPEG' | 'PNG' | 'WEBP';
-}
-
-interface CompressionResult {
-  success: boolean;
-  base64?: string;
-  sizeKB?: number;
-  originalSizeKB?: number;
-  compressionRatio?: number;
-  error?: string;
-}
-
-/**
- * Get file size from URI (React Native compatible)
- */
-const getFileSizeFromUri = async (uri: string): Promise<number> => {
-  try {
-    const response = await fetch(uri);
-    const blob = await response.blob();
-    return blob.size;
-  } catch (error) {
-    console.error('Error getting file size:', error);
-    return 0;
-  }
-};
-
-/**
- * Convert image to base64 string
- */
-const imageToBase64 = async (uri: string): Promise<string | null> => {
-  try {
-    const response = await fetch(uri);
-    const blob = await response.blob();
-    
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onloadend = () => {
-        try {
-          const base64data = reader.result as string;
-          // Remove the data:image/jpeg;base64, prefix
-          const base64 = base64data.split(',')[1];
-          resolve(base64);
-        } catch (error) {
-          reject(error);
-        }
-      };
-      reader.onerror = reject;
-      reader.readAsDataURL(blob);
-    });
-  } catch (error) {
-    console.error('Error converting image to base64:', error);
-    return null;
-  }
-};
-
-/**
- * Compress image with iterative quality reduction to meet size target
- */
-export const compressImageToTarget = async (
-  imageUri: string,
-  options: CompressionOptions = {}
-): Promise<CompressionResult> => {
-  const {
-    maxSizeKB = 300,
-    maxWidth = 1200,
-    maxHeight = 1200,
-    quality = 0.8,
-    format = 'JPEG'
-  } = options;
-
-  try {
-    console.log('🖼️ [COMPRESSION] Starting compression for:', imageUri);
-    
-    // Get original file size
-    const originalSize = await getFileSizeFromUri(imageUri);
-    const originalSizeKB = Math.round(originalSize / 1024);
-    
-    console.log('📊 [COMPRESSION] Original size:', originalSizeKB, 'KB');
-    
-    // If already under target, just convert to base64
-    if (originalSizeKB <= maxSizeKB) {
-      console.log('✅ [COMPRESSION] Image already under target size');
-      const base64 = await imageToBase64(imageUri);
-      
-      if (base64) {
-        return {
-          success: true,
-          base64,
-          sizeKB: originalSizeKB,
-          originalSizeKB,
-          compressionRatio: 1.0
-        };
-      }
-    }
-
-    // Start with initial compression parameters
-    let currentQuality = quality;
-    let currentWidth = maxWidth;
-    let currentHeight = maxHeight;
-    let attempts = 0;
-    const maxAttempts = 8;
-
-    while (attempts < maxAttempts) {
-      attempts++;
-      
-      console.log(`🔄 [COMPRESSION] Attempt ${attempts}: quality=${currentQuality}, size=${currentWidth}x${currentHeight}`);
-      
-      try {
-        // Resize and compress the image
-        const resizedImage = await ImageResizer.createResizedImage(
-          imageUri,
-          currentWidth,
-          currentHeight,
-          format,
-          Math.round(currentQuality * 100), // Convert to percentage
-          0, // rotation
-          undefined, // outputPath
-          false, // keepMeta
-          {
-            mode: 'contain', // Maintain aspect ratio
-            onlyScaleDown: true, // Don't upscale
-          }
-        );
-
-        // Check the size of the compressed image
-        const compressedSize = await getFileSizeFromUri(resizedImage.uri);
-        const compressedSizeKB = Math.round(compressedSize / 1024);
-        
-        console.log(`📊 [COMPRESSION] Attempt ${attempts} result: ${compressedSizeKB} KB`);
-
-        // If we've hit our target, convert to base64 and return
-        if (compressedSizeKB <= maxSizeKB) {
-          console.log('✅ [COMPRESSION] Target size achieved!');
-          
-          const base64 = await imageToBase64(resizedImage.uri);
-          
-          if (base64) {
-            const compressionRatio = originalSizeKB / compressedSizeKB;
-            
-            console.log('🎯 [COMPRESSION] Success:', {
-              originalSizeKB,
-              finalSizeKB: compressedSizeKB,
-              compressionRatio: compressionRatio.toFixed(2) + 'x',
-              attempts
-            });
-            
-            return {
-              success: true,
-              base64,
-              sizeKB: compressedSizeKB,
-              originalSizeKB,
-              compressionRatio
-            };
-          }
-        }
-
-        // If still too large, adjust parameters for next attempt
-        if (compressedSizeKB > maxSizeKB) {
-          // Reduce quality more aggressively if we're way over
-          const sizeRatio = compressedSizeKB / maxSizeKB;
-          
-          if (sizeRatio > 2.0) {
-            // Way too big - reduce quality and dimensions significantly
-            currentQuality *= 0.6;
-            currentWidth = Math.round(currentWidth * 0.8);
-            currentHeight = Math.round(currentHeight * 0.8);
-          } else if (sizeRatio > 1.5) {
-            // Moderately too big - reduce quality more
-            currentQuality *= 0.75;
-            currentWidth = Math.round(currentWidth * 0.9);
-            currentHeight = Math.round(currentHeight * 0.9);
-          } else {
-            // Close to target - fine-tune quality
-            currentQuality *= 0.85;
-          }
-          
-          // Ensure we don't go below minimum thresholds
-          currentQuality = Math.max(0.1, currentQuality);
-          currentWidth = Math.max(400, currentWidth);
-          currentHeight = Math.max(400, currentHeight);
-        }
-        
-      } catch (resizeError) {
-        console.error(`❌ [COMPRESSION] Resize attempt ${attempts} failed:`, resizeError);
-        
-        // Try with more aggressive settings
-        currentQuality *= 0.7;
-        currentWidth = Math.round(currentWidth * 0.8);
-        currentHeight = Math.round(currentHeight * 0.8);
-        
-        if (currentQuality < 0.1 || currentWidth < 200 || currentHeight < 200) {
-          break;
-        }
-      }
-    }
-
-    // If we've exhausted all attempts, return the best effort
-    console.log('⚠️ [COMPRESSION] Max attempts reached, using best effort');
-    
-    try {
-      const finalImage = await ImageResizer.createResizedImage(
-        imageUri,
-        Math.max(400, currentWidth),
-        Math.max(400, currentHeight),
-        format,
-        30, // Very low quality as last resort
-        0,
-        undefined,
-        false,
-        { mode: 'contain', onlyScaleDown: true }
-      );
-
-      const finalSize = await getFileSizeFromUri(finalImage.uri);
-      const finalSizeKB = Math.round(finalSize / 1024);
-      const base64 = await imageToBase64(finalImage.uri);
-
-      if (base64) {
-        console.log('📤 [COMPRESSION] Final result (best effort):', finalSizeKB, 'KB');
-        
-        return {
-          success: true,
-          base64,
-          sizeKB: finalSizeKB,
-          originalSizeKB,
-          compressionRatio: originalSizeKB / finalSizeKB
-        };
-      }
-    } catch (finalError) {
-      console.error('❌ [COMPRESSION] Final compression attempt failed:', finalError);
-    }
-
-    return {
-      success: false,
-      error: `Failed to compress image to ${maxSizeKB}KB after ${maxAttempts} attempts`,
-      originalSizeKB
-    };
-
-  } catch (error) {
-    console.error('❌ [COMPRESSION] Compression service error:', error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown compression error',
-      originalSizeKB: 0
-    };
-  }
-};
-
-/**
- * Quick compression for profile pictures (300KB target)
- */
-export const compressProfilePicture = async (imageUri: string): Promise<CompressionResult> => {
-  return compressImageToTarget(imageUri, {
-    maxSizeKB: 300,
-    maxWidth: 1200,
-    maxHeight: 1200,
-    quality: 0.8,
-    format: 'JPEG'
-  });
-};
-
-/**
- * Compress image for upload with custom settings
- */
-export const compressForUpload = async (
-  imageUri: string,
-  maxSizeKB: number = 300
-): Promise<CompressionResult> => {
-  return compressImageToTarget(imageUri, {
-    maxSizeKB,
-    maxWidth: 1200,
-    maxHeight: 1200,
-    quality: 0.8,
-    format: 'JPEG'
-  });
-};
-
-/**
- * Legacy function for backward compatibility
- */
-export const convertImageToOptimizedBase64 = async (
-  imageUri: string,
-  quality: number = 0.8
-): Promise<string | null> => {
-  const result = await compressImageToTarget(imageUri, {
-    maxSizeKB: 300,
-    quality,
-    format: 'JPEG'
-  });
-  
-  return result.success ? result.base64 || null : null;
+import ImageResizer from '@bam.tech/react-native-image-resizer';
+
+/**
+ * Comprehensive image compression service for React Native
+ * Supports iterative compression to meet specific size targets
+ */
+
+interface CompressionOptions {
+  maxSizeKB?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  quality?: number;
+  format?: 'JPEG' | 'PNG' | 'WEBP';
+}
+
+interface CompressionResult {
+  success: boolean;
+  base64?: string;
+  sizeKB?: number;
+  originalSizeKB?: number;
+  compressionRatio?: number;
+  error?: string;
+}
+
+/**
+ * Get file size from URI (React Native compatible)
+ */
+const getFileSizeFromUri = async (uri: string): Promise<number> => {
+  try {
+    const response = await fetch(uri);
+    const blob = await response.blob();
+    return blob.size;
+  } catch (error) {
+    console.error('Error getting file size:', error);
+    return 0;
+  }
+};
+
+/**
+ * Convert image to base64 string
+ */
+const imageToBase64 = async (uri: string): Promise<string | null> => {
+  try {
+    const response = await fetch(uri);
+    const blob = await response.blob();
+    
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        try {
+          const base64data = reader.result as string;
+          // Remove the data:image/jpeg;base64, prefix
+          const base64 = base64data.split(',')[1];
+          resolve(base64);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  } catch (error) {
+    console.error('Error converting image to base64:', error);
+    return null;
+  }
+};
+
+/**
+ * Compress image with iterative quality reduction to meet size target
+ */
+export const compressImageToTarget = async (
+  imageUri: string,
+  options: CompressionOptions = {}
+): Promise<CompressionResult> => {
+  const {
+    maxSizeKB = 300,
+    maxWidth = 1200,
+    maxHeight = 1200,
+    quality = 0.8,
+    format = 'JPEG'
+  } = options;
+
+  try {
+    console.log('🖼️ [COMPRESSION] Starting compression for:', imageUri);
+    
+    // Get original file size
+    const originalSize = await getFileSizeFromUri(imageUri);
+    const originalSizeKB = Math.round(originalSize / 1024);
+    
+    console.log('📊 [COMPRESSION] Original size:', originalSizeKB, 'KB');
+    
+    // If already under target, just convert to base64
+    if (originalSizeKB <= maxSizeKB) {
+      console.log('✅ [COMPRESSION] Image already under target size');
+      const base64 = await imageToBase64(imageUri);
+      
+      if (base64) {
+        return {
+          success: true,
+          base64,
+          sizeKB: originalSizeKB,
+          originalSizeKB,
+          compressionRatio: 1.0
+        };
+      }
+    }
+
+    // Start with initial compression parameters
+    let currentQuality = quality;
+    let currentWidth = maxWidth;
+    let currentHeight = maxHeight;
+    let attempts = 0;
+    const maxAttempts = 8;
+
+    while (attempts < maxAttempts) {
+      attempts++;
+      
+      console.log(`🔄 [COMPRESSION] Attempt ${attempts}: quality=${currentQuality}, size=${currentWidth}x${currentHeight}`);
+      
+      try {
+        // Resize and compress the image
+        const resizedImage = await ImageResizer.createResizedImage(
+          imageUri,
+          currentWidth,
+          currentHeight,
+          format,
+          Math.round(currentQuality * 100), // Convert to percentage
+          0, // rotation
+          undefined, // outputPath
+          false, // keepMeta
+          {
+            mode: 'contain', // Maintain aspect ratio
+            onlyScaleDown: true, // Don't upscale
+          }
+        );
+
+        // Check the size of the compressed image
+        const compressedSize = await getFileSizeFromUri(resizedImage.uri);
+        const compressedSizeKB = Math.round(compressedSize / 1024);
+        
+        console.log(`📊 [COMPRESSION] Attempt ${attempts} result: ${compressedSizeKB} KB`);
+
+        // If we've hit our target, convert to base64 and return
+        if (compressedSizeKB <= maxSizeKB) {
+          console.log('✅ [COMPRESSION] Target size achieved!');
+          
+          const base64 = await imageToBase64(resizedImage.uri);
+          
+          if (base64) {
+            const compressionRatio = originalSizeKB / compressedSizeKB;
+            
+            console.log('🎯 [COMPRESSION] Success:', {
+              originalSizeKB,
+              finalSizeKB: compressedSizeKB,
+              compressionRatio: compressionRatio.toFixed(2) + 'x',
+              attempts
+            });
+            
+            return {
+              success: true,
+              base64,
+              sizeKB: compressedSizeKB,
+              originalSizeKB,
+              compressionRatio
+            };
+          }
+        }
+
+        // If still too large, adjust parameters for next attempt
+        if (compressedSizeKB > maxSizeKB) {
+          // Reduce quality more aggressively if we're way over
+          const sizeRatio = compressedSizeKB / maxSizeKB;
+          
+          if (sizeRatio > 2.0) {
+            // Way too big - reduce quality and dimensions significantly
+            currentQuality *= 0.6;
+            currentWidth = Math.round(currentWidth * 0.8);
+            currentHeight = Math.round(currentHeight * 0.8);
+          } else if (sizeRatio > 1.5) {
+            // Moderately too big - reduce quality more
+            currentQuality *= 0.75;
+            currentWidth = Math.round(currentWidth * 0.9);
+            currentHeight = Math.round(currentHeight * 0.9);
+          } else {
+            // Close to target - fine-tune quality
+            currentQuality *= 0.85;
+          }
+          
+          // Ensure we don't go below minimum thresholds
+          currentQuality = Math.max(0.1, currentQuality);
+          currentWidth = Math.max(400, currentWidth);
+          currentHeight = Math.max(400, currentHeight);
+        }
+        
+      } catch (resizeError) {
+        console.error(`❌ [COMPRESSION] Resize attempt ${attempts} failed:`, resizeError);
+        
+        // Try with more aggressive settings
+        currentQuality *= 0.7;
+        currentWidth = Math.round(currentWidth * 0.8);
+        currentHeight = Math.round(currentHeight * 0.8);
+        
+        if (currentQuality < 0.1 || currentWidth < 200 || currentHeight < 200) {
+          break;
+        }
+      }
+    }
+
+    // If we've exhausted all attempts, return the best effort
+    console.log('⚠️ [COMPRESSION] Max attempts reached, using best effort');
+    
+    try {
+      const finalImage = await ImageResizer.createResizedImage(
+        imageUri,
+        Math.max(400, currentWidth),
+        Math.max(400, currentHeight),
+        format,
+        30, // Very low quality as last resort
+        0,
+        undefined,
+        false,
+        { mode: 'contain', onlyScaleDown: true }
+      );
+
+      const finalSize = await getFileSizeFromUri(finalImage.uri);
+      const finalSizeKB = Math.round(finalSize / 1024);
+      const base64 = await imageToBase64(finalImage.uri);
+
+      if (base64) {
+        console.log('📤 [COMPRESSION] Final result (best effort):', finalSizeKB, 'KB');
+        
+        return {
+          success: true,
+          base64,
+          sizeKB: finalSizeKB,
+          originalSizeKB,
+          compressionRatio: originalSizeKB / finalSizeKB
+        };
+      }
+    } catch (finalError) {
+      console.error('❌ [COMPRESSION] Final compression attempt failed:', finalError);
+    }
+
+    return {
+      success: false,
+      error: `Failed to compress image to ${maxSizeKB}KB after ${maxAttempts} attempts`,
+      originalSizeKB
+    };
+
+  } catch (error) {
+    console.error('❌ [COMPRESSION] Compression service error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown compression error',
+      originalSizeKB: 0
+    };
+  }
+};
+
+/**
+ * Quick compression for profile pictures (300KB target)
+ */
+export const compressProfilePicture = async (imageUri: string): Promise<CompressionResult> => {
+  return compressImageToTarget(imageUri, {
+    maxSizeKB: 300,
+    maxWidth: 1200,
+    maxHeight: 1200,
+    quality: 0.8,
+    format: 'JPEG'
+  });
+};
+
+/**
+ * Compress image for upload with custom settings
+ */
+export const compressForUpload = async (
+  imageUri: string,
+  maxSizeKB: number = 300
+): Promise<CompressionResult> => {
+  return compressImageToTarget(imageUri, {
+    maxSizeKB,
+    maxWidth: 1200,
+    maxHeight: 1200,
+    quality: 0.8,
+    format: 'JPEG'
+  });
+};
+
+/**
+ * Legacy function for backward compatibility
+ */
+export const convertImageToOptimizedBase64 = async (
+  imageUri: string,
+  quality: number = 0.8
+): Promise<string | null> => {
+  const result = await compressImageToTarget(imageUri, {
+    maxSizeKB: 300,
+    quality,
+    format: 'JPEG'
+  });
+  
+  return result.success ? result.base64 || null : null;
 };