In modern Android development, performing heavy calculations or long-running tasks on the main thread is a bad practice as it can cause the UI to freeze. Instead, these tasks should be offloaded to worker threads. However, updating the UI based on calculations running in a worker thread can be challenging. In this article, we explore multiple approaches—from traditional techniques to modern Compose-native methods—for updating the UI during such scenarios.
1. Using Handler and Thread (Traditional Approach)
This approach involves creating a worker thread and using a Handler to post updates to the main thread.
Code Example
val handler = Handler(Looper.getMainLooper())
Thread {
for (i in 1..100) {
Thread.sleep(50) // Simulate work
val progress = i
handler.post {
// Update UI
progressText = "Progress: $progress%"
}
}
}.start()
Pros:
- Simple and straightforward.
- No additional libraries are required.
Cons:
- Verbose and error-prone.
- Harder to manage lifecycle events.
- Not well-suited for Compose.
2. Using AsyncTask (Deprecated)
AsyncTask was previously the go-to solution for background work. It provided methods to communicate results to the main thread.
Code Example
@Deprecated("Deprecated in API level 30")
class MyAsyncTask(private val onProgressUpdate: (String) -> Unit) : AsyncTask<Void, Int, Void>() {
override fun doInBackground(vararg params: Void?): Void? {
for (i in 1..100) {
Thread.sleep(50)
publishProgress(i)
}
return null
}
override fun onProgressUpdate(vararg values: Int?) {
val progress = values[0] ?: 0
onProgressUpdate("Progress: $progress%")
}
}
Pros:
- Built-in methods for updating the UI.
Cons:
- Deprecated since API 30.
- Poor lifecycle awareness.
3. Using HandlerThread
HandlerThread allows you to create a background thread with a Looper for posting messages.
Code Example
val handlerThread = HandlerThread("MyWorkerThread").apply { start() }
val handler = Handler(handlerThread.looper)
handler.post {
for (i in 1..100) {
Thread.sleep(50)
val progress = i
Handler(Looper.getMainLooper()).post {
progressText = "Progress: $progress%"
}
}
}
Pros:
- Better than plain
HandlerandThread.
Cons:
- Requires manual lifecycle management.
- Verbose.
4. Using LiveData
LiveData is lifecycle-aware and works well with Compose.
Code Example
val progressLiveData = MutableLiveData<String>()
viewModelScope.launch(Dispatchers.IO) {
for (i in 1..100) {
delay(50) // Simulate work
progressLiveData.postValue("Progress: $i%")
}
}
progressLiveData.observe(lifecycleOwner) { progress ->
progressText = progress
}
Pros:
- Lifecycle-aware.
- Easy to integrate with Compose using
observeAsState.
Cons:
- Requires additional boilerplate in Compose.
5. Using StateFlow and CoroutineScope (Recommended Modern Approach)
StateFlow is a Compose-friendly and lifecycle-aware solution.
Code Example
val progressFlow = MutableStateFlow("Progress: 0%")
viewModelScope.launch(Dispatchers.IO) {
for (i in 1..100) {
delay(50) // Simulate work
progressFlow.value = "Progress: $i%"
}
}
@Composable
fun ProgressUI(progressFlow: StateFlow<String>) {
val progress by progressFlow.collectAsState()
Text(text = progress)
}
Pros:
- Compose-friendly.
- Lifecycle-aware.
- Cleaner integration with UI.
Cons:
- Requires familiarity with
StateFlowand Coroutines.
6. Using Worker and WorkManager
If the task is suitable for background work that requires persistence, you can use WorkManager.
Code Example
class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
override fun doWork(): Result {
for (i in 1..100) {
Thread.sleep(50)
setProgressAsync(workDataOf("PROGRESS" to i))
}
return Result.success()
}
}
@Composable
fun ProgressUI(workInfo: WorkInfo) {
val progress = workInfo.progress.getInt("PROGRESS", 0)
Text(text = "Progress: $progress%")
}
Pros:
- Great for persistent background tasks.
- Lifecycle-aware.
Cons:
- Overhead for simple tasks.
- Best suited for persistent tasks.
Which Approach is Best?
For modern Android development with Jetpack Compose, StateFlow with Coroutines is the best option. It is lifecycle-aware, Compose-friendly, and ensures clean code with less boilerplate. LiveData is a close second for projects already using it, but it’s less ideal for new Compose projects. Use WorkManager if persistence and task scheduling are required.
Why StateFlow?
- Compose Integration: Works seamlessly with
collectAsStatein Compose. - Lifecycle Awareness: Automatically handles lifecycle changes.
- Scalability: Suitable for simple to complex state management.
Choose the approach that aligns best with your project requirements, but for most Compose-based apps, StateFlow is the way to go!
Thank you for reading my latest article! I would greatly appreciate your feedback to improve my future posts. 💬 Was the information clear and valuable? Are there any areas you think could be improved? Please share your thoughts in the comments or reach out directly. Your insights are highly valued. 👇😊. Happy coding! 💻✨
Posts
