uploados 0.1.0

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

@@ -0,0 +1,857 @@
+package expo.modules.uploados.upload
+
+import android.content.Context
+import android.net.Uri
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.workDataOf
+import okhttp3.Call
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import org.json.JSONObject
+import java.io.File
+import java.io.IOException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import kotlin.math.max
+import kotlin.math.min
+
+class UploadManager private constructor(private val appContext: Context) {
+  private val store = UploadTaskStore.getInstance(appContext)
+  private val client = OkHttpClient.Builder()
+    .connectTimeout(60, TimeUnit.SECONDS)
+    .readTimeout(60, TimeUnit.SECONDS)
+    .writeTimeout(60, TimeUnit.SECONDS)
+    .build()
+  private val executor: ExecutorService = Executors.newCachedThreadPool()
+  private val activeCalls = ConcurrentHashMap<String, Call>()
+  private val inFlight = ConcurrentHashMap.newKeySet<String>()
+  private var eventEmitter: ((Map<String, Any?>) -> Unit)? = null
+  private val lastProgressEmit = ConcurrentHashMap<String, Long>()
+  private val progressThrottleMs = 250L
+  private val baseRetryDelayMs = 1_000L
+  private val maxRetryDelayMs = 30_000L
+
+  fun setEventEmitter(emitter: (Map<String, Any?>) -> Unit) {
+    eventEmitter = emitter
+  }
+
+  fun createUpload(options: CreateUploadOptions): UploadTaskRecord {
+    val now = System.currentTimeMillis().toDouble()
+    val taskId = UUID.randomUUID().toString()
+    var record = UploadTaskRecord(
+      id = taskId,
+      localUri = options.localUri,
+      compressionEnabled = options.compressionEnabled,
+      compressionPreset = if (options.compressionEnabled) options.compressionPreset.raw else null,
+      uploadUrl = options.uploadUrl,
+      method = options.method,
+      state = UploadState.CREATED,
+      progress = UploadProgress(0, 0, 0.0),
+      background = options.background,
+      networkPolicy = options.networkPolicy,
+      attempt = 0,
+      maxAttempts = options.maxAttempts,
+      nextRetryAt = null,
+      createdAt = now,
+      updatedAt = now,
+      headers = options.headers,
+      error = null,
+    )
+    store.upsert(record)
+    emit(mapOf("type" to "created", "task" to record.toMap()))
+
+    record = store.update(taskId) { task ->
+      task.state = UploadState.COMPRESSING
+    } ?: record.copy(state = UploadState.COMPRESSING)
+    emit(mapOf("type" to "compressing", "taskId" to taskId, "task" to record.toMap()))
+
+    val fileSize = try {
+      val prepared = prepareUploadFile(
+        taskId = taskId,
+        localUri = options.localUri,
+        stagedFilePath = null,
+      )
+      if (prepared.stagedPath != null) {
+        record = store.update(taskId) { task ->
+          task.stagedFilePath = prepared.stagedPath
+        } ?: record.copy(stagedFilePath = prepared.stagedPath)
+      }
+
+      val size = if (options.compressionEnabled) {
+        val existingOptimized = record.optimizedFilePath?.let { File(it) }?.takeIf { it.exists() && it.isFile }
+        if (existingOptimized != null) {
+          existingOptimized.length()
+        } else {
+          val result = CompressionPipeline.compress(
+            context = appContext,
+            sourceFile = prepared.file,
+            taskId = taskId,
+            preset = options.compressionPreset,
+          )
+          record = store.update(taskId) { task ->
+            task.optimizedFilePath = result.outputFile.absolutePath
+            task.originalSize = result.stats.originalSize
+            task.optimizedSize = result.stats.optimizedSize
+          } ?: record.copy(
+            optimizedFilePath = result.outputFile.absolutePath,
+            originalSize = result.stats.originalSize,
+            optimizedSize = result.stats.optimizedSize,
+          )
+          emit(
+            mapOf(
+              "type" to "compressed",
+              "taskId" to taskId,
+              "task" to record.toMap(),
+              "stats" to result.stats.toMap(),
+            ),
+          )
+          result.stats.optimizedSize
+        }
+      } else {
+        val resolvedSize = prepared.file.length()
+        if (resolvedSize > 0) {
+          record = store.update(taskId) { task ->
+            task.originalSize = resolvedSize
+          } ?: record.copy(originalSize = resolvedSize)
+        }
+        resolvedSize
+      }
+      if (size <= 0) {
+        throw UploadManagerException(
+          UploadErrorCode.FILE_NOT_FOUND,
+          "File not found at ${options.localUri}.",
+        )
+      }
+      size
+    } catch (e: UploadManagerException) {
+      markFailed(
+        taskId = taskId,
+        code = e.errorCode,
+        message = e.message,
+        retryable = false,
+        phase = "compressing",
+        httpStatus = null,
+        providerCode = null,
+        providerMessage = null,
+        nativeCause = null,
+      )
+      throw e
+    } catch (e: Exception) {
+      val message = e.message ?: "File not found at ${options.localUri}."
+      markFailed(
+        taskId = taskId,
+        code = if (options.compressionEnabled) UploadErrorCode.COMPRESSION_FAILED else UploadErrorCode.FILE_NOT_FOUND,
+        message = message,
+        retryable = false,
+        phase = "compressing",
+        httpStatus = null,
+        providerCode = null,
+        providerMessage = null,
+        nativeCause = e.javaClass.simpleName,
+      )
+      throw UploadManagerException(
+        if (options.compressionEnabled) UploadErrorCode.COMPRESSION_FAILED else UploadErrorCode.FILE_NOT_FOUND,
+        message,
+      )
+    }
+
+    record = store.update(taskId) { task ->
+      task.state = UploadState.QUEUED
+      task.progress = UploadProgress(0, fileSize, 0.0)
+    } ?: record.copy(
+      state = UploadState.QUEUED,
+      progress = UploadProgress(0, fileSize, 0.0),
+    )
+    emit(mapOf("type" to "queued", "taskId" to taskId))
+
+    scheduleUpload(record)
+    return store.task(taskId) ?: record
+  }
+
+  fun cancelUpload(taskId: String): UploadTaskRecord {
+    val record = store.task(taskId)
+      ?: throw UploadManagerException(UploadErrorCode.UNKNOWN, "Upload task not found: $taskId.")
+
+    activeCalls.remove(taskId)?.cancel()
+    WorkManager.getInstance(appContext).cancelUniqueWork(workName(taskId))
+    inFlight.remove(taskId)
+
+    val error = UploadErrorPayload(
+      code = UploadErrorCode.CANCELLED,
+      message = "Upload cancelled.",
+      retryable = false,
+      taskId = taskId,
+    )
+    val updated = store.update(taskId) { task ->
+      task.state = UploadState.CANCELLED
+      task.error = error
+      task.nextRetryAt = null
+    } ?: record.copy(state = UploadState.CANCELLED, error = error)
+
+    cleanupDerivedFilesIfNeeded(updated)
+    val finalTask = store.update(taskId) { task ->
+      task.stagedFilePath = null
+      task.optimizedFilePath = null
+    } ?: updated
+    UploadNotificationHelper.cancel(appContext, taskId)
+    emit(mapOf("type" to "cancelled", "taskId" to taskId))
+    return finalTask
+  }
+
+  fun retryUpload(taskId: String): UploadTaskRecord {
+    val record = store.task(taskId)
+      ?: throw UploadManagerException(UploadErrorCode.UNKNOWN, "Upload task not found: $taskId.")
+    if (record.state != UploadState.FAILED) {
+      throw UploadManagerException(
+        UploadErrorCode.UNKNOWN,
+        "Upload task $taskId cannot be retried from state ${record.state.raw}.",
+      )
+    }
+
+    activeCalls.remove(taskId)?.cancel()
+    WorkManager.getInstance(appContext).cancelUniqueWork(workName(taskId))
+    inFlight.remove(taskId)
+
+    var updated = store.update(taskId) { task ->
+      task.state = UploadState.COMPRESSING
+      task.error = null
+      task.nextRetryAt = null
+    } ?: record.copy(
+      state = UploadState.COMPRESSING,
+      error = null,
+      nextRetryAt = null,
+    )
+    emit(mapOf("type" to "compressing", "taskId" to taskId, "task" to updated.toMap()))
+
+    val fileSize = try {
+      val file = resolveUploadFile(record)
+      val resolvedSize = file.length()
+      if (resolvedSize <= 0) {
+        throw UploadManagerException(
+          UploadErrorCode.FILE_NOT_FOUND,
+          "File not found at ${record.localUri}.",
+        )
+      }
+      resolvedSize
+    } catch (e: UploadManagerException) {
+      markFailed(
+        taskId = taskId,
+        code = e.errorCode,
+        message = e.message,
+        retryable = false,
+        phase = "compressing",
+        httpStatus = null,
+        providerCode = null,
+        providerMessage = null,
+        nativeCause = null,
+      )
+      throw e
+    } catch (e: Exception) {
+      val message = e.message ?: "File not found."
+      markFailed(
+        taskId = taskId,
+        code = UploadErrorCode.FILE_NOT_FOUND,
+        message = message,
+        retryable = false,
+        phase = "compressing",
+        httpStatus = null,
+        providerCode = null,
+        providerMessage = null,
+        nativeCause = e.javaClass.simpleName,
+      )
+      throw UploadManagerException(UploadErrorCode.FILE_NOT_FOUND, message)
+    }
+    updated = store.update(taskId) { task ->
+      task.state = UploadState.QUEUED
+      task.progress = UploadProgress(0, fileSize, 0.0)
+      task.attempt = 0
+      task.error = null
+      task.nextRetryAt = null
+    } ?: updated.copy(
+      state = UploadState.QUEUED,
+      progress = UploadProgress(0, fileSize, 0.0),
+      attempt = 0,
+      error = null,
+      nextRetryAt = null,
+    )
+
+    emit(mapOf("type" to "queued", "taskId" to taskId))
+    scheduleUpload(updated, existingWorkPolicy = ExistingWorkPolicy.REPLACE)
+    return store.task(taskId) ?: updated
+  }
+
+  fun restoreQueue(): List<UploadTaskRecord> {
+    val pending = store.restorableTasks()
+    for (record in pending) {
+      try {
+        resolveUploadFile(record)
+        val delayMs = if (record.state == UploadState.RETRYING && record.nextRetryAt != null) {
+          (record.nextRetryAt!! - System.currentTimeMillis()).toLong().coerceAtLeast(0L)
+        } else {
+          0L
+        }
+        scheduleUpload(record, delayMs = delayMs, existingWorkPolicy = ExistingWorkPolicy.KEEP)
+      } catch (e: Exception) {
+        markFailed(
+          taskId = record.id,
+          code = UploadErrorCode.FILE_NOT_FOUND,
+          message = e.message ?: "File not found.",
+          retryable = false,
+          phase = "compressing",
+          httpStatus = null,
+          providerCode = null,
+          providerMessage = null,
+          nativeCause = null,
+        )
+      }
+    }
+    return store.allTasks()
+  }
+
+  fun executeUpload(taskId: String): UploadExecutionResult {
+    if (!inFlight.add(taskId)) {
+      return UploadExecutionResult.FINISHED
+    }
+    try {
+      val record = store.task(taskId)
+        ?: throw UploadManagerException(UploadErrorCode.UNKNOWN, "Upload task not found: $taskId.")
+      if (record.state == UploadState.CANCELLED || record.state == UploadState.COMPLETED) {
+        return UploadExecutionResult.FINISHED
+      }
+
+      val file = resolveUploadFile(record)
+      val fileSize = file.length()
+      val connecting = store.update(taskId) { task ->
+        val nextAttempt = task.attempt + 1
+        task.state = UploadState.CONNECTING
+        task.attempt = nextAttempt
+        task.progress.totalBytes = fileSize
+        task.nextRetryAt = null
+        if (nextAttempt > 1) {
+          task.progress.bytesUploaded = 0
+          task.progress.percentage = 0.0
+        }
+      }
+      connecting?.let {
+        emit(mapOf("type" to "connecting", "taskId" to taskId, "task" to it.toMap()))
+      }
+
+      val request = buildRequest(record, file) { bytesWritten, totalBytes ->
+        handleProgress(taskId, bytesWritten, totalBytes)
+      }
+      val call = client.newCall(request)
+      activeCalls[taskId] = call
+      val response = call.execute()
+      activeCalls.remove(taskId)
+
+      if (call.isCanceled()) {
+        throw UploadCancelledException()
+      }
+
+      response.use {
+        if (!it.isSuccessful) {
+          return handleHttpFailure(taskId, it.code, it.body?.string())
+        }
+      }
+      handleCompletion(taskId)
+      return UploadExecutionResult.FINISHED
+    } catch (_: UploadCancelledException) {
+      activeCalls.remove(taskId)
+      return UploadExecutionResult.FINISHED
+    } catch (e: Exception) {
+      activeCalls.remove(taskId)
+      if (e is IOException && e.message?.contains("Canceled", ignoreCase = true) == true) {
+        return UploadExecutionResult.FINISHED
+      }
+      return handleFailure(taskId, e, null)
+    } finally {
+      inFlight.remove(taskId)
+    }
+  }
+
+  private fun scheduleUpload(
+    record: UploadTaskRecord,
+    delayMs: Long = 0L,
+    existingWorkPolicy: ExistingWorkPolicy = ExistingWorkPolicy.KEEP,
+  ) {
+    if (record.background) {
+      val constraints = Constraints.Builder()
+        .setRequiredNetworkType(NetworkType.CONNECTED)
+        .build()
+      val workBuilder = OneTimeWorkRequestBuilder<UploadWorker>()
+        .setInputData(workDataOf(WORK_INPUT_TASK_ID to record.id))
+        .setConstraints(constraints)
+        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 10, TimeUnit.SECONDS)
+        .addTag(WORK_TAG)
+        .addTag(record.id)
+      if (delayMs > 0) {
+        workBuilder.setInitialDelay(delayMs, TimeUnit.MILLISECONDS)
+      }
+      WorkManager.getInstance(appContext).enqueueUniqueWork(
+        workName(record.id),
+        existingWorkPolicy,
+        workBuilder.build(),
+      )
+      return
+    }
+
+    executor.execute {
+      try {
+        if (delayMs > 0) {
+          Thread.sleep(delayMs)
+        }
+        executeUpload(record.id)
+      } catch (_: InterruptedException) {
+        Thread.currentThread().interrupt()
+      } catch (_: Exception) {
+        // Errors are surfaced via events.
+      }
+    }
+  }
+
+  private fun buildRequest(
+    record: UploadTaskRecord,
+    file: File,
+    onProgress: (Long, Long) -> Unit,
+  ): Request {
+    val mediaType = record.headers["Content-Type"]?.toMediaTypeOrNull()
+    val body = ProgressRequestBody(file, mediaType, onProgress)
+    val requestBuilder = Request.Builder()
+      .url(record.uploadUrl)
+      .method(record.method, body)
+
+    record.headers.forEach { (key, value) ->
+      requestBuilder.header(key, value)
+    }
+
+    return requestBuilder.build()
+  }
+
+  private fun handleProgress(taskId: String, bytesUploaded: Long, totalBytes: Long) {
+    val now = System.currentTimeMillis()
+    val percentage = if (totalBytes > 0) {
+      min(100.0, max(0.0, (bytesUploaded.toDouble() / totalBytes.toDouble()) * 100.0))
+    } else {
+      0.0
+    }
+    val previous = store.task(taskId)
+    val isVerifying = percentage >= 100.0
+
+    val updated = store.update(taskId) { task ->
+      task.state = if (isVerifying) UploadState.VERIFYING else UploadState.UPLOADING
+      task.progress = UploadProgress(bytesUploaded, totalBytes, percentage)
+    } ?: return
+    if (updated.background) {
+      UploadNotificationHelper.showProgress(appContext, updated)
+    }
+
+    val lastEmit = lastProgressEmit[taskId] ?: 0L
+    if (now - lastEmit < progressThrottleMs && percentage < 100.0) {
+      return
+    }
+    lastProgressEmit[taskId] = now
+    if (isVerifying && previous?.state != UploadState.VERIFYING) {
+      emit(mapOf("type" to "verifying", "taskId" to taskId))
+    }
+    emit(
+      mapOf(
+        "type" to "progress",
+        "taskId" to taskId,
+        "progress" to updated.progress.toMap(),
+      ),
+    )
+  }
+
+  private fun handleCompletion(taskId: String) {
+    val updated = store.update(taskId) { task ->
+      task.state = UploadState.COMPLETED
+      task.progress.percentage = 100.0
+      task.progress.bytesUploaded = task.progress.totalBytes
+      task.error = null
+      task.nextRetryAt = null
+    } ?: return
+    lastProgressEmit.remove(taskId)
+    cleanupDerivedFilesIfNeeded(updated)
+    val finalTask = store.update(taskId) { task ->
+      task.stagedFilePath = null
+      task.optimizedFilePath = null
+    } ?: updated
+    UploadNotificationHelper.cancel(appContext, taskId)
+
+    emit(
+      mapOf(
+        "type" to "completed",
+        "taskId" to taskId,
+        "task" to finalTask.toMap(),
+      ),
+    )
+  }
+
+  private fun handleFailure(
+    taskId: String,
+    error: Exception,
+    statusCode: Int?,
+  ): UploadExecutionResult {
+    if (error is UploadCancelledException) {
+      return UploadExecutionResult.FINISHED
+    }
+    val retryable = isRetryable(error, statusCode)
+    return failOrRetry(
+      taskId = taskId,
+      code = UploadErrorCode.NETWORK_ERROR,
+      message = error.message ?: "Upload failed.",
+      retryable = retryable,
+      phase = failurePhase(taskId),
+      httpStatus = statusCode,
+      providerCode = null,
+      providerMessage = null,
+      nativeCause = error.javaClass.simpleName,
+    )
+  }
+
+  private fun failurePhase(taskId: String): String {
+    return when (store.task(taskId)?.state) {
+      UploadState.COMPRESSING -> "compressing"
+      UploadState.CONNECTING -> "connecting"
+      UploadState.VERIFYING -> "verifying"
+      UploadState.RETRYING -> "retrying"
+      else -> "uploading"
+    }
+  }
+
+  private fun handleHttpFailure(
+    taskId: String,
+    statusCode: Int,
+    responseBody: String?,
+  ): UploadExecutionResult {
+    val code = if (statusCode == 401 || statusCode == 403) {
+      UploadErrorCode.AUTH_ERROR
+    } else {
+      UploadErrorCode.PROVIDER_ERROR
+    }
+    val providerError = parseProviderError(responseBody)
+    return failOrRetry(
+      taskId = taskId,
+      code = code,
+      message = providerError.message ?: "Upload failed with HTTP status $statusCode.",
+      retryable = statusCode >= 500,
+      phase = "verifying",
+      httpStatus = statusCode,
+      providerCode = providerError.code,
+      providerMessage = providerError.message,
+      nativeCause = null,
+    )
+  }
+
+  private fun markFailed(
+    taskId: String,
+    code: UploadErrorCode,
+    message: String,
+    retryable: Boolean,
+    phase: String?,
+    httpStatus: Int?,
+    providerCode: String?,
+    providerMessage: String?,
+    nativeCause: String?,
+  ) {
+    val error = UploadErrorPayload(
+      code = code,
+      message = message,
+      retryable = retryable,
+      taskId = taskId,
+      phase = phase,
+      httpStatus = httpStatus,
+      providerCode = providerCode,
+      providerMessage = providerMessage,
+      nativeCause = nativeCause,
+    )
+    val updated = store.update(taskId) { task ->
+      task.state = UploadState.FAILED
+      task.error = error
+      task.nextRetryAt = null
+    } ?: return
+    lastProgressEmit.remove(taskId)
+    cleanupDerivedFilesIfNeeded(updated)
+    val finalTask = store.update(taskId) { task ->
+      task.stagedFilePath = null
+      task.optimizedFilePath = null
+    } ?: updated
+    UploadNotificationHelper.cancel(appContext, taskId)
+
+    emit(
+      mapOf(
+        "type" to "failed",
+        "taskId" to taskId,
+        "error" to error.toMap(),
+        "task" to finalTask.toMap(),
+      ),
+    )
+  }
+
+  private fun failOrRetry(
+    taskId: String,
+    code: UploadErrorCode,
+    message: String,
+    retryable: Boolean,
+    phase: String?,
+    httpStatus: Int?,
+    providerCode: String?,
+    providerMessage: String?,
+    nativeCause: String?,
+  ): UploadExecutionResult {
+    val record = store.task(taskId) ?: return UploadExecutionResult.FINISHED
+    if (retryable && record.networkPolicy != UploadNetworkPolicy.FAIL_FAST && record.attempt < record.maxAttempts) {
+      scheduleRetry(
+        record = record,
+        code = code,
+        message = message,
+        phase = phase,
+        httpStatus = httpStatus,
+        providerCode = providerCode,
+        providerMessage = providerMessage,
+        nativeCause = nativeCause,
+      )
+      return UploadExecutionResult.RETRY
+    }
+
+    markFailed(
+      taskId = taskId,
+      code = code,
+      message = message,
+      retryable = retryable,
+      phase = phase,
+      httpStatus = httpStatus,
+      providerCode = providerCode,
+      providerMessage = providerMessage,
+      nativeCause = nativeCause,
+    )
+    return UploadExecutionResult.FINISHED
+  }
+
+  private fun scheduleRetry(
+    record: UploadTaskRecord,
+    code: UploadErrorCode,
+    message: String,
+    phase: String?,
+    httpStatus: Int?,
+    providerCode: String?,
+    providerMessage: String?,
+    nativeCause: String?,
+  ) {
+    val delayMs = if (record.background) {
+      retryDelayMs(record.attempt).coerceAtLeast(10_000L)
+    } else {
+      retryDelayMs(record.attempt)
+    }
+    val nextRetryAt = (System.currentTimeMillis() + delayMs).toDouble()
+    val error = UploadErrorPayload(
+      code = code,
+      message = message,
+      retryable = true,
+      taskId = record.id,
+      phase = phase,
+      httpStatus = httpStatus,
+      providerCode = providerCode,
+      providerMessage = providerMessage,
+      nativeCause = nativeCause,
+    )
+    val updated = store.update(record.id) { task ->
+      task.state = UploadState.RETRYING
+      task.error = error
+      task.nextRetryAt = nextRetryAt
+    } ?: return
+    lastProgressEmit.remove(record.id)
+    emit(
+      mapOf(
+        "type" to "retrying",
+        "taskId" to record.id,
+        "attempt" to updated.attempt + 1,
+        "delayMs" to delayMs,
+        "error" to error.toMap(),
+      ),
+    )
+    if (!record.background) {
+      scheduleUpload(updated, delayMs = delayMs, existingWorkPolicy = ExistingWorkPolicy.REPLACE)
+    }
+  }
+
+  private fun retryDelayMs(attempt: Int): Long {
+    var delay = baseRetryDelayMs
+    repeat((attempt - 1).coerceAtLeast(0)) {
+      delay = (delay * 2).coerceAtMost(maxRetryDelayMs)
+    }
+    val jitter = (delay * 0.2 * Math.random()).toLong()
+    return delay + jitter
+  }
+
+  private fun isRetryable(error: Exception, statusCode: Int?): Boolean {
+    if (error.message?.contains("Canceled", ignoreCase = true) == true) {
+      return false
+    }
+    if (error is SocketTimeoutException || error is UnknownHostException) {
+      return true
+    }
+    if (error is IOException) {
+      val message = error.message?.lowercase() ?: ""
+      if (
+        message.contains("timeout") ||
+        message.contains("connection") ||
+        message.contains("network") ||
+        message.contains("host")
+      ) {
+        return true
+      }
+    }
+    if (statusCode != null && statusCode >= 500) {
+      return true
+    }
+    return false
+  }
+
+  private fun parseProviderError(responseBody: String?): ProviderError {
+    if (responseBody.isNullOrBlank()) {
+      return ProviderError(null, null)
+    }
+    runCatching {
+      val json = JSONObject(responseBody)
+      return ProviderError(
+        code = json.optString("Code").takeIf { it.isNotEmpty() }
+          ?: json.optString("code").takeIf { it.isNotEmpty() },
+        message = json.optString("Message").takeIf { it.isNotEmpty() }
+          ?: json.optString("message").takeIf { it.isNotEmpty() },
+      )
+    }
+    return ProviderError(
+      code = xmlValue(responseBody, "Code"),
+      message = xmlValue(responseBody, "Message"),
+    )
+  }
+
+  private fun xmlValue(body: String, name: String): String? {
+    val open = "<$name>"
+    val close = "</$name>"
+    val start = body.indexOf(open)
+    if (start < 0) {
+      return null
+    }
+    val valueStart = start + open.length
+    val end = body.indexOf(close, valueStart)
+    if (end < 0) {
+      return null
+    }
+    return body.substring(valueStart, end)
+  }
+
+  private data class PreparedUploadFile(
+    val file: File,
+    val stagedPath: String?,
+  )
+
+  private fun prepareUploadFile(
+    taskId: String,
+    localUri: String,
+    stagedFilePath: String?,
+  ): PreparedUploadFile {
+    stagedFilePath?.let { staged ->
+      val file = File(staged)
+      if (file.exists() && file.isFile) {
+        return PreparedUploadFile(file, staged)
+      }
+    }
+
+    if (!FileStager.needsStaging(appContext, localUri)) {
+      val file = resolveStableFile(localUri)
+      return PreparedUploadFile(file, null)
+    }
+
+    val staged = FileStager.stageFile(appContext, localUri, taskId)
+    store.update(taskId) { task ->
+      task.stagedFilePath = staged.absolutePath
+    }
+    return PreparedUploadFile(staged, staged.absolutePath)
+  }
+
+  private fun resolveStableFile(uri: String): File {
+    when {
+      uri.startsWith("file://") -> {
+        val path = Uri.parse(uri).path
+          ?: throw UploadManagerException(UploadErrorCode.FILE_NOT_FOUND, "File not found at $uri.")
+        val file = File(path)
+        if (!file.exists() || !file.isFile) {
+          throw UploadManagerException(UploadErrorCode.FILE_NOT_FOUND, "File not found at $uri.")
+        }
+        return file
+      }
+      else -> {
+        val file = if (uri.startsWith("/")) File(uri) else File(uri)
+        if (!file.exists() || !file.isFile) {
+          throw UploadManagerException(UploadErrorCode.FILE_NOT_FOUND, "File not found at $uri.")
+        }
+        return file
+      }
+    }
+  }
+
+  private fun resolveUploadFile(record: UploadTaskRecord): File {
+    record.optimizedFilePath?.let { optimized ->
+      val file = File(optimized)
+      if (file.exists() && file.isFile) {
+        return file
+      }
+    }
+    return prepareUploadFile(
+      taskId = record.id,
+      localUri = record.localUri,
+      stagedFilePath = record.stagedFilePath,
+    ).file
+  }
+
+  private fun cleanupDerivedFilesIfNeeded(record: UploadTaskRecord) {
+    cleanupStagedFileIfNeeded(record)
+    record.optimizedFilePath?.let { path ->
+      CompressionPipeline.cleanup(appContext, path)
+    }
+  }
+
+  private fun cleanupStagedFileIfNeeded(record: UploadTaskRecord) {
+    record.stagedFilePath?.let { path ->
+      FileStager.cleanup(appContext, path)
+    }
+  }
+
+  private fun emit(event: Map<String, Any?>) {
+    eventEmitter?.invoke(event)
+  }
+
+  private fun workName(taskId: String): String = "uploados-upload-$taskId"
+
+  companion object {
+    const val WORK_INPUT_TASK_ID = "taskId"
+    const val WORK_TAG = "uploados-upload"
+
+    @Volatile
+    private var instance: UploadManager? = null
+
+    fun getInstance(context: Context): UploadManager {
+      return instance ?: synchronized(this) {
+        instance ?: UploadManager(context.applicationContext).also { instance = it }
+      }
+    }
+  }
+}
+
+private data class ProviderError(
+  val code: String?,
+  val message: String?,
+)