Fantastic Async and Where to Find them

As Android developers in the modern age, we're spoiled for choice when it comes to asynchronous tools: RxJava, LiveData, Kotlin Coroutines and now with AndroidX, ListenableFuture! But how do these architectures scale? How easy is it to onboard new developers? How performant is it?

In this whirlwind expedition, we'll adventure in search of fantastic async solutions to your concurrency problems, spending time to discuss how to implement a flexible, scalable architecture for your application, big or small.

Transcript

1. 1 Parth Padgaonkar
4. Table of Contents I. Background II. Surveying the Landscape III. Fantastic Async IV. Questions (& Answers?) 4
5. Q: Why do devs use async tools? 5 (why don't we write everything blockingly?)
6. Q: Why do devs use async tools? A: Because network calls on the UI thread crash my app ☹
7. Q: Why do devs use async tools? A: Because network calls on the UI thread crash my app ☹
8. Q: Why do devs use async tools? A #2: The world is async, and we have to live in it A: Because network calls on the UI thread crash my app ☹
9. Part II: Surveying the Landscape 9
10. Surveying the Landscape 10
11. Surveying the Landscape 11 Kotlin Coroutines RxJava ListenableFuture LiveData
12. Part III: Fantastic Async 12
13. Fantastic Async - The Scoring System 1. Flexibility 2. Composition 3. Granularity 13
14. Scoring System - Flexibility 1. post messages to the UI thread 2. execute commands from a BG thread 3. choose where to observe messages 14
15. Scoring System - Composition 1. blocking completion 2. chain multiple operations • bonus: fan-out + fan-in 3. bridge into framework from Callable • bonus: bridge from generic callback 15
16. Scoring System - Granularity 1. send [1, ∞] events to observer 2. cancel the async task(s) 3. robust error handling a. per-event b. per-stream 16
17. Fantastic Async
 LiveData Edition 17
18. LiveData -- Flexibility Scorecard post to UI thread execute on background thread choose execution context 18
19. LiveData -- Composition Scorecard blocking completion chain multiple operations bridge into framework 19
20. LiveData -- Composition -- Chaining 20 fun flatMapEquivalent(ld: LiveData<Int>): LiveData<String> { return Transformations.switchMap(ld) { input: Int !-> val ld2 = MutableLiveData<String>() ld2.value = input.toString() return@switchMap ld2 } }
21. LiveData -- Granularity Scorecard send [1, ∞] events to observer cancel the async task(s) robust error handling • per-event • per-stream 21
22. LiveData Scorecard 22 Flexibility Composition Granularity Final Score
23. LiveData - Use Cases 23 Use if... • (Google) frameworks are only sources of async • No complex async interactions Shines as... • event bus to UI thread • public API for ViewModel or Repository
24. Fantastic Async
 ListenableFuture 24
25. ListenableFuture -- Flexibility Scorecard post to UI thread execute on background thread choose execution context 25
26. ListenableFuture -- Flexibility -- UI Thread 26 fun observeCompletionOnUiThread_vanilla() { val future: ListenableFuture<WorkInfo> = WorkManager.getInstance().getWorkInfoById(UUID.randomUUID()) future.addListener(Runnable { try { val workInfo: WorkInfo = future.get() "//here be dragons"!! } catch (e: Exception) { when (e) { is CancellationException "-> Log.e(tag, "canceled!") is ExecutionException "-> Log.e(tag, "future"::get threw the error") is InterruptedException "-> Log.e(tag, "blocking interrupted :(") else "-> throw e } } }, mainThreadExecutor) }
27. ListenableFuture -- Flexibility -- UI Thread 27 fun observeCompletionOnUiThread_guava() { val future: ListenableFuture<WorkInfo> = WorkManager.getInstance().getWorkInfoById(UUID.randomUUID()) Futures.addCallback(future, object : FutureCallback<WorkInfo> { override fun onSuccess(result: WorkInfo?) { Log.d(tag, "success!") } override fun onFailure(t: Throwable) {""...} }, MoreExecutors.newSequentialExecutor(mainThreadExecutor)) }
28. ListenableFuture -- Composition Scorecard blocking completion chain multiple operations bridge into framework 28
29. ListenableFuture -- Composition - Fan Out+In 29 fun flatmap_fanout_fanin_guava(): ListenableFuture<List<State.SUCCESS">> { val wm = WorkManager.getInstance() return FluentFuture.from(wm.getWorkInfosByTag("tag")) .transformAsync(AsyncFunction { works: List<WorkInfo>? !-> if (works "== null) Futures.immediateFailedFuture(RuntimeException()) else { val cancels = mutableListOf<ListenableFuture<State.SUCCESS">>() for (work in works) { cancels += wm.cancelWorkById(work.id).result } Futures.allAsList(cancels) } }, backgroundExecutor) }
30. ListenableFuture -- Composition - Bridging 30 fun bridgeFromCallback(): ListenableFuture<Int> { val lfExec = MoreExecutors.listeningDecorator(backgroundExecutor) val listenableFuture: ListenableFuture<Int> = lfExec.submit(Callable { val latch = CountDownLatch(1) var value = 0 someAsyncCallbackFunction { input: Int !-> latch.countDown() value = input } latch.await() return@Callable value }) return listenableFuture }
31. ListenableFuture -- Granularity Scorecard send [1, ∞] events to observer cancel the async task(s) robust error handling • per-event • per-stream 31
32. ListenableFuture Scorecard 32 Flexibility Composition Granularity Score
33. ListenableFuture - Use Cases 33 Use if... • already using Guava • don't need multiple 
 events/emissions Shines as... • bridge from "legacy" Future • public API for libraries or internal components
34. Fantastic Async
 Coroutines 34
35. Coroutines -- Flexibility Scorecard post to UI thread execute on background thread choose execution context 35
36. Coroutines - Flexibility 36 fun observeUiThread(textView: TextView) { MainScope().launch(Dispatchers.Main) { val user: User = withContext(Dispatchers.IO) { retrofit.randomNetworkCall() } textView.text = "ID: $user.id" } }
37. RxJava - Flexibility 37
38. blocking completion chain multiple operations bridge into framework Coroutines -- Composition Scorecard 38
39. Coroutines - Composition 39 suspend fun first(): Int { delay(50L) return 1 } suspend fun second(): Int { delay(55L) return 2 } suspend fun third(): Int { delay(65L) return 3 }
40. Coroutines - Composition 40 fun chainingSeq(scope: CoroutineScope): Job { return scope.launch { val result = first() + second() + third() "// ^^^^^^ takes 50+55+65=170ms to execute } } suspend fun first(): Int {""...} suspend fun second(): Int {""...} suspend fun third(): Int {""...}
41. Coroutines - Composition 41 fun chainingParallel(scope: CoroutineScope): Job { return scope.launch { val one: Deferred<Int> = async { first() } val two = async { second() } val three = async { third() } val result = one.await() + two.await() + three.await() "// ^^^^^^ takes 65ms to execute } } fun chainingSeq(scope: CoroutineScope): Job suspend fun first(): Int {""...} suspend fun second(): Int {""...} suspend fun third(): Int {""...}
42. Coroutines - Composition 42 suspend fun <T> retrofitCall(request: () "-> Call<T>): Response<T> { return suspendCoroutine { continuation !-> request().enqueue(object : Callback<T> { override fun onFailure(call: Call<T>, t: Throwable) { continuation.resumeWithException(t) } override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) { continuation.resume(response) } else { continuation.resumeWithException(HttpException(response)) } } }) } } https://geoffreymetais.github.io/code/coroutines/
43. Coroutines - Composition 43 suspend fun <T> retrofitCall(request: () "-> Call<T>): Response<T> { return suspendCoroutine { continuation !-> request().enqueue(object : Callback<T> { override fun onFailure(call: Call<T>, t: Throwable) { continuation.resumeWithException(t) } override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) { continuation.resume(response) } else { continuation.resumeWithException(HttpException(response)) } } }) } } https://geoffreymetais.github.io/code/coroutines/
44. Coroutines - Composition 44 suspend fun <T> retrofitCall(request: () "-> Call<T>): Response<T> { return suspendCoroutine { continuation !-> request().enqueue(object : Callback<T> { override fun onFailure(call: Call<T>, t: Throwable) { continuation.resumeWithException(t) } override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) { continuation.resume(response) } else { continuation.resumeWithException(HttpException(response)) } } }) } } https://geoffreymetais.github.io/code/coroutines/
45. Coroutines - Composition 45 suspend fun <T> retrofitCall(request: () "-> Call<T>): Response<T> { return suspendCoroutine { continuation !-> request().enqueue(object : Callback<T> { override fun onFailure(call: Call<T>, t: Throwable) { continuation.resumeWithException(t) } override fun onResponse(call: Call<T>, response: Response<T>) { if (response.isSuccessful) { continuation.resume(response) } else { continuation.resumeWithException(HttpException(response)) } } }) } } https://geoffreymetais.github.io/code/coroutines/
46. Coroutines -- Granularity Scorecard send [1, ∞] events to observer cancel the async task(s) robust error handling • per-event • per-stream 46
47. Coroutines - Composition 47 fun makeApiCall() { MainScope().launch(Dispatchers.Main) { val stringResponse = retrofitCall { apiClient.someNetworkCall() } } } suspend fun <T> retrofitCall(request: () "-> Call<T>): Response<T> {""...}
48. Coroutines - Granularity 48 fun makeApiCallTryCatch() { MainScope().launch(Dispatchers.Main) { val stringResponse: Response<String> = try { retrofitCall { apiClient.someNetworkCall() } } catch (e: HttpException) { "//handle exception Response.success(200, "{}") } } }
49. Coroutines Scorecard 49 Flexibility Composition Granularity Score
50. Coroutines - Use Cases 50 Use if... • 100% Kotlin • no need for mutex/SPSC Shines as... • "under the hood" framework • handle async in tests
51. Fantastic Async
 RxJava 51
52. RxJava -- Flexibility Scorecard post to UI thread execute on background thread choose execution context 52
53. RxJava - Flexibility 53 val retrofit = Retrofit() fun rxFlexibility() { retrofit.randomNetworkCall() "//executes on BG thread .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) 
 "//^^^^^^^^ flip to UI thread .subscribe({ result !-> "/*do something"*/ }, 
 "//^^^^^^^^ runs on UI { err: Throwable !-> "/*do something"*/ }) }
54. blocking completion chain multiple operations bridge into framework RxJava -- Composition Scorecard 54
55. RxJava - Composition 55 fun rxComposition(file: File): List<Any> { return Observable.create { emitter: ObservableEmitter<String> !-> BufferedReader(FileReader(file)).use { reader !-> emitter.onNext(reader.readLine()) } } .map { UUID.randomUUID() } .flatMap({ uuid !-> retrofit.randomNetworkCall2(uuid) }, 3) "//fans out 3 active "rails" until queue is drained .toList() "//fan-in; returns Single<List<Foo">> .blockingGet() }
56. RxJava -- Granularity Scorecard send [1, ∞] events to observer cancel the async task(s) robust error handling • per-event • per-stream 56
57. RxJava - Granularity 57 fun rxGranularity() { lateinit var disposable: Disposable disposable = Observable.fromIterable('a'"..'z') .flatMap { c !-> Observable.just( c.toString(), "//"a" c.toString().repeat(2), "//"aa" c.toString().repeat(3) "//"aaa" ) } .takeUntil { str !-> str.toUpperCase().contains("QQ") } "//cancels .onErrorResumeNext { err: Throwable !-> Observable.just("???") } .subscribe("/*something"*/) disposable.dispose() "//cancels, if not already completed }
58. RxJava Scorecard 58 Flexibility Composition Granularity Score
59. RxJava - Use Cases 59 Use if... • complex async composition • learning curves mean nothing to you Shines as... • Model-View-{Flavor} • wire async through different layers
60. So what do I use in my app? 60
61. So what do I use in my app? A: It's complicated. ¯\_(ツ)_/¯
62. The Landscape - Final Scores 62 LiveData Coroutines ListenableFuture RxJava
63. Links/Sources/Inspiration/Future Reading 63 • GH: musichin/reactivelivedata bit.ly/2Rudxn6 • Guava - ListenableFuture bit.ly/2QOtob3 • KotlinConf '17:
 Intro to Coroutines youtu.be/_hfBv0a09Jc • KotlinLang.org: 
 Guide to Coroutines bit.ly/2HfwLs3 • Geoffrey Métais - Coroutines bit.ly/2AMIp84 • Parth @ Droidcon Berlin '18:
 RxJava Extended: Custom Operators youtu.be/TqrevX2Gtxc
64. 64 Parth Padgaonkar
 parth@august.com