Coroutines and Rx: A battle towards Asynchronicity

Coroutines and Rx: A Battle Towards Asynchronicity @droid_singh ⚔

Reactive Extensions “Push Based Updates”

showsApi.getShowByName("Friends") .flatmap { showsApi.getCharacters(it.id) } .subscribe( { /* do something
with characters*/ }, { /* handle errors retrieving characters*/} )

showsApi.getShowByName("Friends") .flatmap { showsApi.getCharacters(it.id) } .subscribe( { /* do something
with characters*/ }, { /* handle errors retrieving characters*/} ) -Ben Christensen

Coroutines “Non blocking subroutines”

CoroutineScope.launch(Dispatchers.IO){ val show = showsApi.getShowByName("Friends") val characters = showsApi.getCharacters(show.id) withContext(Dispatchers.Main){
// do something with characters on UI } }

I O CoroutineScope.launch(Dispatchers.IO){ val show = showsApi.getShowByName("Friends") val characters =
showsApi.getCharacters(show.id) withContext(Dispatchers.Main){ // do something with characters on UI } }

I O 0 sm.item = "Friends" sm.label = 1 CoroutineScope.launch(Dispatchers.IO){
val show = showsApi.getShowByName("Friends") val characters = showsApi.getCharacters(show.id) withContext(Dispatchers.Main){ // do something with characters on UI } }

I O 0 sm.item = "Friends" sm.label = 1 showsApi.getShowsByName(“Friends”,
cont) Continuation CoroutineScope.launch(Dispatchers.IO){ val show = showsApi.getShowByName("Friends") val characters = showsApi.getCharacters(show.id) withContext(Dispatchers.Main){ // do something with characters on UI } }

I O 0 1 show = sm.result sm.label = 2
sm.item = "Friends" sm.label = 1 showsApi.getShowsByName(“Friends”, cont) CoroutineScope.launch(Dispatchers.IO){ val show = showsApi.getShowByName("Friends") val characters = showsApi.getCharacters(show.id) withContext(Dispatchers.Main){ // do something with characters on UI } }

showsApi.getCharacters(show.id, cont) sm.item = "Friends" sm.label = 1 showsApi.getShowsByName(“Friends”, cont) Continuation CoroutineScope.launch(Dispatchers.IO){ val show = showsApi.getShowByName("Friends") val characters = showsApi.getCharacters(show.id) withContext(Dispatchers.Main){ // do something with characters on UI } }

showsApi.getCharacters(show.id, cont) sm.item = "Friends" sm.label = 1 showsApi.getShowsByName(“Friends”, cont) Continuation 2 characters = sm.result CoroutineScope.launch(Dispatchers.IO){ val show = showsApi.getShowByName("Friends") val characters = showsApi.getCharacters(show.id) withContext(Dispatchers.Main){ // do something with characters on UI } }

⚔ ASYNCHRONICITY

“Do not walk away from complexity, Run” ! ! !
- Venkat Subramaniam

Round 1: The Initial Combat ⚔

HTTP over Retrofit.Builder() .baseUrl(MoviesApiInterface.MOVIES_ENDPOINT) .addConverterFactory(gsonConverterFactory) .addCallAdapterFactory(rxJavaCallAdapterFactory) .client(okHttp) .build() .create(MoviesApiInterface::class.java)

moviesApi.getLatestMovies( ) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe( { /* do something with
movies*/ }, { /* handle errors retrieving movies*/} ) HTTP over

Retrofit.Builder() .baseUrl(MoviesApiInterface.MOVIES_ENDPOINT) .addConverterFactory(gsonConverterFactory) .addCallAdapterFactory(coroutineCallAdapterFactory) .client(okHttp) .build() .create(MoviesApiInterface::class.java) HTTP over

CoroutineScope.launch{ val data = moviesApiInterface.getInTheatreMoviesAsync().await() withContext(Dispatchers.Main){ // do something with
data } } HTTP over

Operators Learning

~11k ~3k https://github.com/KeepSafe/dexcount-gradle-plugin

Complexity Most Most

Round 2: Let’s catch that ⚔

Error Propagation over 1 2 3 5 N N /
N - 4 4

Error Propagation over 1 2 3 5 N N /
N - 4 -1/3 -1 -3 Destructive 4

Error Handling • Wrap your response in Result class sealed
class Result<out T> { data class Success<out T>(val data: T) : Result<T>() data class Error(val exception: Exception) : Result<Nothing>() } • Gotta catch them all onError onErrorReturn onErrorResumeNext doOnError onErrorComplete onErrorReturnItem

Error Handling fun getMovies(): Observable<Result<Response>> { return moviesApi.getMovies() .map {
Result.Success(it) } .onErrorReturn { Result.Error(it) } }

Error Handling fun getMovies(): Observable<Result<Response>> { return moviesApi.getMovies() .map {
Result.Success(it) } .onErrorReturn { Result.Error(it) } } Result

Error Propagation over

Error Propagation over Parent-Child Relationship

Error Propagation over Parent-Child Relationship Exceptions  Bubbling  Tendency

Error Propagation over

“Exceptions are like virus for Coroutines” Error Propagation over

Error Handling over • Depends on what Coroutine Builder you
are using: Launch/Async? • Scope Intelligently • Tools for handling ☠ CoroutineExceptionHandler try/catch

Error Handling over private val context: CoroutineContext = Job() +
Dispatchers.IO val scope = CoroutineScope(context) suspend fun longRunningTask(): Unit { delay(100) throw IllegalArgumentException() } • Setup

Error Handling over • launch CoroutineBuilder scope.launch{ launch{ longRunningTask() }
}

Error Handling over • Install CoroutineExceptionHandler private val ceh =
CoroutineExceptionHandler { _, e -> println("CEH Handled Crash [$e]") } scope.launch(ceh){ launch{ longRunningTask() } }

Error Handling over • Async CoroutineBuilder scope.launch{ async{ longRunningTask() }.await()
}

Error Handling over • Install try/catch scope.launch(ceh){ try{ async{ longRunningTask()
}.await() } catch(e: Throwable){ println("Caught") } }

suspend fun <T : Any> apiCall(call: suspend () -> Result<T>,
errorMessage: String): Result<T> { return try { call() } catch (e: Exception) { Result.Error(e) } } Let’s be a pro

suspend fun <T : Any> apiCall(call: suspend () -> Result<T>,
errorMessage: String): Result<T> { return try { call() } catch (e: Exception) { Result.Error(e) } } Result Let’s be a pro

Let’s be a pro suspend fun getLatestMovies(): Result<MovieResults> { return
apiCall( { val data = moviesApiInterface.getInTheatreMoviesAsync().await() return@apiCall Result.Success(data.body()) }, "Couldn't get" ) } So, Now are we pro?

suspend fun getLatestMovies(): Result<MovieResults> { return apiCall( { val data
= moviesApiInterface.getInTheatreMoviesAsync().await() return@apiCall Result.Success(data.body()) }, "Couldn't get" ) } So, Now are we pro? No Let’s be a pro

Round 3: Let’s zip them ⚔

Zip Calls in Observable.zip(getPopularMovies(), getNowPlayingMovies(), BiFunction<Movies, Movies, Movies> { popularMovies,
topRatedMovies, -> // Filter from popular and top rated movies }.subscribeOn(Scheduler.io())

Zip Calls in Let’s apply TEST rule Observable.zip(getPopularMovies(), getNowPlayingMovies(), BiFunction<Movies,
Movies, Movies> { popularMovies, topRatedMovies, -> // Filter from popular and top rated movies }.subscribeOn(Scheduler.io())

Zip Calls in Threading Exception Handling Scalability Transforming results Observable.zip(getPopularMovies(),
getNowPlayingMovies(), BiFunction<Movies, Movies, Movies> { popularMovies, topRatedMovies, -> // Filter from popular and top rated movies }.subscribeOn(Scheduler.io())

Zip Calls in • Let’s cook zip *

Zip Calls in suspend fun <T1, T2, R> zip(source1: Deferred<T1>,
source2: Deferred<T2>, zipper: (T1, T2) -> R) = coroutineScope { // wait for two calls to complete async { zipper(source1.await(), source2.await()) } } • Let’s cook zip *

source2: Deferred<T2>, zipper: (T1, T2) -> R) = coroutineScope { // wait for two calls to complete async { zipper(source1.await(), source2.await()) } } • Let’s cook zip * Zip Deferred 1 Deferred 2 Zipper Result

source2: Deferred<T2>, zipper: (T1, T2) -> R) = coroutineScope { // wait for two calls to complete async { zipper(source1.await(), source2.await()) } } • Let’s cook zip *

Zip Calls in coroutineScope.launch { val popularMovies = async{ getPopularMovies()
} val topRatedMovies = async{ getTopRatedMovies() } zip(popularMovies, topRatedMovies) { popularResults, topRatedResults -> // Filter from popular and top rated movies return filteredResults }.await() } Threading Exception Handling Scalability Transforming results

Zip Calls in Threading Exception Handling Scalability Transforming results coroutineScope.launch
{ val popularMovies = async{ getPopularMovies() } val topRatedMovies = async{ getTopRatedMovies() } zip(popularMovies, topRatedMovies) { popularResults, topRatedResults -> // Filter from popular and top rated movies return filteredResults }.await() }

Round 4: Managing States ⚔

https://jakewharton.com/the-state-of-managing-state-with-rxjava/

State Management through val events = searchButton.clicks() .map { SearchEvent(searchEditText.text.toString())
} Power of RxBindings

State Management through Rich with operators, Adheres to R&FP, exceptional
handling,   lifecycle management, etc. val models = events.flatMap { moviesClient.searchMovies(it.searchTerm) } .map { it.results.asResult() } .onErrorReturn { Result.Error(it.toApplicationError()) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread())

What about Coroutines?

What about Coroutines? Flows

State Management through • Suspension based reactive streams. • Can
be used to represent streams

State Management through • Rich with operators, Adheres to R&FP,
exceptional handling,   lifecycle management, etc. viewModelScope.launch { ﬂowOf(moviesClient.searchMoviesAsync(query).await()) .map { Result.Success(it.results) } .catch { Result.Error(it.toApplicationError()) }.collect { searchStates.postValue(it) } }

State Management through • Rich with operators, Adheres to R&FP,
exceptional handling,   lifecycle management, etc. viewModelScope.launch { ﬂowOf(moviesClient.searchMoviesAsync(query).await()) .map { Result.Success(it.results) } .catch { Result.Error(it.toApplicationError()) }.collect { searchStates.postValue(it) } } UI Bindings?

Conclusion

Thank you @droid_singh @amanjeetsingh150

References • https://medium.com/the-kotlin-chronicle/coroutine-exceptions-3378f51a7d33 • https://medium.com/@elizarov/ • https://speakerdeck.com/krlrozov/kotlin-coroutines-ﬂow-is-coming • https://speakerdeck.com/ragdroid/ﬂowing-things-not-so-strange-in-the-mvi-world •
https://github.com/amanjeetsingh150/CoroutinesRx • https://medium.com/capital-one-tech/coroutines-and-rxjava-an-asynchronicity- comparison-part-1-asynchronous-programming-e726a925342a • Kotlin Coroutines Slack Channel • https://github.com/android/plaid

Coroutines and Rx: A battle towards Asynchronicity

Coroutines and Rx: A battle towards Asynchronicity

More Decks by Amanjeet Singh

Other Decks in Programming

Featured

Transcript