WorkManager

// 1. Worker：定义"做什么"
class SyncWorker(context: Context, params: WorkerParameters)
    : Worker(context, params) {
    override fun doWork(): Result {
        return try {
            syncNotesToServer()          // 执行同步逻辑
            Result.success()             // 成功 → 任务结束
        } catch (e: Exception) {
            Result.retry()               // 失败 → WorkManager 按退避策略自动重试
        }
    }
}
 
// 2. WorkRequest：定义"什么时候做"
val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)   // 需要网络
    .setRequiresCharging(true)                        // 需要充电
    .build()
 
val syncRequest = OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(constraints)
    .setInitialDelay(10, TimeUnit.MINUTES)           // 10 分钟后开始
    .build()
 
// 3. WorkManager：执行调度
WorkManager.getInstance(context).enqueue(syncRequest)

WorkManager.getInstance(context)
    .getWorkInfoByIdLiveData(syncRequest.id)
    .observe(lifecycleOwner) { workInfo ->
        when (workInfo?.state) {
            WorkInfo.State.ENQUEUED -> showStatus("排队等待中...")
            WorkInfo.State.RUNNING -> showStatus("正在同步...")
            WorkInfo.State.SUCCEEDED -> showStatus("同步成功！")
            WorkInfo.State.FAILED -> showStatus("同步失败")
            WorkInfo.State.BLOCKED -> showStatus("等待前置任务完成...")
            else -> {}
        }
    }

// 第 1 个 Worker：压缩图片
class CompressWorker(context: Context, params: WorkerParameters)
    : Worker(context, params) {
    override fun doWork(): Result {
        val imageUri = inputData.getString("IMAGE_URI") ?: return Result.failure()
        val compressedUri = compressImage(imageUri)
 
        // 输出压缩后的图片路径供下一个 Worker 使用
        val output = workDataOf("COMPRESSED_URI" to compressedUri)
        return Result.success(output)
    }
}
 
// 第 2 个 Worker：上传
class UploadWorker(context: Context, params: WorkerParameters)
    : Worker(context, params) {
    override fun doWork(): Result {
        val uri = inputData.getString("COMPRESSED_URI") ?: return Result.failure()
        return try {
            uploadToServer(uri)
            Result.success()
        } catch (e: Exception) {
            Result.retry()
        }
    }
}
 
// 串联执行：先压缩，成功后再上传
val inputData = workDataOf("IMAGE_URI" to photoUri.toString())
 
val compressRequest = OneTimeWorkRequestBuilder<CompressWorker>()
    .setInputData(inputData)
    .build()
 
val uploadRequest = OneTimeWorkRequestBuilder<UploadWorker>()
    .setConstraints(
        Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .build()
    )
    .build()
 
WorkManager.getInstance(context)
    .beginWith(compressRequest)     // 第一步：压缩
    .then(uploadRequest)            // 第二步：等压缩成功后上传
    .enqueue()

WorkManager.getInstance(context)
    .enqueueUniqueWork(
        "daily-sync",                          // 唯一任务名
        ExistingWorkPolicy.REPLACE,            // 如果已存在同名任务，替换它
        syncRequest
    )