react-native-compressor 1.19.0 → 2.0.0

package/android/CMakeLists.txt

@@ -0,0 +1,27 @@
+project(NitroCompressor)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME NitroCompressor)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define the C++ library and add all of our own sources.
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Add all files generated by Nitrogen (sources, headers, prefab links).
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroCompressor+autolinking.cmake)
+
+# Local includes
+include_directories(
+        "src/main/cpp"
+)
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android
+)

package/android/build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-   // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
   def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["Compressor_kotlinVersion"]
 
   repositories {
@@ -8,25 +8,21 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
+    classpath "com.android.tools.build:gradle:9.2.1"
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
-
-
-def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
-
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
+// Nitrogen: registers the generated Kotlin sources with this Gradle project.
+apply from: '../nitrogen/generated/android/NitroCompressor+autolinking.gradle'
 
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Compressor_" + name]
@@ -36,40 +32,62 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Compressor_" + name]).toInteger()
 }
 
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  if (major == 7 && minor >= 3) {
-    return true
-  }
-
-  return major >= 8
-}
-
 android {
-  if (supportsNamespace()) {
-    namespace "com.reactnativecompressor"
+  namespace "com.reactnativecompressor"
 
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  sourceSets {
+    main {
+      manifest.srcFile "src/main/AndroidManifestNew.xml"
     }
   }
 
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
-
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all -std=c++20"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters(*reactNativeArchitectures())
+      }
+    }
   }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
   buildFeatures {
-    buildConfig true
+    prefab true
   }
+
+  packagingOptions {
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libhermes-executor-debug.so",
+      "**/libhermes_executor.so",
+      "**/libreactnative.so",
+      "**/libreactnativejni.so",
+      "**/libturbomodulejsijni.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libjscexecutor.so"
+    ]
+  }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -81,22 +99,8 @@ android {
   }
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_11
-    targetCompatibility JavaVersion.VERSION_11
-  }
-
-  sourceSets {
-    main {
-      if (isNewArchitectureEnabled()) {
-        java.srcDirs += [
-          "src/newarch",
-          // This is needed to build Kotlin project with NewArch enabled
-          "${project.buildDir}/generated/source/codegen/java"
-        ]
-      } else {
-        java.srcDirs += ["src/oldarch"]
-      }
-    }
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
   }
 }
 
@@ -114,6 +118,8 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  // Nitro core (provided as a Gradle subproject by autolinking).
+  implementation project(":react-native-nitro-modules")
 
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
@@ -121,11 +127,3 @@ dependencies {
   implementation 'com.github.kaushik-naik:TAndroidLame:277c2ab4b0'
   implementation 'javazoom:jlayer:1.0.1'
 }
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Compressor"
-    codegenJavaPackageName = "com.reactnativecompressor"
-  }
-}

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Compressor_kotlinVersion=1.7.0
-Compressor_minSdkVersion=21
-Compressor_targetSdkVersion=31
-Compressor_compileSdkVersion=31
-Compressor_ndkversion=21.4.7075529
+Compressor_kotlinVersion=2.1.20
+Compressor_minSdkVersion=24
+Compressor_targetSdkVersion=36
+Compressor_compileSdkVersion=36
+Compressor_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifestNew.xml

@@ -1,2 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- activateBackgroundTask acquires a PARTIAL_WAKE_LOCK; declare it here so it
+         merges into consuming apps (otherwise wakeLock.acquire() throws SecurityException). -->
+    <uses-permission android:name="android.permission.WAKE_LOCK"/>
 </manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,8 @@
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+#include "NitroCompressorOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, [] { margelo::nitro::compressor::registerAllNatives(); });
+}

package/android/src/main/java/com/margelo/nitro/compressor/HybridCompressor.kt

@@ -0,0 +1,213 @@
+package com.margelo.nitro.compressor
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.AnyMap
+import com.margelo.nitro.core.Promise
+import com.reactnativecompressor.Audio.AudioMain
+import com.reactnativecompressor.Image.ImageMain
+import com.reactnativecompressor.NitroPromiseAdapter
+import com.reactnativecompressor.Utils.CreateVideoThumbnailClass
+import com.reactnativecompressor.Utils.Downloader
+import com.reactnativecompressor.Utils.EventEmitterHandler
+import com.reactnativecompressor.Utils.Uploader
+import com.reactnativecompressor.Utils.Utils
+import com.reactnativecompressor.Video.VideoMain
+import java.util.UUID
+import java.util.concurrent.Executors
+import com.facebook.react.bridge.Promise as RNPromise
+
+/**
+ * Nitro HybridObject implementation of the single `Compressor` native module.
+ *
+ * Thin binding layer: it converts Nitro's `AnyMap` options into the
+ * `ReadableMap` the existing domain code already consumes, bridges the Nitro
+ * `Promise` to the domain layer's `com.facebook.react.bridge.Promise` via
+ * [NitroPromiseAdapter], and registers progress callbacks (keyed by `uuid`)
+ * with [EventEmitterHandler]. All heavy logic stays in the domain classes,
+ * which run on a background executor so the JS thread is never blocked.
+ */
+class HybridCompressor : HybridCompressorSpec() {
+  private val reactContext
+    get() = NitroModules.applicationContext
+      ?: throw IllegalStateException("react-native-compressor: ReactApplicationContext is not available")
+
+  private val executor = Executors.newCachedThreadPool()
+
+  private val imageMain by lazy { ImageMain(reactContext) }
+  private val videoMain by lazy { VideoMain(reactContext) }
+  private val audioMain by lazy { AudioMain(reactContext) }
+  private val uploader by lazy { Uploader(reactContext) }
+  private val videoThumbnail by lazy { CreateVideoThumbnailClass(reactContext) }
+
+  // region Converters
+
+  private val toStringResult: (Any?) -> String = { it as? String ?: "" }
+
+  private val toAnyMapResult: (Any?) -> AnyMap = { value ->
+    val hashMap = (value as? ReadableMap)?.toHashMap() ?: HashMap()
+    AnyMap.fromMap(hashMap, true)
+  }
+
+  private val toThumbnailResult: (Any?) -> VideoThumbnailResult = { value ->
+    val map = value as ReadableMap
+    VideoThumbnailResult(
+      if (map.hasKey("path")) map.getString("path") ?: "" else "",
+      if (map.hasKey("size")) map.getDouble("size") else 0.0,
+      if (map.hasKey("mime")) map.getString("mime") ?: "" else "",
+      if (map.hasKey("width")) map.getDouble("width") else 0.0,
+      if (map.hasKey("height")) map.getDouble("height") else 0.0,
+    )
+  }
+
+  // endregion
+
+  // region Image
+
+  override fun image_compress(imagePath: String, optionMap: AnyMap, onDownloadProgress: ((progress: Double) -> Unit)?): Promise<String> {
+    val map = toWritableMap(optionMap)
+    // Remote-image download progress is keyed by `uuid` inside the Downloader. The JS
+    // layer no longer sends one (the callback is passed directly), so mint one here.
+    val uuid = if (map.hasKey("uuid")) map.getString("uuid") ?: UUID.randomUUID().toString() else UUID.randomUUID().toString()
+    map.putString("uuid", uuid)
+    EventEmitterHandler.registerDownloadProgress(uuid, onDownloadProgress)
+    return runOnExecutor(toStringResult, { EventEmitterHandler.unregister(uuid) }) { promise ->
+      imageMain.image_compress(imagePath, map, promise)
+    }
+  }
+
+  override fun getImageMetaData(filePath: String): Promise<AnyMap> {
+    return runOnExecutor(toAnyMapResult) { promise -> imageMain.getImageMetaData(filePath, promise) }
+  }
+
+  // endregion
+
+  // region Video
+
+  override fun compress(
+    fileUrl: String,
+    optionMap: AnyMap,
+    onProgress: ((progress: Double) -> Unit)?,
+    onDownloadProgress: ((progress: Double) -> Unit)?,
+  ): Promise<String> {
+    val map = toWritableMap(optionMap)
+    val uuid = if (map.hasKey("uuid")) map.getString("uuid") ?: "" else ""
+    EventEmitterHandler.registerVideoCompressProgress(uuid, onProgress)
+    EventEmitterHandler.registerDownloadProgress(uuid, onDownloadProgress)
+    return runOnExecutor(toStringResult, { EventEmitterHandler.unregister(uuid) }) { promise ->
+      videoMain.compress(fileUrl, map, promise)
+    }
+  }
+
+  override fun cancelCompression(uuid: String) {
+    videoMain.cancelCompression(uuid)
+  }
+
+  override fun getVideoMetaData(filePath: String): Promise<AnyMap> {
+    return runOnExecutor(toAnyMapResult) { promise -> videoMain.getVideoMetaData(filePath, promise) }
+  }
+
+  override fun activateBackgroundTask(options: AnyMap, onExpired: (() -> Unit)?): Promise<String> {
+    EventEmitterHandler.setBackgroundTaskExpiredCallback(onExpired)
+    val map = toWritableMap(options)
+    return runOnExecutor(toStringResult) { promise -> videoMain.activateBackgroundTask(map, promise) }
+  }
+
+  override fun deactivateBackgroundTask(options: AnyMap): Promise<String> {
+    EventEmitterHandler.setBackgroundTaskExpiredCallback(null)
+    val map = toWritableMap(options)
+    return runOnExecutor(toStringResult) { promise -> videoMain.deactivateBackgroundTask(map, promise) }
+  }
+
+  // endregion
+
+  // region Audio
+
+  override fun compress_audio(fileUrl: String, optionMap: AnyMap): Promise<String> {
+    val map = toWritableMap(optionMap)
+    return runOnExecutor(toStringResult) { promise -> audioMain.compress_audio(fileUrl, map, promise) }
+  }
+
+  // endregion
+
+  // region Upload / Download
+
+  override fun upload(fileUrl: String, options: AnyMap, onProgress: ((written: Double, total: Double) -> Unit)?): Promise<AnyMap> {
+    val map = toWritableMap(options)
+    val uuid = if (map.hasKey("uuid")) map.getString("uuid") ?: "" else ""
+    EventEmitterHandler.registerUploadProgress(uuid, onProgress)
+    return runOnExecutor(toAnyMapResult, { EventEmitterHandler.unregister(uuid) }) { promise ->
+      uploader.upload(fileUrl, map, reactContext, promise)
+    }
+  }
+
+  override fun cancelUpload(uuid: String, shouldCancelAll: Boolean) {
+    uploader.cancelUpload(uuid, shouldCancelAll)
+  }
+
+  override fun download(fileUrl: String, options: AnyMap, onProgress: ((progress: Double) -> Unit)?): Promise<String> {
+    val uuid = if (options.contains("uuid") && options.isString("uuid")) options.getString("uuid") else ""
+    val progressDivider = if (options.contains("progressDivider") && options.isDouble("progressDivider")) options.getDouble("progressDivider").toInt() else 0
+    EventEmitterHandler.registerDownloadProgress(uuid, onProgress)
+    return runOnExecutor(toStringResult, { EventEmitterHandler.unregister(uuid) }) { promise ->
+      val downloadedFilePath = Downloader.downloadMediaWithProgress(fileUrl, uuid, progressDivider, reactContext)
+      if (downloadedFilePath != null) promise.resolve(downloadedFilePath) else promise.reject("Unable to download", "Unable to download")
+    }
+  }
+
+  // endregion
+
+  // region Others
+
+  override fun generateFilePath(fileExtension: String): Promise<String> {
+    return runOnExecutor(toStringResult) { promise -> promise.resolve(Utils.generateCacheFilePath(fileExtension, reactContext)) }
+  }
+
+  override fun getRealPath(path: String, type: String): Promise<String> {
+    // Utils.getRealPath already returns a `file://`-prefixed path via slashifyFilePath,
+    // so it must not be prefixed again (that produced a malformed `file://file:///…`).
+    return runOnExecutor(toStringResult) { promise -> promise.resolve(Utils.getRealPath(path, reactContext)) }
+  }
+
+  override fun getFileSize(filePath: String): Promise<String> {
+    return runOnExecutor(toStringResult) { promise -> Utils.getFileSize(filePath, promise, reactContext) }
+  }
+
+  override fun createVideoThumbnail(fileUrl: String, options: AnyMap): Promise<VideoThumbnailResult> {
+    val map = toWritableMap(options)
+    return runOnExecutor(toThumbnailResult) { promise -> videoThumbnail.create(fileUrl, map, promise) }
+  }
+
+  override fun clearCache(cacheDir: String?): Promise<String> {
+    return runOnExecutor(toStringResult) { promise -> CreateVideoThumbnailClass.clearCache(cacheDir, promise, reactContext) }
+  }
+
+  // endregion
+
+  // region Helpers
+
+  /** Convert a Nitro [AnyMap] to a React Native [WritableMap] that the domain parsers consume. */
+  private fun toWritableMap(map: AnyMap): WritableMap = Arguments.makeNativeMap(map.toHashMap())
+
+  /**
+   * Runs [block] on a background thread, handing it a bridge [RNPromise] that
+   * resolves/rejects the returned Nitro [Promise]. Synchronous throws are routed
+   * to the same adapter so the Promise is never double-settled.
+   */
+  private fun <T> runOnExecutor(convert: (Any?) -> T, onSettle: () -> Unit = {}, block: (RNPromise) -> Unit): Promise<T> {
+    val promise = Promise<T>()
+    val adapter = NitroPromiseAdapter(promise, convert, onSettle)
+    executor.execute {
+      try {
+        block(adapter)
+      } catch (e: Throwable) {
+        adapter.reject(e)
+      }
+    }
+    return promise
+  }
+
+  // endregion
+}

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

@@ -0,0 +1,30 @@
+package com.reactnativecompressor
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.margelo.nitro.compressor.NitroCompressorOnLoad
+
+/**
+ * Empty React package whose sole jobs are:
+ * 1. Make this library discoverable by React Native autolinking (which keys off a
+ *    `ReactPackage`), so the Gradle project + native `.so` get wired into the app.
+ * 2. Load the Nitro C++ library (`libNitroCompressor.so`) on first class-load so the
+ *    `Compressor` HybridObject is registered. The module itself is served by Nitro,
+ *    not by `getModule`, so no native modules are returned here.
+ *
+ * Lives in the `com.reactnativecompressor` namespace (not `com.margelo.nitro.compressor`)
+ * because the React Native CLI derives the autolink import path from the Android namespace.
+ */
+class NitroCompressorPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+  companion object {
+    init {
+      NitroCompressorOnLoad.initializeNative()
+    }
+  }
+}

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

@@ -0,0 +1,55 @@
+package com.reactnativecompressor
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.WritableMap
+import java.util.concurrent.atomic.AtomicBoolean
+import com.margelo.nitro.core.Promise as NitroPromise
+
+/**
+ * Adapts the React Native bridge [Promise] to a Nitro [NitroPromise] so the existing
+ * domain methods — which speak the bridge `Promise` contract (`resolve`/`reject`) — can
+ * drive a Nitro Promise unchanged.
+ *
+ * [convert] maps the resolved bridge value to the Nitro result type [T];
+ * [onSettle] runs once on resolve/reject (used to unregister progress callbacks).
+ */
+class NitroPromiseAdapter<T>(
+  private val promise: NitroPromise<T>,
+  private val convert: (Any?) -> T,
+  private val onSettle: () -> Unit = {},
+) : Promise {
+  private val settled = AtomicBoolean(false)
+
+  override fun resolve(value: Any?) {
+    if (!settled.compareAndSet(false, true)) return
+    onSettle()
+    promise.resolve(convert(value))
+  }
+
+  private fun rejectInternal(message: String?, throwable: Throwable?) {
+    if (!settled.compareAndSet(false, true)) return
+    onSettle()
+    promise.reject(throwable ?: Throwable(message ?: "react-native-compressor error"))
+  }
+
+  override fun reject(code: String?, message: String?) = rejectInternal(message ?: code, null)
+
+  override fun reject(code: String?, throwable: Throwable?) = rejectInternal(code, throwable)
+
+  override fun reject(code: String?, message: String?, throwable: Throwable?) = rejectInternal(message ?: code, throwable)
+
+  override fun reject(throwable: Throwable) = rejectInternal(throwable.message, throwable)
+
+  override fun reject(throwable: Throwable, userInfo: WritableMap) = rejectInternal(throwable.message, throwable)
+
+  override fun reject(code: String?, userInfo: WritableMap) = rejectInternal(code, null)
+
+  override fun reject(code: String?, throwable: Throwable?, userInfo: WritableMap) = rejectInternal(code, throwable)
+
+  override fun reject(code: String?, message: String?, userInfo: WritableMap) = rejectInternal(message ?: code, null)
+
+  override fun reject(code: String?, message: String?, throwable: Throwable?, userInfo: WritableMap?) = rejectInternal(message ?: code, throwable)
+
+  @Deprecated("Prefer passing a module-specific error code to JS.", ReplaceWith("reject(code, message)"))
+  override fun reject(message: String) = rejectInternal(message, null)
+}

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")
       }
     }
   }