Android WorkManager Guide — Background Task Scheduling
WorkManager handles background tasks reliably across different Android versions, respecting doze mode and battery optimization.
CoroutineWorker Basics
class MyCoroutineWorker(
context: Context,
params: WorkerParameters
) : CoroutineWorker(context, params) {
override suspend fun doWork(): Result {
return try {
val result = performBackgroundTask()
Result.success()
} catch (e: Exception) {
when {
e is IOException -> Result.retry()
else -> Result.failure()
}
}
}
private suspend fun performBackgroundTask(): String {
delay(2000)
return "Task completed"
}
}
WorkRequest with Constraints
OneTimeWorkRequest:
val constraints = Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.setRequiresBatteryNotLow(true)
.setRequiresDeviceIdle(false)
.build()
val workRequest = OneTimeWorkRequestBuilder<MyCoroutineWorker>()
.setConstraints(constraints)
.setBackoffCriteria(
backoffPolicy = BackoffPolicy.EXPONENTIAL,
initialDelay = 15,
timeUnit = TimeUnit.MINUTES
)
.build()
WorkManager.getInstance(context).enqueueUniqueWork(
"sync_work",
ExistingWorkPolicy.KEEP,
workRequest
)
PeriodicWorkRequest
val periodicWorkRequest = PeriodicWorkRequestBuilder<MyCoroutineWorker>(
15, TimeUnit.MINUTES
).setConstraints(constraints).build()
WorkManager.getInstance(context).enqueueUniquePeriodicWork(
"periodic_sync",
ExistingPeriodicWorkPolicy.KEEP,
periodicWorkRequest
)
Input/Output Data
val inputData = workDataOf(
"user_id" to 123,
"action" to "sync"
)
val workRequest = OneTimeWorkRequestBuilder<MyCoroutineWorker>()
.setInputData(inputData)
.build()
// In worker
override suspend fun doWork(): Result {
val userId = inputData.getInt("user_id", -1)
val action = inputData.getString("action")
val outputData = workDataOf(
"result" to "success",
"timestamp" to System.currentTimeMillis()
)
return Result.success(outputData)
}
WorkRequest Chaining
Sequential Execution:
val uploadRequest = OneTimeWorkRequestBuilder<UploadWorker>().build()
val syncRequest = OneTimeWorkRequestBuilder<SyncWorker>().build()
val notifyRequest = OneTimeWorkRequestBuilder<NotifyWorker>().build()
WorkManager.getInstance(context)
.beginWith(uploadRequest)
.then(syncRequest)
.then(notifyRequest)
.enqueue()
Parallel + Sequential:
val task1 = OneTimeWorkRequestBuilder<Task1Worker>().build()
val task2 = OneTimeWorkRequestBuilder<Task2Worker>().build()
val merge = OneTimeWorkRequestBuilder<MergeWorker>().build()
WorkManager.getInstance(context)
.beginWith(listOf(task1, task2)) // Run in parallel
.then(merge) // Then merge results
.enqueue()
Monitor Progress in Compose
@Composable
fun WorkProgressScreen() {
val workManager = WorkManager.getInstance(LocalContext.current)
val workState by workManager
.getWorkInfoByIdLiveData(workId)
.observeAsState()
Column(Modifier.fillMaxSize()) {
when {
workState?.state == WorkInfo.State.RUNNING -> {
val progress = workState?.progress?.getInt("progress", 0) ?: 0
LinearProgressIndicator(progress = progress / 100f)
Text("Progress: $progress%")
}
workState?.state == WorkInfo.State.SUCCEEDED -> {
Text("Task completed successfully")
}
workState?.state == WorkInfo.State.FAILED -> {
Text("Task failed")
}
}
}
}
Key Takeaways
- Use CoroutineWorker for suspending operations
- Set Constraints for optimal execution conditions
- Chain work with beginWith/then for complex flows
- Pass data with workDataOf (JSON serializable types)
- Monitor in UI with observeAsState and Compose
- Implement exponential backoff for network retries
8 Android app templates: Gumroad
SOCIAL SHARE CARD GENERATOR