uploados 0.1.0

package/android/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'expo.modules.uploados'
+version = '0.1.0'
+
+android {
+  namespace "expo.modules.uploados"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+dependencies {
+  implementation 'androidx.core:core-ktx:1.13.1'
+  implementation 'com.squareup.okhttp3:okhttp:4.12.0'
+  implementation 'androidx.work:work-runtime-ktx:2.9.1'
+  implementation 'androidx.exifinterface:exifinterface:1.3.7'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,15 @@
+<manifest
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools">
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+  <application>
+    <service
+      android:name="androidx.work.impl.foreground.SystemForegroundService"
+      android:foregroundServiceType="dataSync"
+      tools:node="merge" />
+  </application>
+</manifest>

package/android/src/main/java/expo/modules/uploados/UploadosModule.kt

@@ -0,0 +1,121 @@
+package expo.modules.uploados
+
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.uploados.upload.CompressionPreset
+import expo.modules.uploados.upload.CreateUploadOptions
+import expo.modules.uploados.upload.UploadManager
+import expo.modules.uploados.upload.UploadManagerException
+import expo.modules.uploados.upload.UploadNetworkPolicy
+
+class UploadosModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("Uploados")
+
+    Events("onUploadEvent")
+
+    OnCreate {
+      val context = appContext.reactContext?.applicationContext
+        ?: return@OnCreate
+      val manager = UploadManager.getInstance(context)
+      manager.setEventEmitter { payload ->
+        sendEvent("onUploadEvent", payload)
+      }
+      manager.restoreQueue()
+    }
+
+    AsyncFunction("createUploadAsync") { options: Map<String, Any?> ->
+      val parsed = parseCreateOptions(options)
+      val manager = requireManager()
+      try {
+        manager.createUpload(parsed).toMap()
+      } catch (e: UploadManagerException) {
+        throw CodedException(e.errorCode.raw, e.message, e)
+      }
+    }
+
+    AsyncFunction("cancelUploadAsync") { taskId: String ->
+      val manager = requireManager()
+      try {
+        manager.cancelUpload(taskId).toMap()
+      } catch (e: UploadManagerException) {
+        throw CodedException(e.errorCode.raw, e.message, e)
+      }
+    }
+
+    AsyncFunction("retryUploadAsync") { taskId: String ->
+      val manager = requireManager()
+      try {
+        manager.retryUpload(taskId).toMap()
+      } catch (e: UploadManagerException) {
+        throw CodedException(e.errorCode.raw, e.message, e)
+      }
+    }
+
+    AsyncFunction("getTaskAsync") { taskId: String ->
+      expo.modules.uploados.upload.UploadTaskStore.getInstance(requireContext())
+        .task(taskId)
+        ?.toMap()
+    }
+
+    AsyncFunction("getAllTasksAsync") {
+      val store = expo.modules.uploados.upload.UploadTaskStore.getInstance(requireContext())
+      store.allTasks().map { it.toMap() }
+    }
+
+    AsyncFunction("restoreQueueAsync") {
+      val manager = requireManager()
+      manager.restoreQueue().map { it.toMap() }
+    }
+  }
+
+  private fun requireContext() =
+    appContext.reactContext?.applicationContext
+      ?: throw CodedException("ERR_UPLOADOS", "React application context is not available.", null)
+
+  private fun requireManager(): UploadManager =
+    UploadManager.getInstance(requireContext())
+
+  private fun parseCreateOptions(options: Map<String, Any?>): CreateUploadOptions {
+    val localUri = options["localUri"] as? String
+      ?: throw InvalidOptionsException("localUri")
+    val uploadUrl = options["uploadUrl"] as? String
+      ?: throw InvalidOptionsException("uploadUrl")
+    val method = (options["method"] as? String)?.uppercase() ?: "PUT"
+    if (method != "PUT" && method != "POST") {
+      throw InvalidOptionsException("method")
+    }
+    val networkPolicyRaw = options["networkPolicy"] as? String ?: UploadNetworkPolicy.WAIT.raw
+    val networkPolicy = UploadNetworkPolicy.fromRaw(networkPolicyRaw)
+      ?: throw InvalidOptionsException("networkPolicy")
+    val retry = options["retry"] as? Map<*, *>
+    val maxAttempts = (retry?.get("maxAttempts") as? Number)?.toInt()?.coerceAtLeast(1) ?: 3
+    val headers = (options["headers"] as? Map<*, *>)?.mapNotNull { (key, value) ->
+      val name = key as? String
+      val headerValue = value as? String
+      if (name != null && headerValue != null) name to headerValue else null
+    }?.toMap() ?: emptyMap()
+    val background = options["background"] as? Boolean ?: false
+    val compression = options["compression"] as? Map<*, *>
+    val compressionEnabled = compression?.get("enabled") as? Boolean ?: false
+    val compressionPreset = CompressionPreset.fromRaw(compression?.get("preset") as? String)
+    return CreateUploadOptions(
+      localUri = localUri,
+      uploadUrl = uploadUrl,
+      method = method,
+      headers = headers,
+      background = background,
+      networkPolicy = if (background) UploadNetworkPolicy.WAIT else networkPolicy,
+      maxAttempts = maxAttempts,
+      compressionEnabled = compressionEnabled,
+      compressionPreset = compressionPreset,
+    )
+  }
+}
+
+private class InvalidOptionsException(option: String) : CodedException(
+  "ERR_INVALID_OPTIONS",
+  "Missing or invalid upload option: $option",
+  null,
+)

package/android/src/main/java/expo/modules/uploados/upload/CompressionPipeline.kt

@@ -0,0 +1,192 @@
+package expo.modules.uploados.upload
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import androidx.exifinterface.media.ExifInterface
+import java.io.File
+import java.io.FileOutputStream
+
+enum class CompressionPreset(val raw: String) {
+  BALANCED("balanced"),
+  INSPECTION("inspection"),
+  AVATAR("avatar");
+
+  val maxDimension: Int
+    get() = when (this) {
+      BALANCED -> 2048
+      INSPECTION -> 4096
+      AVATAR -> 512
+    }
+
+  val jpegQuality: Int
+    get() = when (this) {
+      BALANCED -> 82
+      INSPECTION -> 92
+      AVATAR -> 85
+    }
+
+  companion object {
+    fun fromRaw(value: String?): CompressionPreset =
+      entries.firstOrNull { it.raw == value } ?: BALANCED
+  }
+}
+
+data class CompressionStats(
+  val preset: CompressionPreset,
+  val originalSize: Long,
+  val optimizedSize: Long,
+  val format: String = "jpeg",
+) {
+  fun toMap(): Map<String, Any> = mapOf(
+    "preset" to preset.raw,
+    "originalSize" to originalSize,
+    "optimizedSize" to optimizedSize,
+    "format" to format,
+  )
+}
+
+data class CompressionResult(
+  val outputFile: File,
+  val stats: CompressionStats,
+)
+
+object CompressionPipeline {
+  private const val OPTIMIZED_DIR = "optimized"
+
+  fun optimizedDirectory(context: Context): File =
+    File(File(context.filesDir, "uploados"), OPTIMIZED_DIR).also { it.mkdirs() }
+
+  fun isSdkOwnedOptimizedPath(context: Context, path: String): Boolean {
+    val root = optimizedDirectory(context).absolutePath
+    return path == root || path.startsWith("$root/")
+  }
+
+  fun cleanup(context: Context, path: String) {
+    if (!isSdkOwnedOptimizedPath(context, path)) {
+      return
+    }
+    File(path).delete()
+  }
+
+  fun compress(
+    context: Context,
+    sourceFile: File,
+    taskId: String,
+    preset: CompressionPreset,
+  ): CompressionResult {
+    val directory = optimizedDirectory(context)
+    val destination = File(directory, "$taskId.jpg")
+    if (destination.exists() && destination.isFile) {
+      return CompressionResult(
+        outputFile = destination,
+        stats = CompressionStats(
+          preset = preset,
+          originalSize = sourceFile.length(),
+          optimizedSize = destination.length(),
+        ),
+      )
+    }
+
+    val originalSize = sourceFile.length()
+    val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeFile(sourceFile.absolutePath, bounds)
+    if (bounds.outWidth <= 0 || bounds.outHeight <= 0) {
+      throw UploadManagerException(
+        UploadErrorCode.COMPRESSION_FAILED,
+        "The selected file is not a supported image format.",
+      )
+    }
+
+    val sampleSize = calculateSampleSize(bounds.outWidth, bounds.outHeight, preset.maxDimension)
+    val decodeOptions = BitmapFactory.Options().apply {
+      inSampleSize = sampleSize
+      inPreferredConfig = Bitmap.Config.ARGB_8888
+    }
+    var bitmap = BitmapFactory.decodeFile(sourceFile.absolutePath, decodeOptions)
+      ?: throw UploadManagerException(
+        UploadErrorCode.COMPRESSION_FAILED,
+        "Image compression failed.",
+      )
+
+    bitmap = applyExifOrientation(sourceFile, bitmap)
+    bitmap = scaleToMaxDimension(bitmap, preset.maxDimension)
+
+    destination.parentFile?.mkdirs()
+    FileOutputStream(destination).use { output ->
+      if (!bitmap.compress(Bitmap.CompressFormat.JPEG, preset.jpegQuality, output)) {
+        throw UploadManagerException(
+          UploadErrorCode.COMPRESSION_FAILED,
+          "Image compression failed.",
+        )
+      }
+    }
+    bitmap.recycle()
+
+    if (!destination.exists() || destination.length() <= 0) {
+      throw UploadManagerException(
+        UploadErrorCode.COMPRESSION_FAILED,
+        "Image compression failed.",
+      )
+    }
+
+    return CompressionResult(
+      outputFile = destination,
+      stats = CompressionStats(
+        preset = preset,
+        originalSize = originalSize,
+        optimizedSize = destination.length(),
+      ),
+    )
+  }
+
+  private fun calculateSampleSize(width: Int, height: Int, maxDimension: Int): Int {
+    var sampleSize = 1
+    var scaledWidth = width
+    var scaledHeight = height
+    while (scaledWidth / 2 >= maxDimension || scaledHeight / 2 >= maxDimension) {
+      sampleSize *= 2
+      scaledWidth /= 2
+      scaledHeight /= 2
+    }
+    return sampleSize
+  }
+
+  private fun scaleToMaxDimension(bitmap: Bitmap, maxDimension: Int): Bitmap {
+    val width = bitmap.width
+    val height = bitmap.height
+    val scale = minOf(1f, maxDimension.toFloat() / maxOf(width, height).toFloat())
+    if (scale >= 1f) {
+      return bitmap
+    }
+    val matrix = Matrix().apply { setScale(scale, scale) }
+    val scaled = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true)
+    if (scaled != bitmap) {
+      bitmap.recycle()
+    }
+    return scaled
+  }
+
+  private fun applyExifOrientation(sourceFile: File, bitmap: Bitmap): Bitmap {
+    val exif = runCatching { ExifInterface(sourceFile.absolutePath) }.getOrNull() ?: return bitmap
+    val orientation = exif.getAttributeInt(
+      ExifInterface.TAG_ORIENTATION,
+      ExifInterface.ORIENTATION_NORMAL,
+    )
+    val matrix = Matrix()
+    when (orientation) {
+      ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+      ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+      ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+      ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.preScale(-1f, 1f)
+      ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.preScale(1f, -1f)
+      else -> return bitmap
+    }
+    val rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+    if (rotated != bitmap) {
+      bitmap.recycle()
+    }
+    return rotated
+  }
+}

package/android/src/main/java/expo/modules/uploados/upload/FileStager.kt

@@ -0,0 +1,125 @@
+package expo.modules.uploados.upload
+
+import android.content.Context
+import android.net.Uri
+import android.webkit.MimeTypeMap
+import java.io.File
+
+object FileStager {
+  private const val STAGED_DIR = "staged"
+
+  fun stagedDirectory(context: Context): File =
+    File(File(context.filesDir, "uploados"), STAGED_DIR).also { it.mkdirs() }
+
+  fun needsStaging(context: Context, uri: String): Boolean {
+    if (uri.startsWith("content://")) {
+      return true
+    }
+
+    val path = if (uri.startsWith("file://")) Uri.parse(uri).path else uri
+    if (path.isNullOrBlank()) {
+      return false
+    }
+    if (isSdkOwnedStagedPath(context, path) || CompressionPipeline.isSdkOwnedOptimizedPath(context, path)) {
+      return false
+    }
+    val cacheDir = context.cacheDir.absolutePath
+    if (path == cacheDir || path.startsWith("$cacheDir/")) {
+      return true
+    }
+    for (externalCacheDir in context.externalCacheDirs.filterNotNull()) {
+      val externalPath = externalCacheDir.absolutePath
+      if (path == externalPath || path.startsWith("$externalPath/")) {
+        return true
+      }
+    }
+    if (path.contains("/cache/", ignoreCase = true) || path.contains("/tmp/", ignoreCase = true)) {
+      return true
+    }
+    return false
+  }
+
+  fun stageFile(context: Context, sourceUri: String, taskId: String): File {
+    val directory = stagedDirectory(context)
+    val extension = resolveExtension(context, sourceUri)
+    val destination = File(directory, "$taskId$extension")
+    if (destination.exists() && destination.isFile) {
+      return destination
+    }
+    destination.parentFile?.mkdirs()
+    when {
+      sourceUri.startsWith("content://") -> copyContentUri(context, sourceUri, destination)
+      sourceUri.startsWith("file://") -> {
+        val path = Uri.parse(sourceUri).path
+          ?: throw UploadManagerException(UploadErrorCode.FILE_NOT_FOUND, "File not found at $sourceUri.")
+        copyFile(File(path), destination)
+      }
+      else -> {
+        val source = if (sourceUri.startsWith("/")) File(sourceUri) else File(sourceUri)
+        copyFile(source, destination)
+      }
+    }
+    return destination
+  }
+
+  fun isSdkOwnedStagedPath(context: Context, path: String): Boolean {
+    val root = stagedDirectory(context).absolutePath
+    return path == root || path.startsWith("$root/")
+  }
+
+  fun cleanup(context: Context, path: String) {
+    if (!isSdkOwnedStagedPath(context, path)) {
+      return
+    }
+    File(path).delete()
+  }
+
+  private fun copyContentUri(context: Context, uri: String, destination: File) {
+    val contentUri = Uri.parse(uri)
+    context.contentResolver.openInputStream(contentUri)?.use { input ->
+      destination.outputStream().use { output ->
+        input.copyTo(output)
+      }
+    } ?: throw UploadManagerException(
+      UploadErrorCode.FILE_NOT_FOUND,
+      "File not found at $uri.",
+    )
+  }
+
+  private fun copyFile(source: File, destination: File) {
+    if (!source.exists() || !source.isFile) {
+      throw UploadManagerException(
+        UploadErrorCode.FILE_NOT_FOUND,
+        "File not found at ${source.absolutePath}.",
+      )
+    }
+    source.inputStream().use { input ->
+      destination.outputStream().use { output ->
+        input.copyTo(output)
+      }
+    }
+  }
+
+  private fun resolveExtension(context: Context, uri: String): String {
+    if (uri.startsWith("content://")) {
+      val contentUri = Uri.parse(uri)
+      val mime = context.contentResolver.getType(contentUri)
+      val ext = mime?.let { MimeTypeMap.getSingleton().getExtensionFromMimeType(it) }
+      if (!ext.isNullOrBlank()) {
+        return ".$ext"
+      }
+      val name = contentUri.lastPathSegment ?: return ""
+      val dot = name.lastIndexOf('.')
+      if (dot >= 0 && dot < name.length - 1) {
+        return name.substring(dot)
+      }
+      return ""
+    }
+    val path = if (uri.startsWith("file://")) Uri.parse(uri).path else uri
+    if (path.isNullOrBlank()) {
+      return ""
+    }
+    val dot = path.lastIndexOf('.')
+    return if (dot >= 0 && dot < path.length - 1) path.substring(dot) else ""
+  }
+}

package/android/src/main/java/expo/modules/uploados/upload/ProgressRequestBody.kt

@@ -0,0 +1,36 @@
+package expo.modules.uploados.upload
+
+import okhttp3.MediaType
+import okhttp3.RequestBody
+import okio.Buffer
+import okio.BufferedSink
+import okio.source
+import java.io.File
+
+class ProgressRequestBody(
+  private val file: File,
+  private val contentType: MediaType?,
+  private val onProgress: (bytesWritten: Long, totalBytes: Long) -> Unit,
+) : RequestBody() {
+  override fun contentType(): MediaType? = contentType
+
+  override fun contentLength(): Long = file.length()
+
+  override fun writeTo(sink: BufferedSink) {
+    val total = contentLength()
+    var uploaded = 0L
+    file.source().use { source ->
+      var read: Long
+      val buffer = Buffer()
+      while (source.read(buffer, SEGMENT_SIZE).also { read = it } != -1L) {
+        sink.write(buffer, read)
+        uploaded += read
+        onProgress(uploaded, total)
+      }
+    }
+  }
+
+  companion object {
+    private const val SEGMENT_SIZE = 8_192L
+  }
+}