WorkManager Advanced

Work Chaining

WorkManager lets you link work requests so that each step runs only after the previous one succeeds. This creates a dependency graph without manually managing execution order.

val uploadWork = OneTimeWorkRequestBuilder<UploadWorker>().build()
val compressWork = OneTimeWorkRequestBuilder<CompressWorker>().build()
val notifyWork = OneTimeWorkRequestBuilder<NotifyWorker>().build()

WorkManager.getInstance(context)
    .beginWith(uploadWork)
    .then(compressWork)
    .then(notifyWork)
    .enqueue()

// Execution order: upload → compress → notify
// If upload fails, compress and notify are skipped

Parallel Chaining

When multiple work items have no dependency on each other, run them in parallel:

val syncPhotos = OneTimeWorkRequestBuilder<SyncPhotosWorker>().build()
val syncContacts = OneTimeWorkRequestBuilder<SyncContactsWorker>().build()
val syncCalendar = OneTimeWorkRequestBuilder<SyncCalendarWorker>().build()

WorkManager.getInstance(context)
    .beginWith(listOf(syncPhotos, syncContacts, syncCalendar))  // parallel
    .then(OneTimeWorkRequestBuilder<FinalSyncWorker>().build()) // sequential after all
    .enqueue()

Constraints

Constraints define conditions that must be met before work executes. WorkManager automatically defers work until all constraints are satisfied.

val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.UNMETERED)   // Wi-Fi only
    .setRequiresBatteryNotLow(true)                   // skip if battery low
    .setRequiresCharging(true)                        // only while charging
    .setRequiresStorageNotLow(true)                   // skip if storage low
    .setRequiresDeviceIdle(true)                      // Android 6.0+ Doze mode
    .build()

val workRequest = OneTimeWorkRequestBuilder<BackupWorker>
    .setConstraints(constraints)
    .setBackoffCriteria(
        BackoffPolicy.EXPONENTIAL,
        WorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    )
    .build()

Constraint Behavior

Initial Delay

Delay work without creating a new constraint:

val delayedWork = OneTimeWorkRequestBuilder<DailyReportWorker>
    .setInitialDelay(1, TimeUnit.HOURS)
    .build()

Unique Work

Unique work prevents duplicate operations. If a request with the same unique name exists, WorkManager applies the specified policy.

// REPLACE: Cancel existing, enqueue new
WorkManager.getInstance(context)
    .enqueueUniqueWork(
        "DatabaseBackup",
        ExistingWorkPolicy.REPLACE,
        OneTimeWorkRequestBuilder<BackupWorker>().build()
    )

// KEEP: Ignore new request if existing is active
WorkManager.getInstance(context)
    .enqueueUniqueWork(
        "DatabaseBackup",
        ExistingWorkPolicy.KEEP,
        OneTimeWorkRequestBuilder<BackupWorker>().build()
    )

// APPEND: Add new work after existing finishes
WorkManager.getInstance(context)
    .enqueueUniqueWork(
        "DatabaseBackup",
        ExistingWorkPolicy.APPEND,
        OneTimeWorkRequestBuilder<BackupWorker>().build()
    )

Periodic work uses enqueueUniquePeriodicWork — same concept, different method:

WorkManager.getInstance(context)
    .enqueueUniquePeriodicWork(
        "SyncData",
        ExistingPeriodicWorkPolicy.KEEP,
        PeriodicWorkRequestBuilder<SyncWorker>(
            15, TimeUnit.MINUTES  // minimum interval
        ).setConstraints(
            Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .build()
        ).build()
    )

Observing Work Status

Observe work status using WorkInfo to react to completion, failure, or progress:

// Observe a specific work request
WorkManager.getInstance(context)
    .getWorkInfoByIdLiveData(uploadRequest.id)
    .observe(this) { workInfo ->
        when (workInfo?.state) {
            WorkInfo.State.ENQUEUED -> showQueued()
            WorkInfo.State.RUNNING -> showProgress(workInfo.progress)
            WorkInfo.State.SUCCEEDED -> showSuccess()
            WorkInfo.State.FAILED -> showError(workInfo.outputData)
            WorkInfo.State.CANCELLED -> showCancelled()
            else -> {}
        }
    }

// Observe unique work by name
WorkManager.getInstance(context)
    .getWorkInfosForUniqueWorkLiveData("DatabaseBackup")
    .observe(this) { workInfos ->
        val allSucceeded = workInfos.all { it.state == WorkInfo.State.SUCCEEDED }
        if (allSucceeded) updateUI()
    }

Progress Updates

Workers can report progress during execution:

class UploadWorker : CoroutineWorker(context, params) {
    override suspend fun doWork(): Result {
        val files = getInputData().getStringArray("files") ?: return Result.failure()

        files.forEachIndexed { index, file ->
            uploadFile(file)
            setProgress(
                Data.Builder()
                    .putInt("progress", (index + 1) * 100 / files.size)
                    .putString("currentFile", file)
                    .build()
            )
        }

        return Result.success(
            Data.Builder()
                .putInt("uploadedCount", files.size)
                .build()
        )
    }
}

Input and Output Data

Workers communicate through Data bundles:

// Enqueue with input
val request = OneTimeWorkRequestBuilder<ProcessWorker>
    .setInputData(
        Data.Builder()
            .putString("inputPath", "/sdcard/photo.jpg")
            .putInt("quality", 85)
            .build()
    )
    .build()

// Read output
WorkManager.getInstance(context)
    .getWorkInfoByIdLiveData(request.id)
    .observe(this) { info ->
        if (info?.state == WorkInfo.State.SUCCEEDED) {
            val outputPath = info.outputData.getString("outputPath")
        }
    }

Cancellation

// Cancel specific work
WorkManager.getInstance(context).cancelWorkById(uploadRequest.id)

// Cancel all work by tag
WorkManager.getInstance(context).cancelAllWorkByTag("upload")

// Cancel unique work
WorkManager.getInstance(context).cancelUniqueWork("DatabaseBackup")