Kotlin Coroutines Flow is coming to provide a cold asynchronous data stream that emits values sequentially within a coroutine. Flow allows mapping, filtering, and collecting values, handles exceptions transparently, and preserves context. It can integrate with existing APIs like Room and Retrofit using adapters, and is the primary way to handle async streams going forward. Channels will still be used for hot streams and synchronization between coroutines.

1. Kotlin Coroutines
Flow is coming

2. Kirill Rozov
krl.rozov@gmail.com
Lead Android Developer@
@kirill_rozov

3. android_broadcast
News for Android Devs

4. 1. Channels
2. Flows
3. Custom operator
4. Concurrent Flow
5. Flow constraints
6. Adapter
7. Reactive Stream
8. Backpressure
9. Third paNy integrations
Agenda

5. Async in Kotlin
// Single value
suspend fun foo(p: Params): Value =
withContext(Dispatchers.Default) { bar(p) }
// Collection of values
suspend fun foo(p: Params): List<Value> =
buildList { while (hasMore) add(nextValue) }
// Stream of values
fun foo(p: Params): Sequence<Value> =
sequence { while (hasMore) yield(nextValue) }

6. Async in Kotlin
// Single value
suspend fun foo(p: Params): Value =
withContext(Dispatchers.Default) { bar(p) }
// Collection of values
suspend fun foo(p: Params): List<Value> =
buildList { while (hasMore) add(nextValue) }
// Stream of values
fun foo(p: Params): Sequence<Value> =
sequence { while (hasMore) yield(nextValue) }
Blocking

7. Channels

8. Channels
fun CoroutineScope.fooProducer(p: Params)
: ReceiveChannel<Value> {
return produce { while (hasMore) send(nextValue) }
}

9. Channels
fun CoroutineScope.fooProducer(p: Params)
: ReceiveChannel<Value> {
return produce { while (hasMore) send(nextValue) }
}
val values: ReceiveChannel<Value> = fooProducer(p)
if (someCondition) {
return anotherResult // Oops! Leaked channel
}
// ... do further work with values ...

10. • Works with data sources that are intrinsically hot
Data sources that exist without application’s requests for them
• incoming network connections
• event streams
• Synchronization primitives
• For transfer data between coroutines
• Synchronize access to the same data from multiply coroutines
Channels

11. Flows

12. Flow is a cold asynchronous data stream that
executed sequentially (in the same coroutine)
emits values and completes normally or with an
exception
kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/

13. GlobalScope.launch {
flowOf(1, 2, 3)
.map { it * it }
.collect { print(it) }
}
Flow

14. Flow
interface Flow<out T> {
suspend fun collect(collector: FlowCollector<T>)
}

15. Flow
interface Flow<out T> {
suspend fun collect(collector: FlowCollector<T>)
}
interface FlowCollector<in T> {
suspend fun emit(value: T)
}

16. Builders
// From fixed set of values
val flowA = flowOf(1, 2, 3)
// From function type () -> T
val flowB = { repeat(3) { it + 1 } }.asFlow()
// Sequential call to the emit() function
val flowC = flow {
emit(1)
emit(2)
emit(3)
}

17. fun <T> Iterator<T>.asFlow(): Flow<T>
fun <T> Iterable<T>.asFlow(): Flow<T>
fun <T> emptyFlow(): Flow<T>
fun <T> Array<T>.asFlow(): Flow<T>
fun IntRange.asFlow(): Flow<Int>
fun <T> Sequence<T>.asFlow(): Flow<T>
fun <T> (() -> T).asFlow(): Flow<T>
fun <T> flow(
block: suspend FlowCollector<T>.() -> Unit
): Flow<T>
Builders

18. • map / mapNotNull
• switchMap
• combineLatest
• debounce / sample
• delayEach / delayFlow
• Zlter / ZlterNot / ZlterIsInstance / ZlterNotNull
• zip
• catch
• onEach / onCompletion
• atMapConcat / atMapMerge
• a]enConcat / a]enMerge
Intermediate
Operators
* Full list of available operators can be found in official documentation kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/

19. • collect
• single / Zrst
• toList / toSet / toCollection
• count
• fold / reduce
• launchIn / produceIn / broadcastIn
Terminal
Operators

20. Custom Operator

21. Built-in
Operators
interface Flow<out T> {
suspend fun collect(collector: FlowCollector<T>)
}
// Extension-oriented design approach
fun <T, R> Flow<T>.map(
transform: suspend (value: T) -> R
): Flow<R>

22. Custom
Operator
fun <T : Number> Flow<T>.sqrts(): Flow<Double> {
return flow { // this: FlowCollector<Double>
collect { number ->
val value = sqrt(number.toDouble())
emit(value)
}
}
}

23. Custom
Operator
fun <T : Number> Flow<T>.sqrts(): Flow<Double> {
return flow { // this: FlowCollector<Double>
collect { number ->
val value = sqrt(number.toDouble())
emit(value)
}
}
}
GlobalScope.launch {
flowOf(1, 2, 3)
.map { sqrt(it.toDouble()) }
.sqrts()
.collect()
}

24. Custom
Operator
fun <T : Number> Flow<T>.sqrts(): Flow<Double> {
return flow { // this: FlowCollector<Double>
collect { number ->
val value = sqrt(number.toDouble())
emit(value)
}
}
}
GlobalScope.launch {
flowOf(1, 2, 3)
.map { sqrt(it.toDouble()) }
.sqrts()
.collect()
}

25. Concurrent Flow

26. emi]er
collector

27. emi]er
collector

28. emi]er
collector
Coroutine A
Coroutine B

29. Concurrent Flow
fun <T> Flow<T>.buffer(
capacity: Int = Channel.UNLIMITED
): Flow<T> = flow {
val channel = coroutineScope.produce(capacity) {
collect { send(it) }
}
channel.consumeEach { emit(it) }
}

30. Concurrent Flow
fun <T> Flow<T>.buffer(capacity: Int): Flow<T>
fun <T> Flow<T>.produceIn(
scope: CoroutineScope
): ReceiveChannel<T>
fun <T> Flow<T>.broadcastIn(
scope: CoroutineScope,
start: CoroutineStart = CoroutineStart.LAZY
): BroadcastChannel<T>
fun <T> channelFlow(
block: suspend ProducerScope<T>.() -> Unit
): Flow<T>

31. Flow Constraints

32. • Context preservation
Flow encapsulates its own execution context and never propagates or leaks it
downstream
Flow Constraints

33. Context
Preservation
flow {
withContext(Dispatchers.Default) {
emit(longComputation())
}
}

34. Context
Preservation
flow {
withContext(Dispatchers.Default) {
emit(longComputation())
}
}
java.lang.IllegalStateException: Flow invariant is violated: flow was collected in
[Context A info], but emission happened in [Context B info]. Please refer to
'flow' documentation or use 'flowOn' instead

35. Context
Preservation
flow { emit(longComputation()) }
.flowOn(Dispatchers.Default)

36. Context
Preservation
flow {
GlobalScope.launch(Dispatchers.IO) // is prohibited
withContext(Dispatchers.Default) // is prohibited
emit(1) // OK
coroutineScope {
emit(2) // OK -- still the same coroutine
}
}

37. • Context preservation
Flow encapsulates its own execution context and never propagates or leaks it
downstream
• Exception transparency
Flow implementations never catch or handle exceptions that occur in
downstream <ows
Flow Constraints

38. flow<Any> {
try {
emitValue()
} catch (e: Exception) {
println("Error handled $e")
}
}
.map { process1() }
.collect { process2() }
Exception
Transparency

39. flow<Any> { emitValue() }
.map { process1() }
// catches exceptions in emitValue() and process1()
.catch { e -> println("Error handled $e") }
// throws exceptions from process2()
.collect { process2() }
Exception
Transparency

40. Old ways adapter

41. interface Stream<D> {
fun subscribe(callback: Callback<D>)
fun unsubscribe(callback: Callback<D>)
}
interface Callback<D> {
fun onNext(item: D)
fun onError(error: Throwable)
fun onCompleted()
}
Old ways adapter

42. val stream = Stream<Value>()
callbackFlow<Value> { // this: ProducerScope<Value>
// ProducerScope<Value> extends SendChannel<Value>
val callback = object : Callback<Value> {
override fun onNext(item: Value) { offer(item) }
override fun onError(error: Throwable) { close(error) }
override fun onCompleted() { close() }
}
stream.subscribe(callback)
awaitClose { stream.unsubscribe(callback) }
}
Old ways adapter

43. Reactive Streams

44. RxJava Operator
fun <T> Observable<T>.filter(
predicate: (T) -> Boolean
): Observable<T> = ObservableFilter(this, predicate)

45. RxJava Operator
class ObservableFilter<T>(
private val source: ObservableSource<T>,
private val predicate: (T) -> Boolean
) : Observable<T>(), HasUpstreamObservableSource<T> {
override fun source(): ObservableSource<T> = source
override fun subscribeActual(observer: Observer<in T>) {
source.subscribe(FilterObserver(observer, predicate))
}
internal class FilterObserver<T>(
actual: Observer<in T>,
private val filter: (T) -> Boolean
) : BasicFuseableObserver<T, T>(actual) {
override fun onNext(t: T) {
if (sourceMode == QueueFuseable.NONE) {
try {
if (filter(t)) downstream.onNext(t)
} catch (e: Throwable) {
fail(e)
}
} else {
downstream.onNext(null)
}
}
override fun requestFusion(mode: Int) = transitiveBoundaryFusion(mode)
override fun poll(): T? {
while (true) {
val v = qd.poll()
if (v == null || filter(v)) return v
}
}
}
}
fun <T> Observable<T>.filter(
predicate: (T) -> Boolean
): Observable<T> = ObservableFilter(this, predicate)

46. Flow Operator
fun <T> Flow<T>.filter(
predicate: suspend (T) -> Boolean
): Flow<T> {
return flow {
collect {
if (predicate(it)) emit(it)
}
}
}

47. Migration from
RxJava
RxJava 2 Coroutine
Single<T> Deferred<T> !❄
Maybe<T> Deferred<T?> !❄
Completable Job !❄
Observable<T>
Channel<T> !
Flow<T> ❄
Flowable<T>

48. fun <T> Observable<T>.toFlow(): Flow<T>
fun <T> Single<T>.toFlow(): Flow<T>
fun <T> Maybe<T>.toFlow(): Flow<T>
fun <T> Flowable<T>.toFlow(): Flow<T>
RxJava2 to Flow
Adapters

49. fun <T> Observable<T>.toFlow(): Flow<T>
fun <T> Single<T>.toFlow(): Flow<T>
fun <T> Maybe<T>.toFlow(): Flow<T>
fun <T> Flowable<T>.toFlow(): Flow<T>
NO FROM THE BOX :) WRITE YOU OWNRxJava2 to Flow
Adapters

50. Third-paNy library
integration

51. @Dao
interface SampleDao {
}
// Request data and observe changes with RxJava
@Query("SELECT * FROM ENTITIES")
fun queryEntities(): Observable<List<Entity>>Room
// Blocking request data
@Query("SELECT * FROM ENTITIES")
fun queryEntities(): List<Entity>

52. @Dao
interface SampleDao {
}
// Request data and observe changes with RxJava
@Query("SELECT * FROM ENTITIES")
fun queryEntities(): Observable<List<Entity>>Room
// Blocking request data
@Query("SELECT * FROM ENTITIES")
fun queryEntities(): List<Entity>
// Request data using Coroutines
@Query("SELECT * FROM ENTITIES")
suspend fun queryEntities(): List<Entity>

53. @Dao
interface SampleDao {
}
// Request data and observe changes with RxJava
@Query("SELECT * FROM ENTITIES")
fun queryEntities(): Observable<List<Entity>>Room
// Blocking request data
@Query("SELECT * FROM ENTITIES")
fun queryEntities(): List<Entity>
// Request data using Coroutines
@Query("SELECT * FROM ENTITIES")
suspend fun queryEntities(): List<Entity>
// Request data and observe changes using Coroutines
@Query("SELECT * FROM ENTITIES")
fun queryEntities(): Flow<List<Entity>>

54. val database = getSampleDatabase()
GlobalScope.launch {
database.sampleDao.queryEntities().collect {
// Handle updates of entities
}
}
Room

55. interface GitHubService {
}
RetroZt
@GET("users/{user}/repos")
fun listRepos(
@Path("user") user: String
): Call<List<Repo>>

56. interface GitHubService {
}
RetroZt
@GET("users/{user}/repos")
suspend fun listRepos(
@Path("user") user: String
): List<Repo>
@GET("users/{user}/repos")
fun listRepos(
@Path("user") user: String
): Call<List<Repo>>

57. interface GitHubService {
}
RetroZt
@GET("users/{user}/repos")
suspend fun listRepos(
@Path("user") user: String
): List<Repo>
@GET("users/{user}/repos")
fun listRepos(
@Path("user") user: String
): Flow<List<Repo>>
@GET("users/{user}/repos")
fun listRepos(
@Path("user") user: String
): Call<List<Repo>>

58. fun <T> Call<T>.asFlow(): Flow<T> = callbackFlow {
enqueue(object : Callback<T> {
override fun onFailure(call: Call<T>, error: Throwable) {
close(error)
}
override fun onResponse(call: Call<T>, response: Response<T>) {
if (response.isSuccessful) {
offer(response.body()!!)
close()
} else {
close(RetrofitError(response.errorBody()))
}
}
})
awaitClose {
if (!isCanceled) {
cancel()
}
}
}
class RetrofitError(val errorBody: ResponseBody?) : Throwable()
RetroZt

59. val service = getGitHubService()
GlobalScope.launch {
service.listRepos("user-id")
.asFlow()
.collect {
// handle response
}
}
RetroZt

60. • Flow will be primary way to handle async stream
of data
• Channels will be used:
• for hot streams
• “under-the-hood” in some Flow operators
• as synchronization primitive between
Coroutines
What will be the
next?

61. Thank you!
krl.rozov@gmail.com
@android_broadcast
@kirill_rozov