react-native-compressor 1.18.2 → 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/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) {
@@ -262,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/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)
+}