Is there any way to force a dispatch when using `Dispatchers

Question

Is there any way to force a dispatch when using `Dispatchers Main immediate` `yield ` will not do anything `delay 1 ` works but is kind of ugly

octylFractal · Answer

Seems counter productive why not use `Dispatchers Main`

ansman · Answer

Because I don t want other resumes to be deferred

ansman · Answer

Specifically I need to make something happen on the next frame on Android

streetsofboston · Answer

Like a `post` of a Runnable but putting in front of the queue

octylFractal · Answer

maybe `withContext Dispatchers Main ` then

ansman · Answer

Yeah I suppose that would work Now I implemented a general purpose version ``` suspend fun defer val dispatcher = coroutineContext ContinuationInterceptor as CoroutineDispatcher if dispatcher == null Timber w No coroutine dispatcher found using delay instead delay 1 else suspendCancellableCoroutine cont gt dispatcher dispatch EmptyCoroutineContext Runnable cont resume Unit ```

streetsofboston · Answer

This looks fragile to me It requires hidden private knowledge on how delay and dispatcher dispatch work

ansman · Answer

What do you mean they are both public and well documented

streetsofboston · Answer

What if 1 millisecond is too long What if dispatcher dispatch runs the provided Runnable immediately in case `defer` is called on the main thread I d write something myself to make the synchronization you need more explicit instead of relying on delay or dispatcher dispatch

ansman · Answer

`dispatcher dispatch` will always post it to the queue even on the immediate dispatcher

ansman · Answer

1ms cannot be too long since a frame is 16ms

streetsofboston · Answer

For now grinning What are you trying to sequence synchronize

ansman · Answer

So my code looks like this essentially ``` viewCreatedScope launch view awaitPredraw Setup animation defer TransitionManager beginDelayedTransition Set to final state ```

octylFractal · Answer

I suspect that you really don t need `immediate` any suspend point that actually suspends will still re dispatch since coroutine suspension removes the code from the thread and any point that doesn t suspend will continue in the same thread regardless of `immediate`

streetsofboston · Answer

Also <https kotlin github io kotlinx coroutines kotlinx coroutines core kotlinx coroutines coroutine dispatcher dispatch html> It doesn t promise to post the Runnable to a queue It may choose a short path in case the calling thread is already on the dispatcher s thread

octylFractal · Answer

`immediate` only affects the initial coroutine launch

ansman · Answer

It wouldn t work without `immediate` since it would actually draw the frame where i want to set up the animation

ansman · Answer

And it s not true that it only affects the launch it won t dispatch if you resume while on the main thread

ansman · Answer

Here is the implementation of `resumeWith` for a coroutine dispatcher ``` override fun resumeWith result Result lt T gt val context = continuation context val state = result toState if dispatcher isDispatchNeeded context state = state resumeMode = MODE ATOMIC DEFAULT dispatcher dispatch context this else executeUnconfined state MODE ATOMIC DEFAULT withCoroutineContext this context countOrElement continuation resumeWith result ```

streetsofboston · Answer

I d use the Handler s or View s `post` methods for sync not relying on the Coroutine Dispatchers You can the wrap that in a suspend function called defer

ansman · Answer

And `isDispatchNeeded` would return `false` if called on the main thread when using the immediate dispatcher

ansman · Answer

Fair enough but then `defer` could pretty much only be called on the main thread

ansman · Answer

But I suppose a better name would help

streetsofboston · Answer

You can call View s or Handler s `post` from any thread

ansman · Answer

I know but if you re running on an IO thread it would be weird to call `defer`

streetsofboston · Answer

Yup true A different name would be better grinning

louiscad · Answer

I think `yield ` should support the `immediate` dispatcher You should open an issue on GitHub

David Glasser · Answer

Would CoroutineStart UNDISPATCHED help you