react-native-capture-studio 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 varun-gandhi-digiqc
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# react-native-capture-studio
+
+Cross-platform native image compression and watermarking for React Native.
+
+## Features
+
+- **Background Processing** - Images processed off the main thread
+- **WebP Compression** - Better quality at smaller file sizes than JPEG
+- **Auto Watermark** - Adds timestamp text at bottom-right corner
+- **Target Size** - Compresses to 300-500KB with highest possible quality
+- **In-place Replace** - Overwrites original file (path stays the same)
+- **Cross Platform** - Works on both iOS and Android
+
+## Installation
+
+```bash
+yarn add git+https://github.com/gandhi120/react-native-capture-studio.git
+```
+
+### iOS Setup
+
+```bash
+cd ios && pod install && cd ..
+```
+
+**Requires iOS 15.1+**
+
+### Android Setup
+
+No additional setup required.
+
+**Requires Android 11+ (API 30)**
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { processImages, fetchProcessingResult } from 'react-native-capture-studio';
+
+const compressImage = async (imagePath: string) => {
+  const operationId = await processImages([
+    {
+      localPath: imagePath,
+      timeStamp: new Date().toLocaleString(),
+      isForOnlyWatermark: false,
+      compressJpegImage: false,
+      replaceOriginal: true,
+    }
+  ]);
+
+  const poll = async () => {
+    const result = JSON.parse(await fetchProcessingResult(operationId));
+
+    if (result.status === 'completed') {
+      console.log('Done!', result.processedImages);
+    } else {
+      setTimeout(poll, 500);
+    }
+  };
+
+  poll();
+};
+```
+
+### Multiple Images
+
+```typescript
+const compressMultipleImages = async (imagePaths: string[]) => {
+  const images = imagePaths.map(path => ({
+    localPath: path,
+    timeStamp: new Date().toLocaleString(),
+    isForOnlyWatermark: false,
+    compressJpegImage: false,
+    replaceOriginal: true,
+  }));
+
+  const operationId = await processImages(images);
+
+  // Poll for result...
+};
+```
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,139 @@
+buildscript {
+  // 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["CaptureStudio_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.3"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["CaptureStudio_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["CaptureStudio_" + 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
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.capturestudio"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion 29
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+          java.srcDirs += [
+            "generated/java",
+            "generated/jni"
+          ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  // Lifecycle and viewModel
+  implementation "androidx.activity:activity-ktx:1.9.0"
+  implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.4"
+  implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.8.4"
+
+  // CameraX
+  implementation "androidx.camera:camera-core:1.3.4"
+  implementation "androidx.camera:camera-camera2:1.3.4"
+  implementation "androidx.camera:camera-lifecycle:1.3.4"
+  implementation "androidx.camera:camera-view:1.3.4"
+
+  // WorkManager for background image processing
+  implementation "androidx.work:work-runtime-ktx:2.9.0"
+
+  // ExifInterface for image orientation
+  implementation "androidx.exifinterface:exifinterface:1.3.7"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "CaptureStudio"
+    codegenJavaPackageName = "com.capturestudio"
+  }
+}

package/android/generated/java/com/capturestudio/NativeCaptureStudioSpec.java

@@ -0,0 +1,48 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.capturestudio;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeCaptureStudioSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "CaptureStudio";
+
+  public NativeCaptureStudioSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void openCaptureStudio(ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void processImages(ReadableArray images, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void fetchProcessingResult(String operationId, Promise promise);
+}

package/android/generated/jni/CMakeLists.txt

@@ -0,0 +1,31 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB react_codegen_SRCS CONFIGURE_DEPENDS *.cpp react/renderer/components/RNCaptureStudioSpec/*.cpp)
+
+add_library(
+  react_codegen_RNCaptureStudioSpec
+  OBJECT
+  ${react_codegen_SRCS}
+)
+
+target_include_directories(react_codegen_RNCaptureStudioSpec PUBLIC . react/renderer/components/RNCaptureStudioSpec)
+
+target_link_libraries(
+  react_codegen_RNCaptureStudioSpec
+  fbjni
+  jsi
+  # We need to link different libraries based on whether we are building rncore or not, that's necessary
+  # because we want to break a circular dependency between react_codegen_rncore and reactnative
+  reactnative
+)
+
+# Only call if the function exists (added in RN 0.79+)
+if(COMMAND target_compile_reactnative_options)
+  target_compile_reactnative_options(react_codegen_RNCaptureStudioSpec PRIVATE)
+endif()

package/android/generated/jni/RNCaptureStudioSpec-generated.cpp

@@ -0,0 +1,44 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniCpp.js
+ */
+
+#include "RNCaptureStudioSpec.h"
+
+namespace facebook::react {
+
+static facebook::jsi::Value __hostFunction_NativeCaptureStudioSpecJSI_openCaptureStudio(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "openCaptureStudio", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeCaptureStudioSpecJSI_processImages(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "processImages", "(Lcom/facebook/react/bridge/ReadableArray;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeCaptureStudioSpecJSI_fetchProcessingResult(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "fetchProcessingResult", "(Ljava/lang/String;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+NativeCaptureStudioSpecJSI::NativeCaptureStudioSpecJSI(const JavaTurboModule::InitParams &params)
+  : JavaTurboModule(params) {
+  methodMap_["openCaptureStudio"] = MethodMetadata {1, __hostFunction_NativeCaptureStudioSpecJSI_openCaptureStudio};
+  methodMap_["processImages"] = MethodMetadata {1, __hostFunction_NativeCaptureStudioSpecJSI_processImages};
+  methodMap_["fetchProcessingResult"] = MethodMetadata {1, __hostFunction_NativeCaptureStudioSpecJSI_fetchProcessingResult};
+}
+
+std::shared_ptr<TurboModule> RNCaptureStudioSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+  if (moduleName == "CaptureStudio") {
+    return std::make_shared<NativeCaptureStudioSpecJSI>(params);
+  }
+  return nullptr;
+}
+
+} // namespace facebook::react

package/android/generated/jni/RNCaptureStudioSpec.h

@@ -0,0 +1,31 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+/**
+ * JNI C++ class for module 'NativeCaptureStudio'
+ */
+class JSI_EXPORT NativeCaptureStudioSpecJSI : public JavaTurboModule {
+public:
+  NativeCaptureStudioSpecJSI(const JavaTurboModule::InitParams &params);
+};
+
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> RNCaptureStudioSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNCaptureStudioSpec/RNCaptureStudioSpecJSI.h

@@ -0,0 +1,56 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+template <typename T>
+class JSI_EXPORT NativeCaptureStudioCxxSpec : public TurboModule {
+public:
+  static constexpr std::string_view kModuleName = "CaptureStudio";
+
+protected:
+  NativeCaptureStudioCxxSpec(std::shared_ptr<CallInvoker> jsInvoker) : TurboModule(std::string{NativeCaptureStudioCxxSpec::kModuleName}, jsInvoker) {
+    methodMap_["openCaptureStudio"] = MethodMetadata {.argCount = 1, .invoker = __openCaptureStudio};
+    methodMap_["processImages"] = MethodMetadata {.argCount = 1, .invoker = __processImages};
+    methodMap_["fetchProcessingResult"] = MethodMetadata {.argCount = 1, .invoker = __fetchProcessingResult};
+  }
+  
+private:
+  static jsi::Value __openCaptureStudio(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::openCaptureStudio) == 2,
+      "Expected openCaptureStudio(...) to have 2 parameters");
+    return bridging::callFromJs<jsi::Value>(rt, &T::openCaptureStudio,  static_cast<NativeCaptureStudioCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt));
+  }
+
+  static jsi::Value __processImages(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::processImages) == 2,
+      "Expected processImages(...) to have 2 parameters");
+    return bridging::callFromJs<jsi::Value>(rt, &T::processImages,  static_cast<NativeCaptureStudioCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt).asArray(rt));
+  }
+
+  static jsi::Value __fetchProcessingResult(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::fetchProcessingResult) == 2,
+      "Expected fetchProcessingResult(...) to have 2 parameters");
+    return bridging::callFromJs<jsi::Value>(rt, &T::fetchProcessingResult,  static_cast<NativeCaptureStudioCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt));
+  }
+};
+
+} // namespace facebook::react

package/android/gradle.properties

@@ -0,0 +1,5 @@
+CaptureStudio_kotlinVersion=1.7.0
+CaptureStudio_minSdkVersion=21
+CaptureStudio_targetSdkVersion=31
+CaptureStudio_compileSdkVersion=31
+CaptureStudio_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.capturestudio">
+
+    <uses-permission android:name="android.permission.CAMERA" />
+
+    <application>
+        <activity
+            android:name="com.capturestudio.ui.camera.CameraActivity"
+            android:exported="false"
+            android:theme="@style/Theme.AppCompat.NoActionBar" />
+    </application>
+
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/capturestudio/CaptureStudioModule.kt

@@ -0,0 +1,177 @@
+package com.capturestudio
+
+import android.content.Intent
+import android.util.Log
+import androidx.work.Data
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import com.capturestudio.data.processing.ImageProcessingWorker
+import com.capturestudio.ui.camera.CameraActivity
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+import java.util.concurrent.ExecutionException
+
+@ReactModule(name = CaptureStudioModule.NAME)
+class CaptureStudioModule(reactContext: ReactApplicationContext) :
+    NativeCaptureStudioSpec(reactContext) {
+
+    companion object {
+        const val NAME = "CaptureStudio"
+        private const val TAG = "CaptureStudioModule"
+    }
+
+    override fun getName(): String = NAME
+
+    /**
+     * Open the native camera capture UI.
+     */
+    override fun openCaptureStudio(options: ReadableMap, promise: Promise) {
+        val intent = Intent(reactApplicationContext, CameraActivity::class.java)
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        reactApplicationContext.startActivity(intent)
+        promise.resolve(null)
+    }
+
+    /**
+     * Process images with compression and watermarking.
+     * Returns immediately with an operation ID to poll for results.
+     *
+     * @param images Array of image processing items
+     * @param promise Resolves with operation ID (UUID string)
+     */
+    override fun processImages(images: ReadableArray, promise: Promise) {
+        try {
+            // Convert ReadableArray to JSON string
+            val imagesJson = convertArrayToJson(images)
+            Log.d(TAG, "Processing ${images.size()} images")
+
+            // Create input data for worker
+            val inputData = Data.Builder()
+                .putString(ImageProcessingWorker.KEY_IMAGES, imagesJson)
+                .build()
+
+            // Create and enqueue work request
+            val workRequest = OneTimeWorkRequestBuilder<ImageProcessingWorker>()
+                .setInputData(inputData)
+                .build()
+
+            WorkManager.getInstance(reactApplicationContext)
+                .enqueue(workRequest)
+
+            // Return the work ID for polling
+            val operationId = workRequest.id.toString()
+            Log.d(TAG, "Enqueued work with ID: $operationId")
+            promise.resolve(operationId)
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to enqueue image processing", e)
+            promise.reject("PROCESS_ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * Fetch the result of an image processing operation.
+     *
+     * @param operationId The operation ID returned by processImages
+     * @param promise Resolves with JSON string containing status and results
+     */
+    override fun fetchProcessingResult(operationId: String, promise: Promise) {
+        try {
+            val workId = UUID.fromString(operationId)
+            val workManager = WorkManager.getInstance(reactApplicationContext)
+
+            // Get work info synchronously
+            val workInfo = workManager.getWorkInfoById(workId).get()
+
+            if (workInfo == null) {
+                promise.reject("NOT_FOUND", "Operation not found: $operationId")
+                return
+            }
+
+            when (workInfo.state) {
+                WorkInfo.State.SUCCEEDED -> {
+                    val results = workInfo.outputData.getString(ImageProcessingWorker.KEY_RESULTS)
+                    val response = JSONObject().apply {
+                        put("status", "completed")
+                        put("processedImages", JSONArray(results ?: "[]"))
+                    }
+                    Log.d(TAG, "Operation $operationId completed successfully")
+
+                    // Clean up completed work
+                    workManager.cancelWorkById(workId)
+
+                    promise.resolve(response.toString())
+                }
+
+                WorkInfo.State.FAILED -> {
+                    Log.e(TAG, "Operation $operationId failed")
+                    promise.reject("PROCESSING_FAILED", "Image processing failed")
+                }
+
+                WorkInfo.State.CANCELLED -> {
+                    Log.w(TAG, "Operation $operationId was cancelled")
+                    promise.reject("CANCELLED", "Operation was cancelled")
+                }
+
+                WorkInfo.State.RUNNING,
+                WorkInfo.State.ENQUEUED -> {
+                    val response = JSONObject().apply {
+                        put("status", "processing")
+                    }
+                    promise.resolve(response.toString())
+                }
+
+                WorkInfo.State.BLOCKED -> {
+                    val response = JSONObject().apply {
+                        put("status", "blocked")
+                    }
+                    promise.resolve(response.toString())
+                }
+            }
+
+        } catch (e: IllegalArgumentException) {
+            Log.e(TAG, "Invalid operation ID: $operationId", e)
+            promise.reject("INVALID_ID", "Invalid operation ID: $operationId", e)
+        } catch (e: ExecutionException) {
+            Log.e(TAG, "Error fetching work info", e)
+            promise.reject("FETCH_ERROR", e.message, e)
+        } catch (e: InterruptedException) {
+            Log.e(TAG, "Interrupted while fetching work info", e)
+            promise.reject("INTERRUPTED", e.message, e)
+        } catch (e: Exception) {
+            Log.e(TAG, "Unexpected error", e)
+            promise.reject("ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * Convert a ReadableArray to a JSON string.
+     */
+    private fun convertArrayToJson(array: ReadableArray): String {
+        val jsonArray = JSONArray()
+
+        for (i in 0 until array.size()) {
+            val map = array.getMap(i)
+            val jsonObject = JSONObject()
+
+            map?.let {
+                jsonObject.put("localPath", it.getString("localPath") ?: "")
+                jsonObject.put("timeStamp", it.getString("timeStamp") ?: "")
+                jsonObject.put("isForOnlyWatermark", it.getBoolean("isForOnlyWatermark"))
+                jsonObject.put("compressJpegImage", it.getBoolean("compressJpegImage"))
+                jsonObject.put("replaceOriginal", it.getBoolean("replaceOriginal"))
+            }
+
+            jsonArray.put(jsonObject)
+        }
+
+        return jsonArray.toString()
+    }
+}