A modern programming language that makes developers happier.

kotlinlang

I have to use an API that accepts an `Executor` as a parameter. How can I create an `Executor` that is backed by `Dispatchers.Default`? There is no `CoroutineDispatcher.asExecutor()` function unfortunately

I don’t want to spin up a new thread unecessarily

<https://developer.android.com/reference/androidx/biometric/BiometricPrompt.html#BiometricPrompt(androidx.fragment.app.FragmentActivity,%20java.util.concurrent.Executor,%20androidx.biometric.BiometricPrompt.AuthenticationCallback)>

I added a feature request for it here <https://github.com/Kotlin/kotlinx.coroutines/issues/1450>

backing it with a dispatcher isn't going to do much for you in terms of bootstrapping into coroutine-world

I just want the Biometric API to use an already existing thread pool

you can also just use any old handler's `myHandler::post` as an Executor and bounce off the main thread, no need to spin up a different one

if you're processing the results elsewhere you probably want to offer into a channel that you're receiving on or similar instead, from the callback, and just use a directExecutor to do it. It doesn't really matter where the callback is dispatched then

I’m not sure what you mean by a direct executor

a direct executor is one that just runs an incoming runnable inline without any sort of dispatching

but yeah, I would be sending the results to a channel that would be consumed on the main or a `Dispatchers.Default` thread

if your callback implementation just offers into a channel (or the channel of a `callbackFlow`, or similar) then there's no reason to have the executor bounce between threads an extra time

the UI would consume the channel and send the result to the `ViewModel` which processes intentions/actions on `Dispatchers.Default`

whatever you like :slightly_smiling_face: the important part here is that if you're already doing a thread or dispatch hop by sending through a channel or resuming an intercepted continuation, you don't need the Executor to define where the callback should run - it doesn't matter since you're doing your own dispatch into coroutines-land inside the callback itself.

ahh, interesting. the thread the callback executes on doesn’t matter because it will be sent elsewhere anyway :thumbsup:

so you might as well use the fastest executor you can (direct) since you can guarantee that the callback won't block the calling thread

```
val executor = Executor { 
    GlobalScope.launch { it() }
}
```