I have a function doing something like this

fun initialize() {
    coroutineScope.launch {
        <http://log.info|log.info>(TAG, "Start flow collection")
        startFlowCollection(vim.value)
        <http://log.info|log.info>(TAG, "Done with initialization")
    }
}

suspend fun startFlowCollection() = supervisorScope {
    launch { collectFromCallbackFlow1() }
    launch { collectFromCallbackFlow2() } 
}

But I never get “Done with initialization”. I understand callback flows never finish so I collect them inside

launch

to not suspend forever. But it looks like it is suspending forever so I don’t know what I’m doing wrong here.

Is this the actual code? What is the

CoroutineScope

for the 2

launch

-es in

startFlowCollection

? This shouldn't compile as-is, unless

startFlowCollection

is a method in a class that implements

CoroutineScope

itself (which is unlikely)

coroutineScope

comes from

CoroutineScope(SupervisorJob() + <http://Dispatchers.IO|Dispatchers.IO>)

. I tried with

suspend fun initialize

but it didn’t work neither, I though it might be due to the scope being cancelled (the code is part from an android app and initialize was called from a lifecycle scope) so I gave the class containing

initialize

its own coroutine scope

I meant the

launch

calls inside

startFlowCollection

ah, I see, the snippet is missing some code, sorry

Ok now it compiles and makes sense. It's a very important detail. Using

supervisorScope { .. }

here gives a boundary to the lifetime of the 2 launch calls.

startFlowCollection

will only return once the 2 launched coroutines are complete, which never happens if

collectFromCallbackFlowN()

never completes

aaaah, indeed it’s an important details hehe

Let's assume you call those 2

launch

directly inside

initialize

. They would be part of the coroutine scope of the parent

launch

call. It has the same property: it will not complete until the child coroutines are done. So you would get your "Done with initialization" log, but the launched coroutine would still be running. It might be what you want. I don't know. If your definition of "initialization is done" is "the collecting coroutines are launched" (not done!) then it's fine. But then another way to fix it is to just put the log outside the

launch

in

initialize

Yes, I just want to start the collection of the two flows, that’s what “done” meant here. Thanks for the help!

No need for

startFlowCollection

to be suspend fun. Make it an extension fun on CoroutineScope and then just call launch (as in this.launch). Then you’ll not be waiting for the new coroutines

Given how things look (if it's that simple), I'd actually advocate for:

fun initialize() {
    <http://log.info|log.info>(TAG, "Start flow collection")

    coroutineScope.launch { collectFromCallbackFlow1() }
    coroutineScope.launch { collectFromCallbackFlow2() } 

    <http://log.info|log.info>(TAG, "Done with initialization")
}

because there doesn't seem to be a need for an outer launch

If this is just for demonstration of the unerlying concepts, or you need the original semantics this. should work:

fun initialize() {
    coroutineScope.launch {
        <http://log.info|log.info>(TAG, "Start flow collection")
        startFlowCollection(vim.value)
        <http://log.info|log.info>(TAG, "Done with initialization")
    }
}

fun CorotuineScope.startFlowCollection() {
    launch { collectFromCallbackFlow1() }
    launch { collectFromCallbackFlow2() } 
}

But as @Joffrey pointed out, as

startFlowCollection

actually never was actually suspending an now no longer is a suspend fun. you can also call it without an outer launch. All you need is a scope

fun initialize() {
    <http://log.info|log.info>(TAG, "Start flow collection")
    coroutineScope.startFlowCollection(vim.value)
    <http://log.info|log.info>(TAG, "Done with initialization")
}