WorkManager und Hintergrundaufgaben

Hintergrundarbeit unter Android

Was ist WorkManager?

Einrichtung

dependencies {
    implementation 'androidx.work:work-runtime-ktx:2.9.0'
}

Worker erstellen

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

    override suspend fun doWork(): Result {
        return try {
            // This runs on a background coroutine
            val repo = UserRepository(applicationContext)
            repo.syncFromNetwork()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry()
            else Result.failure()
        }
    }
}

OneTimeWorkRequest

val syncWork = OneTimeWorkRequestBuilder<SyncWorker>()
    .setInitialDelay(10, TimeUnit.MINUTES)  // optional delay
    .build()

WorkManager.getInstance(context).enqueue(syncWork)

// With a unique name (prevents duplicates):
WorkManager.getInstance(context).enqueueUniqueWork(
    "sync_work",
    ExistingWorkPolicy.KEEP,   // don't enqueue if already pending
    syncWork
)

PeriodicWorkRequest

val periodicSync = PeriodicWorkRequestBuilder<SyncWorker>(
    repeatInterval = 1, TimeUnit.HOURS
).build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "hourly_sync",
    ExistingPeriodicWorkPolicy.KEEP,
    periodicSync
)

Bedingungen

val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.UNMETERED)  // WiFi only
    .setRequiresBatteryNotLow(true)
    .setRequiresCharging(false)
    .build()

val work = OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context).enqueue(work)

Eingabe- und Ausgabedaten

// Enqueue with input data:
val inputData = workDataOf("user_id" to 42)
val work = OneTimeWorkRequestBuilder<SyncWorker>()
    .setInputData(inputData)
    .build()

// Inside the Worker:
class SyncWorker(...) : CoroutineWorker(...) {
    override suspend fun doWork(): Result {
        val userId = inputData.getInt("user_id", -1)

        // Pass output data back:
        val output = workDataOf("synced_count" to 10)
        return Result.success(output)
    }
}

Arbeitsstatus beobachten

val workRequest = OneTimeWorkRequestBuilder<SyncWorker>().build()
WorkManager.getInstance(this).enqueue(workRequest)

WorkManager.getInstance(this)
    .getWorkInfoByIdLiveData(workRequest.id)
    .observe(this) { info ->
        when (info?.state) {
            WorkInfo.State.RUNNING   -> binding.tvStatus.text = "Syncing..."
            WorkInfo.State.SUCCEEDED -> binding.tvStatus.text = "Done!"
            WorkInfo.State.FAILED    -> binding.tvStatus.text = "Failed"
            else                     -> {}
        }
    }

Arbeit verketten

val downloadWork  = OneTimeWorkRequestBuilder<DownloadWorker>().build()
val processWork   = OneTimeWorkRequestBuilder<ProcessWorker>().build()
val uploadWork    = OneTimeWorkRequestBuilder<UploadWorker>().build()

// Sequential: download → process → upload
WorkManager.getInstance(context)
    .beginWith(downloadWork)
    .then(processWork)
    .then(uploadWork)
    .enqueue()

// Parallel then merge:
WorkManager.getInstance(context)
    .beginWith(listOf(downloadWork, processWork))  // both run in parallel
    .then(uploadWork)                              // runs after both finish
    .enqueue()

WorkManager im Vergleich zu Alternativen

Kurzer Check

Zusammenfassung: WorkManager