WorkManager Mastery: Reliable Background Processing on Android

@HiltWorker
class ArticleSyncWorker @AssistedInject constructor(
    @Assisted appContext: Context,
    @Assisted params: WorkerParameters,
    private val articleRepo: ArticleRepository
) : CoroutineWorker(appContext, params) {

    override suspend fun doWork(): Result {
        val forceRefresh = inputData.getBoolean("force_refresh", false)

        return try {
            setProgress(workDataOf("progress" to 0))
            val syncCount = articleRepo.syncWithRemote(forceRefresh)
            setProgress(workDataOf("progress" to 100))

            // Output is passed to the next worker in a chain
            Result.success(workDataOf("sync_count" to syncCount))
        } catch (e: HttpException) {
            if (e.code() in 500..599) {
                Result.retry()   // Server error: waiting may fix it
            } else {
                // Client error (4xx): retrying will not help
                Result.failure(workDataOf("error" to e.message))
            }
        } catch (e: IOException) {
            Result.retry()       // Network error: retry with backoff
        }
    }
}

// Application: hand WorkManager the Hilt worker factory
@HiltAndroidApp
class MyApplication : Application(), Configuration.Provider {

    @Inject lateinit var workerFactory: HiltWorkerFactory

    // Configuration.Provider is a property in the current Kotlin API
    override val workManagerConfiguration: Configuration
        get() = Configuration.Builder()
            .setWorkerFactory(workerFactory)
            .build()
}

// Only sync on unmetered network, while charging
val syncConstraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.UNMETERED)   // For example, Wi-Fi
    .setRequiresCharging(true)
    .setRequiresBatteryNotLow(true)   // Not in low battery mode
    .setRequiresStorageNotLow(true)
    .build()

val syncRequest = OneTimeWorkRequestBuilder<ArticleSyncWorker>()
    .setConstraints(syncConstraints)
    .setBackoffCriteria(
        BackoffPolicy.EXPONENTIAL,
        30, TimeUnit.SECONDS          // The default, stated explicitly
    )
    .setInputData(workDataOf("force_refresh" to true))
    .addTag("article_sync")
    .build()

WorkManager.getInstance(context).enqueueUniqueWork(
    "article_sync",
    ExistingWorkPolicy.KEEP,          // A running sync is left alone
    syncRequest
)

// Periodic sync: every 6 hours, inside the last 30 minutes of each period
val periodicSync = PeriodicWorkRequestBuilder<ArticleSyncWorker>(
    repeatInterval = 6, TimeUnit.HOURS,
    flexInterval = 30, TimeUnit.MINUTES
).setConstraints(
    Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .build()
).addTag("periodic_sync")
 .build()

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

// Chain: download images, compress, upload, notify
val downloadWork = OneTimeWorkRequestBuilder<DownloadImagesWorker>()
    .setConstraints(networkConstraints)
    .addTag("image_pipeline")
    .build()

val compressWork = OneTimeWorkRequestBuilder<CompressImagesWorker>()
    .addTag("image_pipeline")
    .build()

val uploadWork = OneTimeWorkRequestBuilder<UploadImagesWorker>()
    .setConstraints(networkConstraints)
    .addTag("image_pipeline")
    .build()

val notifyWork = OneTimeWorkRequestBuilder<NotifyCompletionWorker>()
    .build()

WorkManager.getInstance(context)
    .beginWith(downloadWork)        // Step 1
    .then(compressWork)             // Step 2 receives step 1's output
    .then(uploadWork)               // Step 3
    .then(notifyWork)               // Step 4
    .enqueue()

// Parallel work: fetch from several APIs, then merge
val fetchUsers = OneTimeWorkRequestBuilder<FetchUsersWorker>().build()
val fetchPosts = OneTimeWorkRequestBuilder<FetchPostsWorker>().build()
val fetchComments = OneTimeWorkRequestBuilder<FetchCommentsWorker>().build()

val mergeResults = OneTimeWorkRequestBuilder<MergeDataWorker>()
    // Keep every parent's output instead of the last one written
    .setInputMerger(ArrayCreatingInputMerger::class)
    .build()

WorkManager.getInstance(context)
    .beginWith(listOf(fetchUsers, fetchPosts, fetchComments))  // Parallel
    .then(mergeResults)
    .enqueue()

@HiltViewModel
class SyncViewModel @Inject constructor(
    private val workManager: WorkManager
) : ViewModel() {

    // Observe the same unique work that startSync() enqueues
    val syncState: Flow<SyncUiState> = workManager
        .getWorkInfosForUniqueWorkFlow(MANUAL_SYNC)
        .map { workInfos ->
            val info = workInfos.firstOrNull()
            when (info?.state) {
                WorkInfo.State.RUNNING -> SyncUiState.Syncing(
                    progress = info.progress.getInt("progress", 0)
                )
                WorkInfo.State.SUCCEEDED -> SyncUiState.Success(
                    count = info.outputData.getInt("sync_count", 0)
                )
                WorkInfo.State.FAILED -> SyncUiState.Error(
                    message = info.outputData.getString("error") ?: "Sync failed"
                )
                WorkInfo.State.ENQUEUED -> SyncUiState.Waiting
                else -> SyncUiState.Idle
            }
        }

    fun startSync() {
        val request = OneTimeWorkRequestBuilder<ArticleSyncWorker>().build()
        workManager.enqueueUniqueWork(
            MANUAL_SYNC,
            ExistingWorkPolicy.KEEP,
            request
        )
    }

    fun cancelSync() {
        workManager.cancelUniqueWork(MANUAL_SYNC)
    }

    private companion object {
        const val MANUAL_SYNC = "manual_sync"
    }
}

sealed interface SyncUiState {
    data object Idle : SyncUiState
    data object Waiting : SyncUiState
    data class Syncing(val progress: Int) : SyncUiState
    data class Success(val count: Int) : SyncUiState
    data class Error(val message: String) : SyncUiState
}

@Composable
fun SyncButton(viewModel: SyncViewModel = hiltViewModel()) {
    val state by viewModel.syncState
        .collectAsStateWithLifecycle(SyncUiState.Idle)

    when (val current = state) {
        is SyncUiState.Syncing -> {
            LinearProgressIndicator(
                progress = { current.progress / 100f }
            )
        }
        is SyncUiState.Error -> {
            Button(onClick = { viewModel.startSync() }) {
                Text("Retry Sync")
            }
        }
        else -> {
            Button(onClick = { viewModel.startSync() }) {
                Text("Sync Now")
            }
        }
    }
}