react-native-compressor 1.13.0 → 1.15.0

package/android/build.gradle

@@ -115,7 +115,7 @@ dependencies {
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
   implementation 'org.mp4parser:isoparser:1.9.56'
-  implementation 'com.github.banketree:AndroidLame-kotlin:v0.0.1'
+  implementation 'com.github.kaushik-naik:TAndroidLame:277c2ab4b0'
   implementation 'javazoom:jlayer:1.0.1'
 }
 

package/android/src/main/java/com/reactnativecompressor/Image/ImageCompressor.kt

@@ -133,11 +133,20 @@ object ImageCompressor {
     }
 
     fun manualCompressImage(imagePath: String?, options: ImageCompressorOptions, reactContext: ReactApplicationContext?): String? {
-        val image = if (options.input === ImageCompressorOptions.InputType.base64) decodeImage(imagePath) else loadImage(imagePath)
-        val resizedImage = resize(image, options.maxWidth, options.maxHeight)
-        val imageDataByteArrayOutputStream = compress(resizedImage, options.output, options.quality,options.disablePngTransparency)
-        val isBase64 = options.returnableOutputType === ImageCompressorOptions.ReturnableOutputType.base64
-        return encodeImage(imageDataByteArrayOutputStream, isBase64, options.output.toString(),imagePath, reactContext)
+      val image = if (options.input === ImageCompressorOptions.InputType.base64) decodeImage(imagePath) else loadImage(imagePath)
+      val resizedImage = resize(image, options.maxWidth, options.maxHeight)
+      val isBase64 = options.returnableOutputType === ImageCompressorOptions.ReturnableOutputType.base64
+      val uri = Uri.parse(imagePath)
+      val imagePathNew = uri.path
+      var scaledBitmap: Bitmap? = correctImageOrientation(resizedImage, imagePathNew)
+      val imageDataByteArrayOutputStream = compress(scaledBitmap, options.output, options.quality, options.disablePngTransparency)
+      val compressedImagePath = encodeImage(imageDataByteArrayOutputStream, isBase64, options.output.toString(), imagePath, reactContext)
+      if (isCompressedSizeLessThanActualFile(imagePath!!, compressedImagePath)) {
+          return compressedImagePath
+      } else {
+          MediaCache.deleteFile(compressedImagePath!!)
+          return slashifyFilePath(imagePath)
+      }
     }
 
   fun isCompressedSizeLessThanActualFile(sourceFileUrl: String,compressedFileUrl: String?): Boolean {
@@ -249,20 +258,45 @@ object ImageCompressor {
     }
 
     fun correctImageOrientation(bitmap: Bitmap?, imagePath: String?): Bitmap? {
+        if (bitmap == null || imagePath == null) return bitmap
+
         return try {
-            val exif = ExifInterface(imagePath!!)
+            val exif = ExifInterface(imagePath)
             val orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
             val matrix = Matrix()
+
             when (orientation) {
-                ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
-                ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
-                ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
-                else -> return bitmap // No rotation needed
+                ExifInterface.ORIENTATION_NORMAL -> return bitmap
+                ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> {
+                    matrix.setScale(-1f, 1f)
+                }
+                ExifInterface.ORIENTATION_ROTATE_180 -> {
+                    matrix.setRotate(180f)
+                }
+                ExifInterface.ORIENTATION_FLIP_VERTICAL -> {
+                    matrix.setScale(1f, -1f)
+                }
+                ExifInterface.ORIENTATION_TRANSPOSE -> {
+                    matrix.setRotate(90f)
+                    matrix.postScale(-1f, 1f)
+                }
+                ExifInterface.ORIENTATION_ROTATE_90 -> {
+                    matrix.setRotate(90f)
+                }
+                ExifInterface.ORIENTATION_TRANSVERSE -> {
+                    matrix.setRotate(-90f)
+                    matrix.postScale(-1f, 1f)
+                }
+                ExifInterface.ORIENTATION_ROTATE_270 -> {
+                    matrix.setRotate(-90f)
+                }
+                else -> return bitmap
             }
-            Bitmap.createBitmap(bitmap!!, 0, 0, bitmap.width, bitmap.height, matrix, true)
+
+            Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
         } catch (e: IOException) {
             e.printStackTrace()
-            bitmap // Return original bitmap if an error occurs
+            bitmap
         }
     }
 }

package/ios/Image/ImageMain.swift

@@ -28,23 +28,47 @@ class ImageMain {
     static func getImageMetaData(_ filePath: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
         let options = ImageCompressorOptions.fromDictionary([:])
         ImageCompressor.getAbsoluteImagePath(filePath, options: options) { ImagePath in
-            if ImagePath.hasPrefix("file://") {
-                let absoluteImagePath = URL(string: ImagePath)!.path
-                Utils.getFileSize(absoluteImagePath) { fileSize in
-                    let _extension = (absoluteImagePath as NSString).pathExtension
-                    let imageData = NSData(contentsOfFile: absoluteImagePath)!
-                    let imageSource = CGImageSourceCreateWithData(imageData, nil)!
-                    let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil)!
-                    let exif=imageProperties as NSDictionary
-                    let mutableExif = exif.mutableCopy() as! NSMutableDictionary
-                    if let fileSizeInt = Int(fileSize as! String) {
-                        mutableExif.setValue(fileSizeInt, forKey: "size")
-                        }
-                    mutableExif.setValue(_extension, forKey: "extension")
-                    resolve(mutableExif)
-                } reject: { code, message, error in
-                    reject(code, message, error)
+            guard ImagePath.hasPrefix("file://") else {
+                reject("INVALID_PATH", "Image path must start with file://", nil)
+                return
+            }
+            
+            guard let url = URL(string: ImagePath) else {
+                reject("INVALID_URL", "Failed to create URL from image path", nil)
+                return
+            }
+            
+            let absoluteImagePath = url.path
+            let fileURL = url as CFURL
+            
+            Utils.getFileSize(absoluteImagePath) { fileSize in
+                let _extension = (absoluteImagePath as NSString).pathExtension
+                
+                // Use CGImageSourceCreateWithURL to avoid loading entire file into memory (prevents OOM crashes for large images)
+                guard let imageSource = CGImageSourceCreateWithURL(fileURL, nil) else {
+                    reject("INVALID_IMAGE", "Failed to create image source from URL", nil)
+                    return
+                }
+                
+                guard let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) else {
+                    reject("NO_PROPERTIES", "Failed to get image properties", nil)
+                    return
+                }
+                
+                let exif = imageProperties as NSDictionary
+                guard let mutableExif = exif.mutableCopy() as? NSMutableDictionary else {
+                    reject("COPY_ERROR", "Failed to create mutable copy of image properties", nil)
+                    return
+                }
+                
+                if let fileSizeString = fileSize as? String, let fileSizeInt = Int(fileSizeString) {
+                    mutableExif.setValue(fileSizeInt, forKey: "size")
                 }
+                
+                mutableExif.setValue(_extension, forKey: "extension")
+                resolve(mutableExif)
+            } reject: { code, message, error in
+                reject(code, message, error)
             }
         }
     }

package/ios/Utils/Utils.swift

@@ -70,6 +70,8 @@ class Utils {
                    let fileSize = attrs[.size] as? UInt64 {
                     let fileSizeString = String(fileSize)
                     resolve(fileSizeString)
+                } else {
+                    reject("FILE_SIZE_ERROR", "Failed to get file size for path: \(filePath)", nil)
                 }
             }
         } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-compressor",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Compress Image, Video, and Audio same like Whatsapp & Auto/Manual Compression | Background Upload | Download File | Create Video Thumbnail",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",