Background Work with WorkManager

dependencies {
    implementation("androidx.work:work-runtime-ktx:2.10.0") // check for the latest stable version
}

class SyncWorker(
    appContext: Context,
    params: WorkerParameters,
) : CoroutineWorker(appContext, params) {

    override suspend fun doWork(): Result {
        val since = inputData.getLong(KEY_SINCE, 0L)
        return try {
            val count = syncRepository().syncChangesSince(since)     // suspend, main-safe
            Result.success(workDataOf(KEY_COUNT to count))
        } catch (e: IOException) {
            if (runAttemptCount < 5) Result.retry() else Result.failure()
        }
    }

    companion object {
        const val KEY_SINCE = "since"
        const val KEY_COUNT = "count"
    }
}

val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .setRequiresBatteryNotLow(true)
    .build()

// One-time, unique: avoid duplicate syncs if the user taps twice
val oneTime = OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(constraints)
    .setInputData(workDataOf(SyncWorker.KEY_SINCE to lastSync))
    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
    .build()
WorkManager.getInstance(context)
    .enqueueUniqueWork("sync", ExistingWorkPolicy.KEEP, oneTime)

// Periodic: minimum interval is 15 minutes
val periodic = PeriodicWorkRequestBuilder<SyncWorker>(12, TimeUnit.HOURS)
    .setConstraints(constraints)
    .build()
WorkManager.getInstance(context)
    .enqueueUniquePeriodicWork("periodic-sync", ExistingPeriodicWorkPolicy.KEEP, periodic)

WorkManager.getInstance(context)
    .beginUniqueWork("upload", ExistingWorkPolicy.REPLACE, compressRequest)
    .then(uploadRequest)          // receives compress output as input
    .then(cleanupRequest)
    .enqueue()

// Observe progress/state as Flow (e.g. in a ViewModel)
val uploadState: Flow<WorkInfo.State?> =
    WorkManager.getInstance(context)
        .getWorkInfosForUniqueWorkFlow("upload")
        .map { infos -> infos.lastOrNull()?.state }

@HiltWorker
class SyncWorker @AssistedInject constructor(
    @Assisted appContext: Context,
    @Assisted params: WorkerParameters,
    private val repository: SyncRepository,
) : CoroutineWorker(appContext, params) {
    override suspend fun doWork(): Result = /* ... */ Result.success()
}
// Application implements Configuration.Provider with HiltWorkerFactory,
// and the default WorkManager initializer is removed in the manifest.

@Test
fun syncWorker_succeeds() = runTest {
    val worker = TestListenableWorkerBuilder<SyncWorker>(context)
        .setInputData(workDataOf(SyncWorker.KEY_SINCE to 0L))
        .build()
    val result = worker.doWork()
    assertTrue(result is ListenableWorker.Result.Success)
}