react-native-compressor 1.19.2 → 2.0.1

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.java

@@ -0,0 +1,105 @@
+package com.reactnativecompressor;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.WritableMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+
+/**
+ * Adapts the React Native bridge {@link Promise} to a Nitro
+ * {@link com.margelo.nitro.core.Promise} so the existing domain methods — which speak the bridge
+ * {@code Promise} contract ({@code resolve}/{@code reject}) — can drive a Nitro Promise unchanged.
+ *
+ * <p>{@code convert} maps the resolved bridge value to the Nitro result type {@code T};
+ * {@code onSettle} runs once on resolve/reject (used to unregister progress callbacks).
+ *
+ * <p>This is intentionally written in Java rather than Kotlin: the bridge {@code Promise} interface
+ * declares {@code code} as non-null ({@code String}) on some React Native versions and nullable
+ * ({@code String?}) on others. Kotlin override parameter types are invariant, so a single Kotlin
+ * source can only match one of those. Java erases nullability for override matching, so one Java
+ * implementation satisfies every React Native version.
+ */
+public class NitroPromiseAdapter<T> implements Promise {
+  private final com.margelo.nitro.core.Promise<T> promise;
+  private final Function1<Object, T> convert;
+  private final Function0<Unit> onSettle;
+  private final AtomicBoolean settled = new AtomicBoolean(false);
+
+  public NitroPromiseAdapter(
+      com.margelo.nitro.core.Promise<T> promise,
+      Function1<Object, T> convert,
+      Function0<Unit> onSettle) {
+    this.promise = promise;
+    this.convert = convert;
+    this.onSettle = onSettle;
+  }
+
+  @Override
+  public void resolve(Object value) {
+    if (!settled.compareAndSet(false, true)) return;
+    onSettle.invoke();
+    promise.resolve(convert.invoke(value));
+  }
+
+  private void rejectInternal(String message, Throwable throwable) {
+    if (!settled.compareAndSet(false, true)) return;
+    onSettle.invoke();
+    promise.reject(
+        throwable != null
+            ? throwable
+            : new Throwable(message != null ? message : "react-native-compressor error"));
+  }
+
+  @Override
+  public void reject(String code, String message) {
+    rejectInternal(message != null ? message : code, null);
+  }
+
+  @Override
+  public void reject(String code, Throwable throwable) {
+    rejectInternal(code, throwable);
+  }
+
+  @Override
+  public void reject(String code, String message, Throwable throwable) {
+    rejectInternal(message != null ? message : code, throwable);
+  }
+
+  @Override
+  public void reject(Throwable throwable) {
+    rejectInternal(throwable.getMessage(), throwable);
+  }
+
+  @Override
+  public void reject(Throwable throwable, WritableMap userInfo) {
+    rejectInternal(throwable.getMessage(), throwable);
+  }
+
+  @Override
+  public void reject(String code, WritableMap userInfo) {
+    rejectInternal(code, null);
+  }
+
+  @Override
+  public void reject(String code, Throwable throwable, WritableMap userInfo) {
+    rejectInternal(code, throwable);
+  }
+
+  @Override
+  public void reject(String code, String message, WritableMap userInfo) {
+    rejectInternal(message != null ? message : code, null);
+  }
+
+  @Override
+  public void reject(String code, String message, Throwable throwable, WritableMap userInfo) {
+    rejectInternal(message != null ? message : code, throwable);
+  }
+
+  @Deprecated
+  @Override
+  public void reject(String message) {
+    rejectInternal(message, null);
+  }
+}