uploados 0.1.0

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

@@ -0,0 +1,209 @@
+package expo.modules.uploados.upload
+
+import java.io.File
+
+enum class UploadState(val raw: String) {
+  CREATED("created"),
+  VALIDATING("validating"),
+  COMPRESSING("compressing"),
+  QUEUED("queued"),
+  CONNECTING("connecting"),
+  UPLOADING("uploading"),
+  VERIFYING("verifying"),
+  RETRYING("retrying"),
+  COMPLETED("completed"),
+  PAUSED("paused"),
+  FAILED("failed"),
+  CANCELLED("cancelled");
+
+  companion object {
+    fun fromRaw(value: String): UploadState? =
+      entries.firstOrNull { it.raw == value }
+  }
+}
+
+enum class UploadNetworkPolicy(val raw: String) {
+  WAIT("wait"),
+  FAIL_FAST("failFast");
+
+  companion object {
+    fun fromRaw(value: String): UploadNetworkPolicy? =
+      entries.firstOrNull { it.raw == value }
+  }
+}
+
+enum class UploadExecutionResult {
+  FINISHED,
+  RETRY,
+}
+
+enum class UploadErrorCode(val raw: String) {
+  FILE_NOT_FOUND("FILE_NOT_FOUND"),
+  FILE_TOO_LARGE("FILE_TOO_LARGE"),
+  NETWORK_ERROR("NETWORK_ERROR"),
+  AUTH_ERROR("AUTH_ERROR"),
+  PROVIDER_ERROR("PROVIDER_ERROR"),
+  MULTIPART_FAILED("MULTIPART_FAILED"),
+  COMPRESSION_FAILED("COMPRESSION_FAILED"),
+  BACKGROUND_RESTRICTED("BACKGROUND_RESTRICTED"),
+  CANCELLED("CANCELLED"),
+  UNKNOWN("UNKNOWN");
+
+  companion object {
+    fun fromRaw(value: String): UploadErrorCode? =
+      entries.firstOrNull { it.raw == value }
+  }
+}
+
+data class UploadErrorPayload(
+  val code: UploadErrorCode,
+  val message: String,
+  val retryable: Boolean,
+  val taskId: String,
+  val phase: String? = null,
+  val httpStatus: Int? = null,
+  val providerCode: String? = null,
+  val providerMessage: String? = null,
+  val nativeCause: String? = null,
+) {
+  fun toMap(): Map<String, Any> {
+    val map = mutableMapOf<String, Any>(
+      "code" to code.raw,
+      "message" to message,
+      "retryable" to retryable,
+      "taskId" to taskId,
+    )
+    phase?.let { map["phase"] = it }
+    httpStatus?.let { map["httpStatus"] = it }
+    providerCode?.let { map["providerCode"] = it }
+    providerMessage?.let { map["providerMessage"] = it }
+    nativeCause?.let { map["nativeCause"] = it }
+    return map
+  }
+}
+
+data class UploadFileMetadata(
+  val originalUri: String,
+  val uploadUri: String,
+  val isStaged: Boolean,
+  val sizeBytes: Long? = null,
+) {
+  fun toMap(): Map<String, Any> {
+    val map = mutableMapOf<String, Any>(
+      "originalUri" to originalUri,
+      "uploadUri" to uploadUri,
+      "isStaged" to isStaged,
+    )
+    sizeBytes?.let { map["sizeBytes"] = it }
+    return map
+  }
+}
+
+data class UploadProgress(
+  var bytesUploaded: Long,
+  var totalBytes: Long,
+  var percentage: Double,
+) {
+  fun toMap(): Map<String, Any> = mapOf(
+    "bytesUploaded" to bytesUploaded,
+    "totalBytes" to totalBytes,
+    "percentage" to percentage,
+  )
+}
+
+data class UploadTaskRecord(
+  val id: String,
+  val localUri: String,
+  var stagedFilePath: String? = null,
+  var optimizedFilePath: String? = null,
+  val compressionEnabled: Boolean = false,
+  var compressionPreset: String? = null,
+  var originalSize: Long? = null,
+  var optimizedSize: Long? = null,
+  val uploadUrl: String,
+  val method: String,
+  var state: UploadState,
+  var progress: UploadProgress,
+  val background: Boolean,
+  val networkPolicy: UploadNetworkPolicy,
+  var attempt: Int,
+  val maxAttempts: Int,
+  var nextRetryAt: Double? = null,
+  val createdAt: Double,
+  var updatedAt: Double,
+  var headers: Map<String, String>,
+  var error: UploadErrorPayload? = null,
+) {
+  fun fileMetadata(): UploadFileMetadata {
+    val uploadPath = optimizedFilePath ?: stagedFilePath
+    val uploadUri = uploadPath?.let { File(it).toURI().toString() }
+      ?: if (localUri.startsWith("file://") || localUri.startsWith("content://")) {
+        localUri
+      } else {
+        File(localUri).toURI().toString()
+      }
+    val sizeBytes = optimizedSize ?: originalSize ?: progress.totalBytes.takeIf { it > 0 }
+    return UploadFileMetadata(
+      originalUri = localUri,
+      uploadUri = uploadUri,
+      isStaged = stagedFilePath != null || optimizedFilePath != null,
+      sizeBytes = sizeBytes,
+    )
+  }
+
+  fun compressionStatsMap(): Map<String, Any>? {
+    val preset = compressionPreset
+    val original = originalSize
+    val optimized = optimizedSize
+    if (!compressionEnabled || preset == null || original == null || optimized == null) {
+      return null
+    }
+    return mapOf(
+      "preset" to preset,
+      "originalSize" to original,
+      "optimizedSize" to optimized,
+      "format" to "jpeg",
+    )
+  }
+
+  fun toMap(): Map<String, Any?> {
+    val map = mutableMapOf<String, Any?>(
+      "id" to id,
+      "localUri" to localUri,
+      "file" to fileMetadata().toMap(),
+      "uploadUrl" to uploadUrl,
+      "method" to method,
+      "state" to state.raw,
+      "progress" to progress.toMap(),
+      "background" to background,
+      "networkPolicy" to networkPolicy.raw,
+      "attempt" to attempt,
+      "maxAttempts" to maxAttempts,
+      "createdAt" to createdAt,
+      "updatedAt" to updatedAt,
+    )
+    nextRetryAt?.let { map["nextRetryAt"] = it }
+    originalSize?.let { map["originalSize"] = it }
+    optimizedSize?.let { map["optimizedSize"] = it }
+    compressionStatsMap()?.let { map["compression"] = it }
+    error?.let { map["error"] = it.toMap() }
+    return map
+  }
+}
+
+data class CreateUploadOptions(
+  val localUri: String,
+  val uploadUrl: String,
+  val method: String,
+  val headers: Map<String, String>,
+  val background: Boolean,
+  val networkPolicy: UploadNetworkPolicy,
+  val maxAttempts: Int,
+  val compressionEnabled: Boolean = false,
+  val compressionPreset: CompressionPreset = CompressionPreset.BALANCED,
+)
+
+class UploadManagerException(
+  val errorCode: UploadErrorCode,
+  override val message: String,
+) : Exception(message)

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

@@ -0,0 +1,93 @@
+package expo.modules.uploados.upload
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.ServiceInfo
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.work.ForegroundInfo
+import kotlin.math.roundToInt
+
+object UploadNotificationHelper {
+  private const val CHANNEL_ID = "uploados_uploads"
+  private const val CHANNEL_NAME = "Uploads"
+
+  fun foregroundInfo(context: Context, task: UploadTaskRecord): ForegroundInfo {
+    val notification = buildNotification(context, task)
+    val notificationId = notificationId(task.id)
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      ForegroundInfo(notificationId, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+    } else {
+      ForegroundInfo(notificationId, notification)
+    }
+  }
+
+  fun showProgress(context: Context, task: UploadTaskRecord) {
+    try {
+      notificationManager(context).notify(notificationId(task.id), buildNotification(context, task))
+    } catch (_: RuntimeException) {
+      // Notification updates are best-effort; upload state remains the source of truth.
+    }
+  }
+
+  fun cancel(context: Context, taskId: String) {
+    try {
+      notificationManager(context).cancel(notificationId(taskId))
+    } catch (_: RuntimeException) {
+      // Notification cleanup should not affect completed, failed, or cancelled uploads.
+    }
+  }
+
+  private fun buildNotification(context: Context, task: UploadTaskRecord): Notification {
+    ensureChannel(context)
+
+    val percentage = task.progress.percentage.roundToInt().coerceIn(0, 100)
+    val hasTotal = task.progress.totalBytes > 0
+    val contentText = if (hasTotal) {
+      "$percentage% uploaded"
+    } else {
+      "Preparing upload"
+    }
+
+    return NotificationCompat.Builder(context, CHANNEL_ID)
+      .setSmallIcon(notificationIcon(context))
+      .setContentTitle("Upload in progress")
+      .setContentText(contentText)
+      .setOngoing(task.state != UploadState.COMPLETED && task.state != UploadState.FAILED)
+      .setOnlyAlertOnce(true)
+      .setCategory(NotificationCompat.CATEGORY_PROGRESS)
+      .setPriority(NotificationCompat.PRIORITY_LOW)
+      .setProgress(100, percentage, !hasTotal)
+      .build()
+  }
+
+  private fun ensureChannel(context: Context) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return
+    }
+    val manager = notificationManager(context)
+    if (manager.getNotificationChannel(CHANNEL_ID) != null) {
+      return
+    }
+    val channel = NotificationChannel(
+      CHANNEL_ID,
+      CHANNEL_NAME,
+      NotificationManager.IMPORTANCE_LOW,
+    )
+    channel.setShowBadge(false)
+    manager.createNotificationChannel(channel)
+  }
+
+  private fun notificationManager(context: Context): NotificationManager =
+    context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+  private fun notificationIcon(context: Context): Int {
+    val appIcon = context.applicationInfo.icon
+    return if (appIcon != 0) appIcon else android.R.drawable.stat_sys_upload
+  }
+
+  private fun notificationId(taskId: String): Int =
+    taskId.hashCode().and(Int.MAX_VALUE).coerceAtLeast(1)
+}

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

@@ -0,0 +1,224 @@
+package expo.modules.uploados.upload
+
+import android.content.Context
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+class UploadTaskStore private constructor(context: Context) {
+  private val fileName = "uploados-tasks.json"
+  private val lock = Any()
+  private val tasks = mutableMapOf<String, UploadTaskRecord>()
+  private val storeDir: File =
+    File(context.filesDir, "uploados").also { it.mkdirs() }
+
+  init {
+    loadFromDisk()
+  }
+
+  fun allTasks(): List<UploadTaskRecord> = synchronized(lock) {
+    tasks.values.sortedBy { it.createdAt }
+  }
+
+  fun task(id: String): UploadTaskRecord? = synchronized(lock) {
+    tasks[id]
+  }
+
+  fun upsert(task: UploadTaskRecord) {
+    synchronized(lock) {
+      tasks[task.id] = task
+      persistLocked()
+    }
+  }
+
+  fun update(id: String, mutate: (UploadTaskRecord) -> Unit): UploadTaskRecord? {
+    synchronized(lock) {
+      val existing = tasks[id] ?: return null
+      val copy = existing.copy(
+        stagedFilePath = existing.stagedFilePath,
+        optimizedFilePath = existing.optimizedFilePath,
+        compressionPreset = existing.compressionPreset,
+        originalSize = existing.originalSize,
+        optimizedSize = existing.optimizedSize,
+        progress = existing.progress.copy(),
+        headers = existing.headers.toMap(),
+        error = existing.error,
+      )
+      mutate(copy)
+      copy.updatedAt = System.currentTimeMillis().toDouble()
+      tasks[id] = copy
+      persistLocked()
+      return copy
+    }
+  }
+
+  fun restorableTasks(): List<UploadTaskRecord> = synchronized(lock) {
+    tasks.values.filter { task ->
+      when (task.state) {
+        UploadState.CREATED,
+        UploadState.VALIDATING,
+        UploadState.COMPRESSING,
+        UploadState.QUEUED,
+        UploadState.CONNECTING,
+        UploadState.UPLOADING,
+        UploadState.VERIFYING,
+        UploadState.RETRYING,
+        UploadState.PAUSED -> true
+        else -> false
+      }
+    }
+  }
+
+  private fun loadFromDisk() {
+    synchronized(lock) {
+      val file = storeFile()
+      if (!file.exists()) {
+        return
+      }
+      try {
+        val json = JSONArray(file.readText())
+        tasks.clear()
+        for (i in 0 until json.length()) {
+          val record = decodeTask(json.getJSONObject(i))
+          tasks[record.id] = record
+        }
+      } catch (_: Exception) {
+        tasks.clear()
+      }
+    }
+  }
+
+  private fun persistLocked() {
+    val file = storeFile()
+    val tmpFile = File(storeDir, "$fileName.tmp")
+    val backupFile = File(storeDir, "$fileName.bak")
+    try {
+      val array = JSONArray()
+      tasks.values.forEach { array.put(encodeTask(it)) }
+      tmpFile.writeText(array.toString())
+      if (file.exists()) {
+        file.copyTo(backupFile, overwrite = true)
+      }
+      if (file.exists() && !file.delete()) {
+        throw IllegalStateException("Could not replace upload task store.")
+      }
+      if (!tmpFile.renameTo(file)) {
+        if (backupFile.exists()) {
+          backupFile.copyTo(file, overwrite = true)
+        }
+        throw IllegalStateException("Could not persist upload task store.")
+      }
+      backupFile.delete()
+    } catch (_: Exception) {
+      tmpFile.delete()
+      // Persistence failures should not crash uploads.
+    }
+  }
+
+  private fun storeFile(): File = File(storeDir, fileName)
+
+  companion object {
+    @Volatile
+    private var instance: UploadTaskStore? = null
+
+    fun getInstance(context: Context): UploadTaskStore {
+      return instance ?: synchronized(this) {
+        instance ?: UploadTaskStore(context.applicationContext).also { instance = it }
+      }
+    }
+  }
+}
+
+private fun encodeTask(task: UploadTaskRecord): JSONObject {
+  val json = JSONObject()
+  json.put("id", task.id)
+  json.put("localUri", task.localUri)
+  task.stagedFilePath?.let { json.put("stagedFilePath", it) }
+  task.optimizedFilePath?.let { json.put("optimizedFilePath", it) }
+  json.put("compressionEnabled", task.compressionEnabled)
+  task.compressionPreset?.let { json.put("compressionPreset", it) }
+  task.originalSize?.let { json.put("originalSize", it) }
+  task.optimizedSize?.let { json.put("optimizedSize", it) }
+  json.put("uploadUrl", task.uploadUrl)
+  json.put("method", task.method)
+  json.put("state", task.state.raw)
+  json.put("background", task.background)
+  json.put("networkPolicy", task.networkPolicy.raw)
+  json.put("attempt", task.attempt)
+  json.put("maxAttempts", task.maxAttempts)
+  task.nextRetryAt?.let { json.put("nextRetryAt", it) }
+  json.put("createdAt", task.createdAt)
+  json.put("updatedAt", task.updatedAt)
+  val progress = JSONObject()
+  progress.put("bytesUploaded", task.progress.bytesUploaded)
+  progress.put("totalBytes", task.progress.totalBytes)
+  progress.put("percentage", task.progress.percentage)
+  json.put("progress", progress)
+  val headers = JSONObject()
+  task.headers.forEach { (key, value) -> headers.put(key, value) }
+  json.put("headers", headers)
+  task.error?.let { error ->
+    val errorJson = JSONObject()
+    errorJson.put("code", error.code.raw)
+    errorJson.put("message", error.message)
+    errorJson.put("retryable", error.retryable)
+    errorJson.put("taskId", error.taskId)
+    error.phase?.let { errorJson.put("phase", it) }
+    error.httpStatus?.let { errorJson.put("httpStatus", it) }
+    error.providerCode?.let { errorJson.put("providerCode", it) }
+    error.providerMessage?.let { errorJson.put("providerMessage", it) }
+    error.nativeCause?.let { errorJson.put("nativeCause", it) }
+    json.put("error", errorJson)
+  }
+  return json
+}
+
+private fun decodeTask(json: JSONObject): UploadTaskRecord {
+  val progressJson = json.getJSONObject("progress")
+  val headersJson = json.optJSONObject("headers") ?: JSONObject()
+  val headers = mutableMapOf<String, String>()
+  headersJson.keys().forEach { key ->
+    headers[key] = headersJson.getString(key)
+  }
+  val error = json.optJSONObject("error")?.let { errorJson ->
+    UploadErrorPayload(
+      code = UploadErrorCode.fromRaw(errorJson.getString("code")) ?: UploadErrorCode.UNKNOWN,
+      message = errorJson.getString("message"),
+      retryable = errorJson.getBoolean("retryable"),
+      taskId = errorJson.getString("taskId"),
+      phase = errorJson.optString("phase").takeIf { it.isNotEmpty() },
+      httpStatus = if (errorJson.has("httpStatus")) errorJson.getInt("httpStatus") else null,
+      providerCode = errorJson.optString("providerCode").takeIf { it.isNotEmpty() },
+      providerMessage = errorJson.optString("providerMessage").takeIf { it.isNotEmpty() },
+      nativeCause = errorJson.optString("nativeCause").takeIf { it.isNotEmpty() },
+    )
+  }
+  return UploadTaskRecord(
+    id = json.getString("id"),
+    localUri = json.getString("localUri"),
+    stagedFilePath = json.optString("stagedFilePath").takeIf { it.isNotEmpty() },
+    optimizedFilePath = json.optString("optimizedFilePath").takeIf { it.isNotEmpty() },
+    compressionEnabled = json.optBoolean("compressionEnabled", false),
+    compressionPreset = json.optString("compressionPreset").takeIf { it.isNotEmpty() },
+    originalSize = if (json.has("originalSize")) json.getLong("originalSize") else null,
+    optimizedSize = if (json.has("optimizedSize")) json.getLong("optimizedSize") else null,
+    uploadUrl = json.getString("uploadUrl"),
+    method = json.getString("method"),
+    state = UploadState.fromRaw(json.getString("state")) ?: UploadState.FAILED,
+    progress = UploadProgress(
+      bytesUploaded = progressJson.getLong("bytesUploaded"),
+      totalBytes = progressJson.getLong("totalBytes"),
+      percentage = progressJson.getDouble("percentage"),
+    ),
+    background = json.getBoolean("background"),
+    networkPolicy = UploadNetworkPolicy.fromRaw(json.optString("networkPolicy", UploadNetworkPolicy.WAIT.raw))
+      ?: UploadNetworkPolicy.WAIT,
+    attempt = json.optInt("attempt", 0),
+    maxAttempts = json.optInt("maxAttempts", 3).coerceAtLeast(1),
+    nextRetryAt = if (json.has("nextRetryAt")) json.getDouble("nextRetryAt") else null,
+    createdAt = json.getDouble("createdAt"),
+    updatedAt = json.getDouble("updatedAt"),
+    headers = headers,
+    error = error,
+  )
+}

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

@@ -0,0 +1,31 @@
+package expo.modules.uploados.upload
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+
+class UploadWorker(
+  appContext: Context,
+  workerParams: WorkerParameters,
+) : CoroutineWorker(appContext, workerParams) {
+  override suspend fun doWork(): Result {
+    val taskId = inputData.getString(UploadManager.WORK_INPUT_TASK_ID)
+      ?: return Result.failure()
+    return try {
+      val store = UploadTaskStore.getInstance(applicationContext)
+      store.task(taskId)?.let { task ->
+        setForeground(UploadNotificationHelper.foregroundInfo(applicationContext, task))
+      }
+      when (UploadManager.getInstance(applicationContext).executeUpload(taskId)) {
+        UploadExecutionResult.RETRY -> Result.retry()
+        UploadExecutionResult.FINISHED -> Result.success()
+      }
+    } catch (_: UploadCancelledException) {
+      Result.failure()
+    } catch (_: Exception) {
+      Result.failure()
+    }
+  }
+}
+
+class UploadCancelledException : Exception()