Coroutines | A Coroutine framework for AI in games | Game Engine library

If a coroutine was launched and no dispatcher was specified (eg. GlobalScope.launch {}), what dispatcher is used?

If no dispatcher is specified in the coroutine builder, you get the dispatcher from whichever CoroutineScope you're starting your coroutine in. If there is no dispatcher in that scope's context, the coroutine will use Dispatchers.Default (see the doc of launch for instance).

Note that the scope is the receiver of the coroutine builder call:

• if you see GlobalScope.launch { ... } then GlobalScope is the scope
• if you see scope.launch { ... }, look at that scope
• if you see launch { .. } in the wild, some instance of CoroutineScope must be available as this in that piece of code, so that's the parent scope (see below for an example on where it could be coming from)

Here is some info about the dispatchers used in the most common coroutine scopes:

If the scope is GlobalScope, then it doesn't have any dispatcher, so as mentioned before the coroutines will use Dispatchers.Default.

If the scope is lifecycleScope or viewModelScope provided by Android, then coroutines will use Dispatchers.Main.immediate by default.

If the scope is created with the CoroutineScope() factory function without particular dispatcher, Dispatchers.Default will be used (see the "Custom usage" section in the documentation).

If the scope is created using MainScope() and without particular dispatcher, it will use Dispatchers.Main as per the same documentation.

If the scope is provided by runBlocking, then it will use a special dispatcher that works like an event loop and executes your coroutines in the thread that called runBlocking (which is nice because that thread would be blocked anyway).

If the scope is provided by another (outer) coroutine builder like launch or async (which means your coroutine is a child of that coroutine), then the dispatcher will be taken from the scope that was used to launch the parent coroutine, unless they override it. So you can go all the way up until you reach one of the options mentioned above:

If it's not the bandwidth that limits you (but I cannot check this), there is a solution less complicated than the celery and rabbitmq but it is not as scalable as the celery and rabbitmq, it will be limited by your number of CPU.

Instead of splitting calls on celery workers, you split them on multiple processes.

I modified the fetch function like this:

A cold stream does not start producing values until one starts to collect them. A hot stream on the other hand starts producing values immediately.

I would recommend to read below to understand hot and cold steams with usage:

https://balwindersinghrajput.medium.com/complete-guide-to-livedata-and-flow-answering-why-where-when-and-which-6b31496ba7f3

https://developer.android.com/kotlin/flow/stateflow-and-sharedflow

The issue is that your compile SDK is 31, you are targetting API 31 (Android 12) and not setting the exported attribute.

You need to specify android:exported="true" in the manifest.

If your app targets Android 12 and contains activities, services, or broadcast receivers that use intent filters, you must explicitly declare the android: exported attribute for these app components.

I managed to fix this by upgrading compileSdk to 31 and kotlin gradle plugin to 1.5.10

I don't know if it is critical for your problem but modifying this

In some sense, the mess you experience is a consequence of Kotlin coroutines having been an early success, before they became stable. In their experimental days, one thing they lacked was structured concurrency, and a ton of web material got written about them in that state (such as your link 1 from 2017). Some of the then-valid preconceptions remained with people even after their maturation, and got perpetuated in even more recent posts.

The actual situation is quite clear — all you have to understand is coroutine hierarchy, which is mediated through the Job objects. It doesn't matter whether it's a launch or an async, or any further coroutine builder — they all behave uniformly.

With this in mind, let's go through your examples:

This seems to be a legacy implementation for MSVSC. MSVSC implemented coroutines before the standard was formally complete, so there are two implementations of async (/async and /async:strict). I seem to have the old, non–standard-compliant version turned on.

The standard is clear that you cannot use plain return statements in coroutines (emphasis added):

Coroutines cannot use variadic arguments, plain return statements, or placeholder return types (auto or Concept). Constexpr functions, constructors, destructors, and the main function cannot be coroutines.

— https://en.cppreference.com/w/cpp/language/coroutines

You can verify that this is a legacy behavior with a simple example (view in Godbolt):

and an extension function which converts the API into a hot flow

This extension looks correct, however the flow is not hot (nor should it be). It only registers a callback when an actual collection starts, and unregisters when the collector is cancelled (this includes when the collector uses terminal operators that limit the number of items, such as .first() or .take(n)).

This is quite an important note to keep in mind for your other questions.

In the absence of that SupervisorJob(), it appears that test will never end. Maybe collecting the flow never ends for some reason, which I don't understand

As mentioned above, due to how the flow is constructed (and how the CallbackApi works), the flow collection cannot end by decision of the producer (the callback API). It can only stop by cancellation of the collector, which will also unregister the correponding callback (which is good).

The reason your custom job allows the test to end is probably because you're escaping structured concurrency by overriding the job in the context by a custom one that doesn't have that current job as parent. However you're likely still leaking that neverending coroutine from the scope that is never cancelled.

I'm feeding captured callback in a separate coroutine.

And that's correct, although I don't understand why you call removeListener from this separate coroutine. What callback are you unregistering here? Note that this also cannot have any effect on the flow, because even if you could unregister the callback that was created in the callbackFlow builder, it wouldn't magically close the channel of the callbackFlow, so the flow wouldn't end anyway (which I'm assuming is what you tried to do here).

Also, unregistering the callback from outside would prevent you from checking it was actually unregistered by your production code.

2- If I remove the launch body which callbackSlot.captured.onResult(10) is inside it, test will fail with this error UninitializedPropertyAccessException: lateinit property captured has not been initialized. I would think that yield should start the flow.

yield() is quite brittle. If you use it, you must be very conscious about how the code of each concurrent coroutine is currently written. The reason it's brittle is that it will only yield the thread to other coroutines until the next suspension point. You can't predict which coroutine will be executed when yielding, neither can you predict which one the thread will resume after reaching the suspension point. If there are a couple suspensions, all bets are off. If there are other running coroutines, all bets are off too.

A better approach is to use kotlinx-coroutines-test which provides utilities like advanceUntilIdle which makes sure other coroutines are all done or waiting on a suspension point.

Now how to fix this test? I can't test anything right now, but I would probably approach it this way:

• use runTest from kotlinx-coroutines-test instead of runBlocking to control better when other coroutines run (and wait for instance for the flow collection to do something)
• start the flow collection in a coroutine (just launch/launchIn(this) without custom scope) and keep a handle to the launched Job (return value of launch/launchIn)
• call the captured callback with a value, advanceUntilIdle() to ensure the flow collector's coroutine can handle it, and then assert that the list got the element (note: since everything is single threaded and the callback is not suspending, this would deadlock if there was no buffer, but callbackFlow uses a default buffer so it should be fine)
• optional: repeat the above several times with different values and confirm they are collected by the flow
• cancel the collection job, advanceUntilIdle(), and then test that the callback was unregistered (I'm not a Mockk expert, but there should be something to check that removeListener was called)

Note: maybe I'm old school but if your CallbackApi is an interface (it's a class in your example, but I'm not sure to which extent it reflects the reality), I'd rather implement a mock manually using a channel to simulate events and assert expectations. I find it easier to reason about and to debug. Here is an example of what I mean