At some point you’ll need to collect (receive items) from a Flow (reactive stream) within a Kotlin Coroutine. More than likely you will use a launch on a CoroutineScope, and then collect like this:
scope.launch {
flow
.onEach { println(it) }
.collect()
}This works great, but there is a better way for most use cases. It’s using a function called launchIn. What’s launchIn? It’s just shorthand to do what you did above. This is the equivalent logic as above, but using launchIn.
flow
.onEach { println(it) }
.launchIn(scope)This is less code to write, but more importantly it’ll get you out of some hard to debug situations when collecting from Flows. The non obvious thing to understand is that collect() will block the coroutine until the flow has finished emitting. This behavior is sometimes desired, but for me it’s not in most cases.
In the example below, you’d think that both Flows are being collected at the same time, but flow1 is collected until the Flow finishes emitting, and then flow2 is collected until it is finished emitting.
scope.launch {
flow1
.onEach { println(it) }
.collect()
// Will not run until flow1 finishes emitting
flow2
.onEach { println(it) }
.collect()
}To collect both in parallel, you’d need to write this:
scope.launch {
flow1
.collect { println(it) }
}
scope.launch {
flow2
.collect { println(it) }
}This is where launchIn comes to the rescue to make this reach much easier in my opinion. Here is the equivalent using launchIn:
myFlow1
.onEach { println(it) }
.launchIn(coroutineScope)
myFlow2
.onEach { println(it) }
.launchIn(coroutineScope)I like launchIn because it’s less code to write, I don’t have to have indentation, and I just found it easier to understand.
In no way does this mean that the normal launch() and collect() aren’t great things to use, but for most use cases, I’d suggest considering using launchIn().
