react-native-compressor 1.18.2 → 2.0.0

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

@@ -1,66 +1,70 @@
 package com.reactnativecompressor.Utils
 
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.concurrent.ConcurrentHashMap
 
+/**
+ * Routes native progress emissions to the per-call JS callbacks that
+ * `HybridCompressor` registers. This replaces the old `RCTDeviceEventEmitter`
+ * bridge: Nitro delivers progress through callback parameters, so the domain
+ * layer's `emit*` calls (unchanged) are dispatched to the callback registered
+ * under the same `uuid` that the JS layer threads through the options map.
+ */
 class EventEmitterHandler {
   companion object {
-    public var reactContext: ReactApplicationContext?=null
+    private val videoCompressProgressCallbacks = ConcurrentHashMap<String, (Double) -> Unit>()
+    private val downloadProgressCallbacks = ConcurrentHashMap<String, (Double) -> Unit>()
+    private val uploadProgressCallbacks = ConcurrentHashMap<String, (Double, Double) -> Unit>()
 
-    private fun sendEvent(eventName: String,
-                          params: Any?) {
-      reactContext
-        ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-        ?.emit(eventName, params)
+    @Volatile
+    private var backgroundTaskExpiredCallback: (() -> Unit)? = null
+
+    // Registration (called by HybridCompressor)
+
+    fun registerVideoCompressProgress(uuid: String, callback: ((Double) -> Unit)?) {
+      if (callback != null) videoCompressProgressCallbacks[uuid] = callback
     }
 
-    fun emitBackgroundTaskExpired(backgroundId: String?){
-      sendEvent("backgroundTaskExpired",backgroundId)
+    fun registerDownloadProgress(uuid: String, callback: ((Double) -> Unit)?) {
+      if (callback != null) downloadProgressCallbacks[uuid] = callback
     }
 
-    fun emitVideoCompressProgress(progress:Double,uuid:String){
-      val params = Arguments.createMap()
-      val data = Arguments.createMap()
-      params.putString("uuid", uuid)
-      data.putDouble("progress", progress)
-      params.putMap("data", data)
-      sendEvent("videoCompressProgress", params)
+    fun registerUploadProgress(uuid: String, callback: ((Double, Double) -> Unit)?) {
+      if (callback != null) uploadProgressCallbacks[uuid] = callback
     }
 
-    fun emitDownloadProgress(progress:Double,uuid:String){
-      val params = Arguments.createMap()
-      val data = Arguments.createMap()
-      params.putString("uuid", uuid)
-      data.putDouble("progress", progress)
-      params.putMap("data", data)
-      sendEvent("downloadProgress", params)
+    fun unregister(uuid: String) {
+      videoCompressProgressCallbacks.remove(uuid)
+      downloadProgressCallbacks.remove(uuid)
+      uploadProgressCallbacks.remove(uuid)
     }
 
-    fun emitDownloadProgressError(uuid:String?, error:String?){
-      if (uuid != null && error != null) {
-        val params = Arguments.createMap()
-        val data = Arguments.createMap()
-        params.putString("uuid", uuid)
-        params.putString("error", error)
-        params.putMap("data", data)
-        sendEvent("downloadProgressError", params)
-      }
+    fun setBackgroundTaskExpiredCallback(callback: (() -> Unit)?) {
+      backgroundTaskExpiredCallback = callback
     }
 
-    fun sendUploadProgressEvent(numBytes: Long, totalBytes: Long, uuid:String?) {
-      if(uuid!=null) {
-        val _params = Arguments.createMap()
-        val _data = Arguments.createMap()
-        _params.putString("uuid", uuid)
-        _data.putDouble("written", numBytes.toDouble())
-        _data.putDouble("total", totalBytes.toDouble())
-        _params.putMap("data", _data)
-        sendEvent("uploadProgress", _params)
-      }
+    // Emission (called by the domain layer — method names preserved)
+
+    fun emitBackgroundTaskExpired(backgroundId: String?) {
+      backgroundTaskExpiredCallback?.invoke()
     }
 
+    fun emitVideoCompressProgress(progress: Double, uuid: String) {
+      videoCompressProgressCallbacks[uuid]?.invoke(progress)
+    }
 
-  }
+    fun emitDownloadProgress(progress: Double, uuid: String) {
+      downloadProgressCallbacks[uuid]?.invoke(progress)
+    }
+
+    fun emitDownloadProgressError(uuid: String?, error: String?) {
+      // No JS consumer for `downloadProgressError`; download failures surface
+      // through the rejected Promise instead. Kept so domain call sites compile.
+    }
 
+    fun sendUploadProgressEvent(numBytes: Long, totalBytes: Long, uuid: String?) {
+      if (uuid != null) {
+        uploadProgressCallbacks[uuid]?.invoke(numBytes.toDouble(), totalBytes.toDouble())
+      }
+    }
+  }
 }

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

@@ -134,7 +134,7 @@ object Utils {
       if (fileSize >= 0) {
         promise.resolve(fileSize.toString())
       } else {
-        promise.resolve("")
+        promise.reject("FILE_SIZE_ERROR", "Failed to get file size for path: $filePath")
       }
     }
   }

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) {