Is there any way to force a dispatch when using `Dispatchers.Main.immediate`? `yield()` will not do ...

# coroutines

[ansman]

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]

Seems counter-productive -- why not use Dispatchers.Main?

[ansman]

Because I don’t want other resumes to be deferred

[ansman]

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

[streetsofboston]

Like a post of a Runnable, but putting in front of the queue?

[octylFractal]

maybe withContext(Dispatchers.Main) then?

[ansman]

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 ->
            dispatcher.dispatch(EmptyCoroutineContext, Runnable { cont.resume(Unit) })
        }
    }
}

[streetsofboston]

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

[ansman]

What do you mean, they are both public and well documented

[streetsofboston]

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]

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

[ansman]

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

[streetsofboston]

For now.... 😀

What are you trying to sequence/synchronize?

[ansman]

So my code looks like this essentially:

viewCreatedScope.launch {
  view.awaitPredraw()
  // Setup animation
  defer()
  TransitionManager.beginDelayedTransition(...)
  // Set to final state
}

[octylFractal]

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]

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]

immediate only affects the initial coroutine launch

[ansman]

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

[ansman]

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

[ansman]

Here is the implementation of resumeWith for a coroutine dispatcher:

override fun resumeWith(result: Result<T>) {
        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]

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]

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

[ansman]

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

[ansman]

But I suppose a better name would help

[streetsofboston]

You can call View's or Handler's post from any thread.

[ansman]

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

[streetsofboston]

Yup, true... A different name would be better 😀

[louiscad]

I think yield() should support the immediate dispatcher. You should open an issue on GitHub.

[David Glasser]

Would CoroutineStart.UNDISPATCHED help you?