Do you even (Kotlin) Flow? The new API for Reactive Programming Ricardo Costeira @rcosteira79 Photo by Riccardo Chiarini on Unsplash 

No content

No content

Reactive Programming Coroutines Channels 

Reactive Programming 

● Focus on the data itself ● React to changes in data ● No control over where data comes from ○ helps us avoid asynchronicity issues 

fun getUsers(): Observable { return api.getAllUsers() // Maybe> .filter { it.isNotEmpty() } .flattenAsObservable { it } // Observable } fun getUserDetails(name: String): Maybe { return api.getUserDetails(name) } .flatMapMaybe { getUserDetails(it.name) } .toList() // Single> .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe( { handleDetailedUsers(it) }, { handleErrors(it) } ) getUsers() 

.flatMapMaybe { getUserDetails(it.name) } .toList() // Single> .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe( { handleDetailedUsers(it) }, { handleErrors(it) } ) compositeDisposable.add(getUsers() ) fun getUsers(): Observable { return api.getAllUsers() // Maybe> .filter { it.isNotEmpty() } .flattenAsObservable { it } // Observable } fun getUserDetails(name: String): Maybe { return api.getUserDetails(name) } 

.flatMapMaybe { getUserDetails(it.name) } .toList() // Single> .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe( { handleDetailedUsers(it) }, { handleErrors(it) } ) getUsers() .addTo(compositeDisposable) // Extension function fun getUsers(): Observable { return api.getAllUsers() // Maybe> .filter { it.isNotEmpty() } .flattenAsObservable { it } // Observable } fun getUserDetails(name: String): Maybe { return api.getUserDetails(name) } 

Coroutines 

● Lightweight threads ○ A typical thread on Android: 1 to 2mb ○ A typical coroutine on Android: a couple of bytes ● Provide mechanisms to jump between different thread types ● Use suspending functions to pause/continue execution (without blocking the thread) ● Perform async computations with sequential looking code 

suspend fun getUsers(): List { return api.getAllUsers() } suspend fun getUserDetails(name: String): DetailedUser { return api.getUserDetails(name) } val job = scope.launch { // scope tied to the main thread withContext(Dispatchers.IO) { val users = getUsers() // List .map { async { getUserDetails(it.name) } } // Yay parallelism! .map { it.await() } // Wait for the async calls to finish } // back in the main thread if (users.isNotEmpty()) { handleDetailedUsers(users) } else { handleErrors(NoUsersError()) } } 

Channels 

● Synchronization primitives ● Communicate between sender and receiver through suspending operations ● Hot stream - close it, or leak it ○ channel.close() 

val job = GlobalScope.launch { print("Everything litty, ") produce { send("I love when it's hot") } } job.invokeOnCompletion { print("Turned up the city, ") } Thread.sleep(1000) println("I broke off the notch") Everything litty, I broke off the notch 

val channel = Channel() val job = GlobalScope.launch { print("Everything litty, ") channel.send("I love when it's hot") channel.close() } CoroutineScope(Dispatchers.IO).launch { println(channel.receive()) } job.invokeOnCompletion { print("Turned up the city, ") } Thread.sleep(1000) println("I broke off the notch") Everything litty, I love when it's hot Turned up the city, I broke off the notch 

No content

Kotlin Flow 

● Asynchronously computed cold reactive streams ● Can be built through specific builders ○ flow { }, flowOf(), .asFlow(), etc ● Intermediate operators ○ map, filter, zip, flatMapMerge, etc ● Terminal operators: ○ collect, toList, toSet, launchIn, etc 

fun notFoo(): Flow = flow { for (i in 1..3) { delay(1000) println("Emitting $i") emit(i) } } scope.launch { val flow = notFoo() println("Calling collect!") flow.collect { value -> println("Collecting $value") } println("Again!") flow.collect { value -> println("Collecting $value") } } Emitting 1 Collecting 1 Emitting 2 Collecting 2 Emitting 3 Collecting 3 Emitting 1 Collecting 1 Emitting 2 Collecting 2 Emitting 3 Collecting 3 Calling collect! Again! 

scope.launch { notFoo() .flowOn(Dispatchers.Default) .collect { value -> println("Collecting $value") } } fun notFoo(): Flow = flow { for (i in 1..3) { delay(1000) println("Emitting $i") emit(i) } } 

launch(Dispatchers.Main) { notFoo() } .filter { it % 2 == 0 } // Main // Main 

launch(Dispatchers.Main) { notFoo() } .filter { it % 2 == 0 } .flowOn(Dispatchers.IO) // IO // IO 

launch(Dispatchers.Main) { notFoo() } .filter { it % 2 == 0 } .flowOn(Dispatchers.IO) // IO // IO .map { it * 2 } // Main 

launch(Dispatchers.Main) { notFoo() } .filter { it % 2 == 0 } .flowOn(Dispatchers.IO) // IO // IO .map { it * 2 } // Default .flowOn(Dispatchers.Default) 

launch(Dispatchers.Main) { notFoo() } .filter { it % 2 == 0 } .flowOn(Dispatchers.IO) // IO // IO .map { it * 2 } // Default .flowOn(Dispatchers.Default) .collect { value -> println("Collecting $value") } // Main 

Buffer 1 2 3 Collected in 1220 ms fun main() = runBlocking { val time = measureTimeMillis { notFoo().collect { value -> delay(300) // “processing” it for 300 ms println(value) } } println("Collected in $time ms") } fun notFoo(): Flow = flow { for (i in 1..3) { delay(100) // pretend we are waiting 100 ms emit(i) // emit next value } } 

Buffer fun notFoo(): Flow = flow { for (i in 1..3) { delay(100) // pretend we are waiting 100 ms emit(i) // emit next value } } 1 2 3 Collected in 1071 ms fun main() = runBlocking { val time = measureTimeMillis { notFoo() .buffer() // buffer emissions, don't wait .collect { value -> delay(300) // “processing” it for 300 ms println(value) } } println("Collected in $time ms") } 

Conflate 1 3 Collected in 766 ms fun notFoo(): Flow = flow { for (i in 1..3) { delay(100) // pretend we are waiting 100 ms emit(i) // emit next value } } fun main() = runBlocking { val time = measureTimeMillis { notFoo() .conflate() // conflate emissions, don't process each one .collect { value -> delay(300) // “processing” it for 300 ms println(value) } } println("Collected in $time ms") } 

Latest Collecting 1 Collecting 2 Collecting 3 Done 3 Collected in 741 ms fun notFoo(): Flow = flow { for (i in 1..3) { delay(100) // pretend we are waiting 100 ms emit(i) // emit next value } } fun main() = runBlocking { val time = measureTimeMillis { notFoo() .collectLatest { value -> // cancel & restart on latest println("Collecting $value") delay(300) // pretend we are processing it for 300 ms println("Done $value") } } println("Collected in $time ms") } 

Size limiting operators fun numbers(): Flow = flow { try { emit(1) emit(2) println("This line will not execute") emit(3) } catch (e: Exception) { println(e) } finally { println("Finally in numbers") } } fun main() = runBlocking { numbers() .take(2) // take only the first two .collect { value -> println(value) } } 1 2 kotlinx.coroutines.flow.internal. AbortFlowException: Flow was aborted, no more elements needed Finally in numbers 

Size limiting operators fun numbers(): Flow = flow { emit(1) emit(2) emit(3) } fun main() = runBlocking { numbers() .take(2) // take only the first two .catch { e -> println(e)} .onCompletion { println("Finally in numbers") } .collect { value -> println(value) } } 1 2 Finally in numbers 

Transform suspend fun performRequest(request: Int): String { delay(1000) // imitate long-running asynchronous work return "response $request" } fun main() = runBlocking { (1..3).asFlow() // a flow of requests .transform { request -> emit("Making request $request") emit(performRequest(request)) } .collect { response -> println(response) } } Response 1 Making request 2 Making request 1 Response 2 Making request 3 Response 3 

Flow on Android ● User interactions ● Database updates ● Wherever you need the Observer pattern 

Flow on Android button.setOnClickListener { // do things } 

Flow on Android fun View.clicks(): Flow = callbackFlow { // ProducerScope val listener = View.OnClickListener { offer(Unit) } setOnClickListener(listener) awaitClose { setOnClickListener(null) } } // Usage (RxBinding, anyone?) button.clicks() .map { /* apply operators */ } .collect { /* collect events */ } 

Flow on Android @Dao interface UsersDao { @Query("SELECT * from Users") fun getAllUsers(): } List 

Flow on Android @Dao interface UsersDao { @Query("SELECT * from Users") fun getAllUsers(): } Flow> 

Flow on Android sealed class ViewEvent { object UpdateUsers : ViewEvent() object LoadMoreUsers : ViewEvent() } 

Flow on Android sealed class ViewEvent { object UpdateUsers : ViewEvent() object LoadMoreUsers : ViewEvent() } // SomeActivity fun viewEvents(): Flow { val flows = listOf( updateButton.clicks().map { ViewEvent.UpdateUsers }, loadMoreButton.clicks().map { ViewEvent.LoadMoreUsers }, ) return flows.asFlow().flattenMerge(flows.size) } 

Flow on Android sealed class ViewEvent { object UpdateUsers : ViewEvent() object LoadMoreUsers : ViewEvent() } // SomeActivity fun viewEvents(): Flow { val flows = listOf( updateButton.clicks().map { ViewEvent.UpdateUsers }, loadMoreButton.clicks().map { ViewEvent.LoadMoreUsers }, ) return flows.asFlow().flattenMerge(flows.size) } scope.launch { viewEvents() .collect { viewEvent -> viewModel.processEvent(viewEvent) } } 

Flow on Android sealed class ViewEvent { object UpdateUsers : ViewEvent() object LoadMoreUsers : ViewEvent() } // SomeActivity fun viewEvents(): Flow { val flows = listOf( updateButton.clicks().map { ViewEvent.UpdateUsers }, loadMoreButton.clicks().map { ViewEvent.LoadMoreUsers }, ) return flows.asFlow().flattenMerge(flows.size) } viewEvents() .onEach { viewEvent -> viewModel.processEvent(viewEvent) } .launchIn(scope) 

Flow on Android data class ViewState( val isLoading: Boolean = false, val users: List = emptyList(), val possibleFailure: Failure = Failure.NoFailure ) 

Flow on Android data class ViewState( val isLoading: Boolean = false, val users: List = emptyList(), val possibleFailure: Failure = Failure.NoFailure ) // SomeViewModel private val _state = ConflatedBroadcastChannel() val stateFlow = _state.asFlow() 

Flow on Android data class ViewState( val isLoading: Boolean = false, val users: List = emptyList(), val possibleFailure: Failure = Failure.NoFailure ) // SomeViewModel private val _state = ConflatedBroadcastChannel() val stateFlow = _state.asFlow() val newState: ViewState = /** Compute new state, according to view event */ 

Flow on Android data class ViewState( val isLoading: Boolean = false, val users: List = emptyList(), val possibleFailure: Failure = Failure.NoFailure ) // SomeViewModel private val _state = ConflatedBroadcastChannel() val stateFlow = _state.asFlow() val newState: ViewState = /** Compute new state, according to view event */ _state.offer(newState) 

Flow on Android data class ViewState( val isLoading: Boolean = false, val users: List = emptyList(), val possibleFailure: Failure = Failure.NoFailure ) // SomeViewModel private val _state = ConflatedBroadcastChannel() val stateFlow = _state.asFlow() val newState: ViewState = /** Compute new state, according to view event */ _state.offer(newState) // Collect in Activity stateFlow .onEach { state -> updateUI(state) } .launchIn(scope) 

Resources ● Kotlin Flow official documentation - https://kotlinlang.org/docs/reference/coroutines/flow.html ● Roman Elizarov’s Medium posts about Flow - https://medium.com/@elizarov/cold-flows-hot-channels-d74769805f9 ● Roman Elizarov’s talk at Kotlinconf 2019 - https://www.youtube.com/watch?v=E4F0YU8Jd5g&t=4895s ● David Karnok’s Kotlin Flow Extensions - https://github.com/akarnokd/kotlin-flow-extensions ● Lessons Learnt using Coroutines Flow in the Android Dev Summit 2019 App - https://medium.com/androiddevelopers/lessons-learnt-using-coroutines-flow-4a6b285c0d06 ● Android Dev Summit 2019 App repo - https://github.com/google/iosched/tree/adssched ● “Coroutine + Flow = MVI” by Etienne Caron at Droidcon NYC 2019 - https://www.droidcon.com/media-detail?video=362742098 ● “Flowing Things, not so strange in the MVI world” by Garima Jain at Droidcon NYC 2019 - https://www.droidcon.com/media-detail?video=362742238 

No content

Do you even (Kotlin) Flow? The new API for Reactive Programming Ricardo Costeira @rcosteira79 Photo by Riccardo Chiarini on Unsplash Thank you!