react-native-capture-studio 0.1.0

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

@@ -0,0 +1,33 @@
+package com.capturestudio
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class CaptureStudioPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == CaptureStudioModule.NAME) {
+      CaptureStudioModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[CaptureStudioModule.NAME] = ReactModuleInfo(
+        CaptureStudioModule.NAME,
+        CaptureStudioModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/capturestudio/data/CameraRepository.kt

@@ -0,0 +1,43 @@
+package com.capturestudio.data
+
+import android.content.Context
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.Preview
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.view.PreviewView
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+
+class CameraRepository {
+
+    private var cameraProvider: ProcessCameraProvider? = null
+
+    fun startCamera(
+        context: Context,
+        lifecycleOwner: LifecycleOwner,
+        previewView: PreviewView
+    ) {
+        val providerFuture = ProcessCameraProvider.getInstance(context)
+
+        providerFuture.addListener({
+            cameraProvider = providerFuture.get()
+
+            val preview = Preview.Builder().build()
+            preview.setSurfaceProvider(previewView.surfaceProvider)
+
+            val selector = CameraSelector.DEFAULT_BACK_CAMERA
+
+            cameraProvider?.unbindAll()
+            cameraProvider?.bindToLifecycle(
+                lifecycleOwner,
+                selector,
+                preview
+            )
+        }, ContextCompat.getMainExecutor(context))
+    }
+
+    fun release() {
+        cameraProvider?.unbindAll()
+        cameraProvider = null
+    }
+}

package/android/src/main/java/com/capturestudio/data/processing/ImageProcessingWorker.kt

@@ -0,0 +1,126 @@
+package com.capturestudio.data.processing
+
+import android.content.Context
+import android.util.Log
+import androidx.work.CoroutineWorker
+import androidx.work.Data
+import androidx.work.WorkerParameters
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * WorkManager worker that processes images in the background.
+ * Handles multiple images sequentially with compression and watermarking.
+ */
+class ImageProcessingWorker(
+    context: Context,
+    params: WorkerParameters
+) : CoroutineWorker(context, params) {
+
+    companion object {
+        private const val TAG = "ImageProcessingWorker"
+
+        // Input/Output data keys
+        const val KEY_IMAGES = "images"
+        const val KEY_RESULTS = "results"
+    }
+
+    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
+        val imagesJson = inputData.getString(KEY_IMAGES)
+
+        if (imagesJson.isNullOrEmpty()) {
+            Log.e(TAG, "No images provided")
+            return@withContext Result.failure()
+        }
+
+        try {
+            val results = processImages(imagesJson)
+
+            val outputData = Data.Builder()
+                .putString(KEY_RESULTS, results.toString())
+                .build()
+
+            Log.d(TAG, "Processing completed successfully")
+            Result.success(outputData)
+        } catch (e: Exception) {
+            Log.e(TAG, "Processing failed", e)
+            Result.failure()
+        }
+    }
+
+    /**
+     * Process all images from the JSON array.
+     *
+     * @param imagesJson JSON array string of image processing items
+     * @return JSONArray of processing results
+     */
+    private fun processImages(imagesJson: String): JSONArray {
+        val imageArray = JSONArray(imagesJson)
+        val results = JSONArray()
+
+        Log.d(TAG, "Processing ${imageArray.length()} images")
+
+        for (i in 0 until imageArray.length()) {
+            val imageObject = imageArray.getJSONObject(i)
+            val result = processSingleImage(imageObject)
+            results.put(result)
+        }
+
+        return results
+    }
+
+    /**
+     * Process a single image and return the result.
+     */
+    private fun processSingleImage(imageObject: JSONObject): JSONObject {
+        val originalPath = imageObject.optString("localPath", "")
+        val localPath = originalPath.replace("file://", "")
+        val timeStamp = imageObject.optString("timeStamp", "")
+        val isForOnlyWatermark = imageObject.optBoolean("isForOnlyWatermark", false)
+        val compressJpeg = imageObject.optBoolean("compressJpegImage", false)
+
+        // Validate input
+        if (localPath.isEmpty() || localPath == "undefined") {
+            Log.w(TAG, "Skipping invalid path: $localPath")
+            return createResultJson(originalPath, false, "Invalid path")
+        }
+
+        if (timeStamp.isEmpty() || timeStamp == "undefined") {
+            Log.w(TAG, "Skipping invalid timestamp for: $localPath")
+            return createResultJson(originalPath, false, "Invalid timestamp")
+        }
+
+        // Process the image
+        val result = ImageProcessor.processImage(
+            imagePath = localPath,
+            timeStamp = timeStamp,
+            isForOnlyWatermark = isForOnlyWatermark,
+            compressJpeg = compressJpeg
+        )
+
+        return if (result.isSuccess) {
+            createResultJson(originalPath, true, null)
+        } else {
+            val error = result.exceptionOrNull()?.message ?: "Unknown error"
+            Log.e(TAG, "Failed to process $localPath: $error")
+            createResultJson(originalPath, false, error)
+        }
+    }
+
+    /**
+     * Create a JSON result object.
+     */
+    private fun createResultJson(
+        localPath: String,
+        success: Boolean,
+        error: String?
+    ): JSONObject {
+        return JSONObject().apply {
+            put("localPath", localPath)
+            put("success", success)
+            put("error", error ?: JSONObject.NULL)
+        }
+    }
+}

package/android/src/main/java/com/capturestudio/data/processing/ImageProcessor.kt

@@ -0,0 +1,244 @@
+package com.capturestudio.data.processing
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.Rect
+import android.util.Log
+import androidx.exifinterface.media.ExifInterface
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+
+/**
+ * Handles image processing operations including:
+ * - EXIF orientation correction
+ * - Watermark overlay
+ * - Compression to target file size (300-500KB)
+ */
+object ImageProcessor {
+
+    private const val TAG = "ImageProcessor"
+
+    // Target file size range in KB
+    private const val MIN_SIZE_KB_DEFAULT = 300
+    private const val MIN_SIZE_KB_WATERMARK_ONLY = 400
+    private const val MAX_SIZE_KB = 500
+
+    /**
+     * Process a single image: rotate based on EXIF, add watermark, compress.
+     *
+     * @param imagePath Path to the image file
+     * @param timeStamp Watermark text to overlay
+     * @param isForOnlyWatermark Use higher minimum size if true
+     * @param compressJpeg Use JPEG format if true, WebP otherwise
+     * @return Result indicating success or failure with error message
+     */
+    fun processImage(
+        imagePath: String,
+        timeStamp: String,
+        isForOnlyWatermark: Boolean,
+        compressJpeg: Boolean
+    ): Result<Unit> {
+        return runCatching {
+            val file = File(imagePath)
+            if (!file.exists()) {
+                throw IllegalArgumentException("File not found: $imagePath")
+            }
+
+            Log.d(TAG, "Processing image: $imagePath")
+
+            // 1. Load bitmap
+            val originalBitmap = BitmapFactory.decodeFile(file.absolutePath)
+                ?: throw IllegalStateException("Failed to decode image: $imagePath")
+
+            // 2. Get EXIF orientation and rotate if needed
+            val exif = ExifInterface(file.absolutePath)
+            val orientation = exif.getAttributeInt(
+                ExifInterface.TAG_ORIENTATION,
+                ExifInterface.ORIENTATION_NORMAL
+            )
+            val rotatedBitmap = rotateBitmapIfNeeded(originalBitmap, orientation)
+
+            // Recycle original if we created a new bitmap
+            if (rotatedBitmap !== originalBitmap) {
+                originalBitmap.recycle()
+            }
+
+            // 3. Add watermark
+            val watermarkedBitmap = if (timeStamp.isNotEmpty()) {
+                addWatermark(rotatedBitmap, timeStamp).also {
+                    if (it !== rotatedBitmap) rotatedBitmap.recycle()
+                }
+            } else {
+                rotatedBitmap
+            }
+
+            // 4. Compress to target size
+            val minSizeKB = if (isForOnlyWatermark) MIN_SIZE_KB_WATERMARK_ONLY else MIN_SIZE_KB_DEFAULT
+            compressToTargetSize(
+                bitmap = watermarkedBitmap,
+                outputPath = imagePath,
+                minKB = minSizeKB,
+                maxKB = MAX_SIZE_KB,
+                useJpeg = compressJpeg
+            )
+
+            watermarkedBitmap.recycle()
+
+            Log.d(TAG, "Successfully processed: $imagePath")
+        }
+    }
+
+    /**
+     * Rotate bitmap based on EXIF orientation.
+     */
+    private fun rotateBitmapIfNeeded(bitmap: Bitmap, orientation: Int): Bitmap {
+        val rotationAngle = when (orientation) {
+            ExifInterface.ORIENTATION_ROTATE_90 -> 90f
+            ExifInterface.ORIENTATION_ROTATE_180 -> 180f
+            ExifInterface.ORIENTATION_ROTATE_270 -> 270f
+            else -> return bitmap // No rotation needed
+        }
+
+        val matrix = Matrix().apply {
+            postRotate(rotationAngle)
+        }
+
+        return Bitmap.createBitmap(
+            bitmap,
+            0,
+            0,
+            bitmap.width,
+            bitmap.height,
+            matrix,
+            true
+        )
+    }
+
+    /**
+     * Add a watermark to the bottom-right corner of the image.
+     * Yellow text on black background, matching iOS implementation.
+     */
+    private fun addWatermark(bitmap: Bitmap, text: String): Bitmap {
+        val mutableBitmap = bitmap.copy(Bitmap.Config.ARGB_8888, true)
+        val canvas = Canvas(mutableBitmap)
+
+        val imageWidth = mutableBitmap.width
+        val imageHeight = mutableBitmap.height
+
+        // Calculate sizes relative to image dimensions (matching iOS)
+        val textSize = imageWidth / 40f
+        val padding = imageWidth / 50f
+
+        // Text paint
+        val textPaint = Paint().apply {
+            color = Color.YELLOW
+            this.textSize = textSize
+            isAntiAlias = true
+        }
+
+        // Background paint
+        val bgPaint = Paint().apply {
+            color = Color.BLACK
+            style = Paint.Style.FILL
+        }
+
+        // Measure text
+        val textBounds = Rect()
+        textPaint.getTextBounds(text, 0, text.length, textBounds)
+
+        // Calculate background dimensions
+        val bgWidth = textBounds.width() + 2 * padding
+        val bgHeight = textBounds.height() + 2 * padding
+
+        // Position at bottom-right
+        val x = imageWidth - bgWidth - padding
+        val y = imageHeight - bgHeight - padding
+
+        // Draw black background rectangle
+        canvas.drawRect(x, y, x + bgWidth, y + bgHeight, bgPaint)
+
+        // Draw text
+        canvas.drawText(
+            text,
+            x + padding,
+            y + textBounds.height() + padding,
+            textPaint
+        )
+
+        return mutableBitmap
+    }
+
+    /**
+     * Compress bitmap to target file size using binary search.
+     * Tries to achieve file size between minKB and maxKB.
+     */
+    private fun compressToTargetSize(
+        bitmap: Bitmap,
+        outputPath: String,
+        minKB: Int,
+        maxKB: Int,
+        useJpeg: Boolean
+    ) {
+        val format = getCompressFormat(useJpeg)
+        Log.d(TAG, "Using compression format: $format (useJpeg=$useJpeg)")
+
+        var low = 0
+        var high = 100
+        var bestData: ByteArray? = null
+        var bestQuality = 100
+
+        // Binary search for optimal quality
+        while (low <= high) {
+            val quality = (low + high) / 2
+            val stream = ByteArrayOutputStream()
+
+            bitmap.compress(format, quality, stream)
+            val data = stream.toByteArray()
+            val sizeKB = data.size / 1024
+
+            bestData = data
+            bestQuality = quality
+
+            when {
+                sizeKB < minKB -> {
+                    // Size too small, increase quality
+                    low = quality + 1
+                }
+                sizeKB > maxKB -> {
+                    // Size too large, decrease quality
+                    high = quality - 1
+                }
+                else -> {
+                    // Within range, done
+                    Log.d(TAG, "Found optimal quality: $quality, size: ${sizeKB}KB")
+                    break
+                }
+            }
+        }
+
+        // Write to file
+        bestData?.let { data ->
+            FileOutputStream(outputPath).use { fos ->
+                fos.write(data)
+            }
+            Log.d(TAG, "Wrote ${data.size / 1024}KB at quality $bestQuality to $outputPath")
+        }
+    }
+
+    /**
+     * Get the appropriate compression format based on preference.
+     */
+    private fun getCompressFormat(useJpeg: Boolean): Bitmap.CompressFormat {
+        return if (useJpeg) {
+            Bitmap.CompressFormat.JPEG
+        } else {
+            @Suppress("DEPRECATION")
+            Bitmap.CompressFormat.WEBP
+        }
+    }
+}

package/android/src/main/java/com/capturestudio/domain/model/ImageProcessingItem.kt

@@ -0,0 +1,18 @@
+package com.capturestudio.domain.model
+
+/**
+ * Represents an image to be processed with compression and watermarking.
+ *
+ * @property localPath The file path to the image (may include "file://" prefix)
+ * @property timeStamp The timestamp text to overlay as watermark
+ * @property isForOnlyWatermark If true, uses higher minimum size (400KB vs 300KB)
+ * @property compressJpegImage If true, uses JPEG format; otherwise uses WebP
+ * @property replaceOriginal If true, overwrites the original file
+ */
+data class ImageProcessingItem(
+    val localPath: String,
+    val timeStamp: String,
+    val isForOnlyWatermark: Boolean = false,
+    val compressJpegImage: Boolean = false,
+    val replaceOriginal: Boolean = true
+)

package/android/src/main/java/com/capturestudio/domain/model/ProcessingResult.kt

@@ -0,0 +1,14 @@
+package com.capturestudio.domain.model
+
+/**
+ * Represents the result of processing a single image.
+ *
+ * @property localPath The original path of the processed image
+ * @property success Whether processing completed successfully
+ * @property error Error message if processing failed, null otherwise
+ */
+data class ProcessingResult(
+    val localPath: String,
+    val success: Boolean,
+    val error: String? = null
+)

package/android/src/main/java/com/capturestudio/ui/camera/CameraActivity.kt

@@ -0,0 +1,55 @@
+package com.capturestudio.ui.camera
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.os.Bundle
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.activity.viewModels
+import androidx.appcompat.app.AppCompatActivity
+import androidx.camera.view.PreviewView
+import androidx.core.content.ContextCompat
+import com.capturestudio.R
+
+class CameraActivity : AppCompatActivity() {
+
+    private val viewModel: CameraViewModel by viewModels {
+        CameraViewModelFactory()
+    }
+
+    private lateinit var previewView: PreviewView
+
+    private val permissionLauncher =
+        registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+            if (granted) {
+                startCamera()
+            }
+        }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_camera)
+
+        previewView = findViewById(R.id.previewView)
+
+        if (hasCameraPermission()) {
+            startCamera()
+        } else {
+            permissionLauncher.launch(Manifest.permission.CAMERA)
+        }
+    }
+
+    private fun startCamera() {
+        viewModel.startCamera(
+            context = this,
+            lifecycleOwner = this,
+            previewView = previewView
+        )
+    }
+
+    private fun hasCameraPermission(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            this,
+            Manifest.permission.CAMERA
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+}

package/android/src/main/java/com/capturestudio/ui/camera/CameraUiState.kt

@@ -0,0 +1,7 @@
+package com.capturestudio.ui.camera
+
+data class CameraUiState(
+    val isCameraReady: Boolean = false,
+    val isCapturing: Boolean = false,
+    val error: String? = null
+)

package/android/src/main/java/com/capturestudio/ui/camera/CameraViewModel.kt

@@ -0,0 +1,34 @@
+package com.capturestudio.ui.camera
+
+import android.content.Context
+import androidx.camera.view.PreviewView
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.ViewModel
+import com.capturestudio.data.CameraRepository
+
+class CameraViewModel(
+    private val cameraRepository: CameraRepository
+) : ViewModel() {
+
+    private val _uiState = MutableLiveData(CameraUiState())
+    val uiState: LiveData<CameraUiState> = _uiState
+
+    fun startCamera(
+        context: Context,
+        lifecycleOwner: LifecycleOwner,
+        previewView: PreviewView
+    ) {
+        cameraRepository.startCamera(
+            context = context,
+            lifecycleOwner = lifecycleOwner,
+            previewView = previewView
+        )
+    }
+
+    override fun onCleared() {
+        super.onCleared()
+        cameraRepository.release()
+    }
+}

package/android/src/main/java/com/capturestudio/ui/camera/CameraViewModelFactory.kt

@@ -0,0 +1,17 @@
+package com.capturestudio.ui.camera
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import com.capturestudio.data.CameraRepository
+
+class CameraViewModelFactory : ViewModelProvider.Factory {
+
+    override fun <T : ViewModel> create(modelClass: Class<T>): T {
+        if (modelClass.isAssignableFrom(CameraViewModel::class.java)) {
+            return CameraViewModel(
+                cameraRepository = CameraRepository()
+            ) as T
+        }
+        throw IllegalArgumentException("Unknown ViewModel class")
+    }
+}

package/android/src/main/res/layout/activity_camera.xml

@@ -0,0 +1,10 @@
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="#000">
+
+    <androidx.camera.view.PreviewView
+        android:id="@+id/previewView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</FrameLayout>

package/ios/CaptureStudio.h

@@ -0,0 +1,7 @@
+#ifdef __cplusplus
+#import "generated/ReactCodegen/RNCaptureStudioSpec/RNCaptureStudioSpec.h"
+#endif
+
+@interface CaptureStudio : NSObject <NativeCaptureStudioSpec>
+
+@end