react-native-compressor 1.18.1 → 1.19.0

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

@@ -9,6 +9,7 @@ import android.graphics.Paint
 import android.media.ExifInterface
 import android.net.Uri
 import android.util.Base64
+import android.util.Log
 import com.facebook.react.bridge.ReactApplicationContext
 import com.reactnativecompressor.Utils.MediaCache
 import com.reactnativecompressor.Utils.Utils.exifAttributes
@@ -21,6 +22,8 @@ import java.io.IOException
 import java.net.MalformedURLException
 
 object ImageCompressor {
+    private const val TAG = "ImageCompressor"
+
     fun getRNFileUrl(filePath: String?): String? {
         var filePath = filePath
         val returnAbleFile = File(filePath)
@@ -56,25 +59,38 @@ object ImageCompressor {
         return BitmapFactory.decodeFile(filePath)
     }
 
-    fun copyExifInfo(imagePath:String, outputUri:String){
-      try {
-        // for copy exif info
-        val sourceExif = ExifInterface(imagePath)
-        val compressedExif = ExifInterface(outputUri)
-        for (tag in exifAttributes) {
-          val compressedValue = compressedExif.getAttribute(tag)
-          if(compressedValue==null)
-          {
-            val sourceValue = sourceExif.getAttribute(tag)
-            if (sourceValue != null) {
-              compressedExif.setAttribute(tag, sourceValue)
+    /**
+     * Strip "file://" / "content://" scheme so legacy ExifInterface can open
+     * the underlying JPEG. ExifInterface(String) only accepts raw filesystem
+     * paths — passing a URI string makes it fail silently inside the
+     * try/catch and drops every EXIF tag, including GPS.
+     */
+    private fun normalizeToFilePath(input: String): String {
+        if (input.startsWith("file://") || input.startsWith("content://")) {
+            return Uri.parse(input).path ?: input
+        }
+        return input
+    }
+
+    fun copyExifInfo(imagePath: String, outputUri: String) {
+        try {
+            val sourcePath = normalizeToFilePath(imagePath)
+            val outPath = normalizeToFilePath(outputUri)
+            val sourceExif = ExifInterface(sourcePath)
+            val compressedExif = ExifInterface(outPath)
+            var copied = 0
+            for (tag in exifAttributes) {
+                val sourceValue = sourceExif.getAttribute(tag) ?: continue
+                if (compressedExif.getAttribute(tag) == null) {
+                    compressedExif.setAttribute(tag, sourceValue)
+                    copied++
+                }
             }
-          }
+            compressedExif.saveAttributes()
+            Log.i(TAG, "copyExifInfo copied $copied tags from $sourcePath -> $outPath")
+        } catch (e: Exception) {
+            Log.w(TAG, "copyExifInfo failed for $imagePath", e)
         }
-        compressedExif.saveAttributes()
-      } catch (e: Exception) {
-        e.printStackTrace()
-      }
     }
 
     fun encodeImage(imageDataByteArrayOutputStream: ByteArrayOutputStream, isBase64: Boolean, outputExtension: String?,imagePath: String?, reactContext: ReactApplicationContext?): String? {
@@ -84,10 +100,14 @@ object ImageCompressor {
         } else {
             val outputUri = generateCacheFilePath(outputExtension!!, reactContext!!)
             try {
-                val fos = FileOutputStream(outputUri)
-                imageDataByteArrayOutputStream.writeTo(fos)
+                // Close the stream before ExifInterface re-opens the file so
+                // the JPEG bytes are fully flushed; otherwise saveAttributes()
+                // may truncate the in-flight write.
+                FileOutputStream(outputUri).use { fos ->
+                    imageDataByteArrayOutputStream.writeTo(fos)
+                }
 
-              copyExifInfo(imagePath!!, outputUri)
+                copyExifInfo(imagePath!!, outputUri)
 
                 return getRNFileUrl(outputUri)
             } catch (e: Exception) {
@@ -113,16 +133,17 @@ object ImageCompressor {
 
     fun compress(image: Bitmap?, output: ImageCompressorOptions.OutputType, quality: Float,disablePngTransparency:Boolean): ByteArrayOutputStream {
       var stream = ByteArrayOutputStream()
+      val normalizedQuality = Math.round(100 * quality.coerceIn(0f, 1f))
       if (output === ImageCompressorOptions.OutputType.jpg)
       {
-        image!!.compress(CompressFormat.JPEG, Math.round(100 * quality), stream)
+        image!!.compress(CompressFormat.JPEG, normalizedQuality, stream)
       }
       else
       {
         var bitmap = image
         if(disablePngTransparency)
         {
-          image!!.compress(CompressFormat.JPEG, Math.round(100 * quality), stream)
+          image!!.compress(CompressFormat.JPEG, normalizedQuality, stream)
           val byteArray: ByteArray = stream.toByteArray()
           stream=ByteArrayOutputStream()
           bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.size)
@@ -261,7 +282,7 @@ object ImageCompressor {
         if (bitmap == null || imagePath == null) return bitmap
 
         return try {
-            val exif = ExifInterface(imagePath)
+            val exif = ExifInterface(normalizeToFilePath(imagePath))
             val orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
             val matrix = Matrix()
 

package/android/src/main/java/com/reactnativecompressor/Utils/createVideoThumbnail.kt

@@ -62,6 +62,7 @@ class CreateVideoThumbnailClass(private val reactContext: ReactApplicationContex
         }
 
         val headers: Map<String, String> = if (options.hasKey("headers")) options.getMap("headers")!!.toHashMap() as Map<String, String> else HashMap<String, String>()
+        val quality = if (options.hasKey("quality")) (options.getDouble("quality") * 100).toInt().coerceIn(0, 100) else DEFAULT_THUMBNAIL_QUALITY
         val fileName = if (TextUtils.isEmpty(cacheName)) "thumb-" + UUID.randomUUID().toString() else "$cacheName.$format"
         var fOut: OutputStream? = null
 
@@ -73,7 +74,7 @@ class CreateVideoThumbnailClass(private val reactContext: ReactApplicationContex
             fOut = FileOutputStream(file)
 
             // 100 means no compression, the lower you go, the stronger the compression
-            image.compress(Bitmap.CompressFormat.JPEG, 90, fOut)
+            image.compress(Bitmap.CompressFormat.JPEG, quality, fOut)
             fOut.flush()
             fOut.close()
 
@@ -96,6 +97,8 @@ class CreateVideoThumbnailClass(private val reactContext: ReactApplicationContex
     }
 
     companion object {
+        private const val DEFAULT_THUMBNAIL_QUALITY = 90
+
         // delete previously added files one by one untill requred space is available
         fun clearCache(cacheDir: String?,promise:Promise, reactContext: ReactApplicationContext) {
           val cacheDirectory=cacheDir?.takeIf { it.isNotEmpty() } ?:"/thumbnails"
@@ -134,29 +137,47 @@ class CreateVideoThumbnailClass(private val reactContext: ReactApplicationContex
         }
 
         private fun getBitmapAtTime(context: Context?, filePath: String?, time: Int, headers: Map<String, String>): Bitmap {
+            check(!filePath.isNullOrEmpty()) { "Video file path cannot be null or empty" }
             val retriever = MediaMetadataRetriever()
-            if (URLUtil.isFileUrl(filePath)) {
-                val decodedPath: String?
-                decodedPath = try {
-                    URLDecoder.decode(filePath, "UTF-8")
-                } catch (e: UnsupportedEncodingException) {
-                    filePath
-                }
-                retriever.setDataSource(decodedPath!!.replace("file://", ""))
-            } else if (filePath!!.contains("content://")) {
-                retriever.setDataSource(context, Uri.parse(filePath))
-            } else {
-                check(Build.VERSION.SDK_INT >= 14) { "Remote videos aren't supported on sdk_version < 14" }
-                retriever.setDataSource(filePath, headers)
-            }
-            val image = retriever.getFrameAtTime((time * 1000).toLong(), MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
             try {
-                retriever.release()
-            } catch (e: IOException) {
-                throw RuntimeException(e)
+                if (URLUtil.isFileUrl(filePath)) {
+                    val decodedPath: String? = try {
+                        URLDecoder.decode(filePath, "UTF-8")
+                    } catch (e: UnsupportedEncodingException) {
+                        filePath
+                    }
+                    retriever.setDataSource(decodedPath!!.replace("file://", ""))
+                } else if (filePath.contains("content://")) {
+                    retriever.setDataSource(context, Uri.parse(filePath))
+                } else {
+                    check(Build.VERSION.SDK_INT >= 14) { "Remote videos aren't supported on sdk_version < 14" }
+                    retriever.setDataSource(filePath, headers)
+                }
+
+                val requestedTimeUs = (time * 1000).toLong()
+                val frameAttempts = arrayOf(
+                    Pair(requestedTimeUs, MediaMetadataRetriever.OPTION_CLOSEST_SYNC),
+                    Pair(requestedTimeUs, MediaMetadataRetriever.OPTION_CLOSEST),
+                    Pair(1_000_000L, MediaMetadataRetriever.OPTION_CLOSEST_SYNC),
+                )
+                for ((timeUs, option) in frameAttempts) {
+                    val image = try {
+                        retriever.getFrameAtTime(timeUs, option)
+                    } catch (e: RuntimeException) {
+                        null
+                    }
+                    if (image != null) {
+                        return image
+                    }
+                }
+                error("Unable to extract video frame from file")
+            } finally {
+                try {
+                    retriever.release()
+                } catch (e: IOException) {
+                    // Ignore
+                }
             }
-            checkNotNull(image) { "File doesn't exist or not supported" }
-            return image
         }
     }
 }

package/android/src/main/java/com/reactnativecompressor/Video/AutoVideoCompression.kt

@@ -24,7 +24,7 @@ object AutoVideoCompression {
                 val actualHeight = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
                 val actualWidth = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
                 val bitrate = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_BITRATE)
-                val frameRate = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
+                val frameRate = VideoCompressorHelper.getSourceFrameRate(metaRetriever)
                 if (actualHeight <= 0 || actualWidth <= 0) {
                     promise.reject(Throwable("Failed to read the input video dimensions"))
                     return

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressionProfile.kt

@@ -12,7 +12,12 @@ data class VideoCompressionProfile(
 )
 
 object VideoCompressionProfileFactory {
+    // Fallback when the source frame rate cannot be detected.
     private const val DEFAULT_FRAME_RATE = 30
+    // Hard upper bound. 60 fps covers every modern phone capture (24/25/30/
+    // 50/60). Capping at 30 — the previous behaviour — silently halved 60
+    // fps recordings and made the output look choppy.
+    private const val MAX_FRAME_RATE = 60
 
     fun createAuto(
         sourceWidth: Int,
@@ -99,7 +104,7 @@ object VideoCompressionProfileFactory {
             return DEFAULT_FRAME_RATE
         }
 
-        return sourceFrameRate.coerceIn(1, DEFAULT_FRAME_RATE)
+        return sourceFrameRate.coerceIn(1, MAX_FRAME_RATE)
     }
 
     private fun estimateBitrate(
@@ -111,20 +116,25 @@ object VideoCompressionProfileFactory {
         targetHeight: Int,
         targetFrameRate: Int,
     ): Int {
+        // WhatsApp-style bitrate envelope. The previous floors/ceilings
+        // were ~2-3x larger and produced "compressed" outputs that were
+        // still 20-40 MB for short clips. These bands target ~1.5 Mbps at
+        // 720p, which matches WhatsApp's typical output size while keeping
+        // visual quality acceptable for chat playback.
         val targetLongSide = max(targetWidth, targetHeight)
         val floor = when {
-            targetLongSide >= 1920 -> 4_000_000
-            targetLongSide >= 1280 -> 2_200_000
-            targetLongSide >= 960 -> 1_600_000
-            targetLongSide >= 720 -> 1_200_000
-            else -> 850_000
+            targetLongSide >= 1920 -> 2_000_000
+            targetLongSide >= 1280 -> 1_200_000
+            targetLongSide >= 960 -> 900_000
+            targetLongSide >= 720 -> 700_000
+            else -> 500_000
         }
         val ceiling = when {
-            targetLongSide >= 1920 -> 8_000_000
-            targetLongSide >= 1280 -> 5_000_000
-            targetLongSide >= 960 -> 3_500_000
-            targetLongSide >= 720 -> 2_500_000
-            else -> 1_500_000
+            targetLongSide >= 1920 -> 3_500_000
+            targetLongSide >= 1280 -> 2_000_000
+            targetLongSide >= 960 -> 1_500_000
+            targetLongSide >= 720 -> 1_200_000
+            else -> 900_000
         }
 
         if (sourceBitrate <= 0) {