Hi all, I have a weird behaviour regarding coroutines on Android and I hope that you can help me: I have a suspending function that performs some UI logic

suspend fun showSnackbar() {
    val snackbar = Snackbar.make(...)
    snackbar.show()
    delay(4000)
    snackbar.setAction("...", null) // crash here
    snackbar.dismiss()
}

The functions is called via

launch(Dispatchers.Main) { showSnackbar() }

. Please don't ask why I have to

null

the action. It is required to prevent a false positive memory leak warning. Anyway, the call

snackbar.setAction()

crashes the app with

android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

and I wonder if

delay()

might change the Dispatcher?? 🤔 Thanks for your help!

Pretty sure no dispatcher is changed here. Feel free to throw some logging in there:

Log.d("Thread", "On Thread ${Thread.currentThread}")

This is pretty much all there is of the code. I just abstracted away building the snackbar UI 🤷‍♂️🏼

Did you throw in some logging? You could also add:

Log.d("Thread", "My Dispatcher is ${coroutineContext[CoroutineDispatcher]}")

This has nothing to do with coroutines, it's an Android restriction that you can only fix by running the UI code interacting with Views APIs on the main thread.

I'm aware of this restriction 😉 I run this suspending function like this:

launch(Dispatchers.Main) { showSnackbar() }

@louiscad @svenjacobs writes: The functions is called via 

launch(Dispatchers.Main) { showSnackbar() }

@uli I added logging right after

delay()

and this is the output:

Thread: Thread[DefaultDispatcher-worker-2,5,main]
Dispatcher: Dispatchers.Main

but the next UI code definitely crashes.

do you have a stack trace?

It looks like the thread is one of

Dispatchers.Default

while the

coroutineContext

has

Dispatchers.Main

🤔

Hm, okay, I will check the "backend" code which calls the UI function. Maybe something weird is going on there.

To be sure, instead of wrapping the call to

showSnackbar()

, I'd wrap the body of the function itself with

Dispatchers.Main { … }

You mean

withContext(Dispatchers.Main) { ... }

?

Both work, there's an

operator fun invoke

for

CoroutineDispatcher

.

Okay, sorry for the confusion but it actually was a problem of the backend code. It's a bit more complex. There are cascading coroutine calls and I was of the impression that

launch

inherits the dispatcher... It looked like this

launch(Dispatchers.Main) { someFunc() }

and in

someFunc

...
launch { showSnackbar() }
...

However adding

Dispatchers.Main

to the second

launch

fixes this.

;-)

Thanks for your help, Uli & Louis!

But it did say

Dispatchers.Main

while being on a default dispatcher’s thread?

Thread: Thread[DefaultDispatcher-worker-2,5,main]
Dispatcher: Dispatchers.Main

Yes, after fixing the second

launch

it now says

Thread[main,5,main]

I am more concerned as to why thread and dispatcher did not match

Maybe because of

launch(Dispatchers.Main) {
  launch { ... }
}

?

@svenjacobs Not all UI calls check for the main thread on Android, that's why it didn't crash earlier.