CODEWITHSUNDEEP
androidkotlin-coroutinesandroid-handlerandroid-looperandroid-handlerthread
Augusto Carmo
Augusto Carmo

Reputation: 4964

Handler or Launching a Coroutine Job to do something in the MainThread

I've been wondering about whether it is a better approach to use a Handler (Looper.getMainLooper()) or launch a new Coroutine Job to do small things on the Main Thread, like updating a View.

Handler:

val uiHandler = Handler(Looper.getMainLooper())

fun foo() {
    uiHandler.post { 
        someView.update()
    }
}

Coroutine

fun foo() {
    lifecycleScope.launch {
        someView.update()
    }
}

I really don't know and couldn't find anything related on the Internet, but I'd love to acquire that knowledge.

Upvotes: 6

Views: 1853

Answers (2)

Sep
Sep

Reputation: 371

well they both do the same thing. but if we want to choose we should consider these facts :

  • in performing UI update on main thread, coroutine is recommended. because it has better consistency when coding with coroutines.

  • if you want more control in timing stuff like delaying and posting at desired time, Handler is a better option.

  • finally in today's android development, using coroutines and handling stuff with it is recommended.

Upvotes: 0

BPDev
BPDev

Reputation: 897

You can do both, but I think the common practice is to use coroutines. I don't think handlers are lifecycle aware by default, but coroutines will get cancelled if the view or activity is destroyed. A lot of libraries use suspend functions, so you will have to use coroutines.

Based on this, coroutines add tasks to the event loop just like handlers. I was wondering how coroutines work internally and found this post that uses mainHandler.post { continuation.resume(value) } to dispatch a coroutine, so I doubt there will be major differences in performance.

Upvotes: 1

Related Questions