Kotlin Night Berlin: RxJava & Coroutines: A Practical Analysis

Kotlin has taken the Android world by storm, and is quickly becoming the most popular language, with coroutines approaching stability, does it make sense to replace your RxJava implementations for Coroutines?

Despite the hype, it may not make sense to jump on the bandwagon just yet, with RxJava having already proven its stability and usefulness, and in many cases the comparison between the two frameworks showing that they simply fit different purposes.

In this talk, you can learn how you can utilise the strengths of each framework, how to correctly choose the best solution for the requirements of your project, whether it may be beneficial to migrate or run them concurrently, and how you can start doing so for your project.

Transcript

1. RxJava & Coroutines: A Practical Analysis ashdavies.io - @askashdavies
4. !
5. Adoption
6. 7.7% (2015)
7. 19.5% (2016) 7.7% (2015)
8. 46.8% (2017) 19.5% (2016) 7.7% (2015)
9. blog.jetbrains.com/kotlin/2016/02/kotlin-1-0-released-pragmatic-language-for-jvm-and-android/
10. Multi Platform
11. Coroutines
12. fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) }
13. fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) }
14. fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) }
15. ⚖ Stability
16. async / launch
17. val deferred: Deferred<String> = async { "Hello" }
18. val result: String = deferred.await()
19. val job: Job = launch { "Hello" }
20. job.join()
21. Annotations bit.ly/2BrxgKv
22. ! Here be dragons
23. ⚠ @ExperimentalCoroutinesApi
24. ⚠ @ObsoleteCoroutinesApi
25. ☠ @InternalCoroutinesApi
27. Coroutines ! Best thing since sliced bread
28. ! Coroutines
29. ! Native first-party library
30. ! Easy-to-use
31. ! suspend fun
32. Dispatchers.Main
33. ! History of Android
34. Background Processes
35. ! Runnable / Handler
36. ! AsyncTask
37. ! IntentService
38. ! Loader<T>
39. WorkManager
40. Background Processes AlarmManager , AsyncTask , CountDownTimer , FutureTask<T> , GcmNetworkManager , Handler , HandlerThread , IntentService , JobDispatcher , JobScheduler , Loader<T> , ScheduledThreadPoolExecutor , Timer , Task<T> , WorkManager
41. https://xkcd.com/927/
42. RxJava to the rescue
43. ⛓ Chained operations
44. ⬆ ⬇ Abstracted threading
45. ! Reactive programming
46. !
53. ! Asynchronous API's
54. ! Synchronous API's
55. Observable.fromIterable()
56. Flowable / Observable / Single / Completable / Maybe
58. ! Observable .fromIterable(resourceDraft.getResources()) .flatMap(resourceServiceApiClient::createUploadContainer) .zipWith(Observable.fromIterable(resourceDraft.getResources()), Pair::create) .flatMap(uploadResources()) .toList() .toObservable() .flatMapMaybe(resourceCache.getResourceCachedItem()) .defaultIfEmpty(Resource.getDefaultItem()) .flatMap(postResource(resourceId, resourceDraft.getText(), currentUser, resourceDraft.getIntent())) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()) .subscribe( resource -> repository.setResource(resourceId, resource, provisionalResourceId), resourceUploadError(resourceId, resourceDraft, provisionalResourceId) );
60. ⚙ Hidden complexity
61. ! Hidden gotchas
62. ! Memory footprint
63. ⤴ Steep learning curve
64. http://explosm.net/comics/3185/
66. #RxMustDie pca.st/7IJG
67. "When all you have is a hammer, everything looks like a nail" Ivan Morgillo (@hamen)
68. Reactive & Imperative programming
69. Coroutine Use Cases
70. Network Call Handling // RxJava2 fun getUser(): Single<User> = Single.fromCallable { /* ... */ } // Coroutine suspend fun getUser(): User = /* ... */
71. Cache Retrieval // RxJava2 fun getUser(): Maybe<User> = Maybe.fromCallable { /* ... */ } // Coroutine suspend fun getUser(): User? = /* ... */
72. Background Task Handling // RxJava2 fun storeUser(user: User): Completable.fromCallable { /* ... */ } // Coroutine suspend fun storeUser(user: User) { /* ... */ }
73. RxJava2 / Coroutines Single<T> / T Maybe<T> / T? Completable / Unit
74. Thread Handling // RxJava2 getUser() .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .subscribe { /* Do something */ } // Coroutine launch(Dispatchers.Main) { val user = getUser() /* Do something */ }
75. ! FlatMap // RxJava2 getUser() .flatMap { doSomethingWithUser(it) } .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .subscribe { /* Do something else */ } // Coroutine launch(Dispatchers.Main) { val user = getUser() val smth = doSomethingWithUser(user) /* Do something else */ }
76. Callback Consumption // RxJava2 fun getSingle(): Single = Single.create<T> { emitter -> doSomethingAsync(object: Callback<T> { override fun onComplete(result: T) = emitter.onSuccess(result) override fun onException(exception: Exception) = emitter.onError(exception) }) } // Coroutine suspend fun getCoroutine() : T = suspendCoroutine { continuation -> doSomethingAsync(object : Callback<Baz> { override fun onComplete(result: T) = continuation.resume(result) override fun onException(exception: Exception) = continuation.resumeWithException(exception) }) }
77. Task Cancellation // RxJava2 val disposable: Disposable = Single.create { /* Do something */ } .subscribe { /* Do something else */ } disposable.dispose() // Coroutine val parent: Job = Job() launch(Dispatchers.Main + parent) { /* Do something */ } parent.cancelChildren()
78. Lifecycle Task Cancellation bit.ly/2POmNBJ
79. Lifecycle Task Cancellation class MainActivity : AppCompatActivity { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) lifecycle.coroutineScope.launch { someSuspendFunction() someOtherSuspendFunction() someCancellableSuspendFunction() } } }
80. Value Streams // RxJava2 val publisher = PublishSubject() publisher.subscribe { /* Do something */ } publisher.onNext("Hello") // Coroutine val channel = Channel<String>() launch { channel.send("Hello") } launch { channel.consumeEach { /* Do something */ } }
81. ! Backpressure
82. Channels bit.ly/2DQU7lb
83. RxJava Use Cases
84. ↔ Channels
85. ❄ Cold Streams
86. ⚙ Complex Business Logic
87. Coroutines & RxJava: An Asynchronicity Comparison Manuel Vivo (@manuelvicnt) bit.ly/2R27stP
88. Is Coroutines a replacement for RxJava?
89. Maybe...
90. Should I migrate to Coroutines?
91. Probably not...
92. "Don't fix what ain't broke" Some Guy
94. Did "I" migrate to Coroutines?
95. ! Yes!
96. How could I migrate to Coroutines?
97. ! Migration Policy
98. Retrofit Services
99. Retrofit2 Coroutines Adapter bit.ly/2TyGXOh com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:+
100. interface UserService { @GET("/user") fun getUser(): Deferred<User> } val retrofit = Retrofit.Builder() .baseUrl("https://example.com/") .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build() GlobalScope.launch { val user = retrofit .create<UserService>() // >= 2.5.0 .getUser() .await() }
101. interface UserService { @GET("/user") fun getUser(): Deferred<User> } val retrofit = Retrofit.Builder() .baseUrl("https://example.com/") .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build() GlobalScope.launch { val user = retrofit .create<UserService>() // >= 2.5.0 .getUser() .await() }
102. interface UserService { @GET("/user") fun getUser(): Deferred<User> } val retrofit = Retrofit.Builder() .baseUrl("https://example.com/") .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build() GlobalScope.launch { val user = retrofit .create<UserService>() // >= 2.5.0 .getUser() .await() }
103. interface UserService { @GET("/user") fun getUser(): Deferred<User> } val retrofit = Retrofit.Builder() .baseUrl("https://example.com/") .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build() GlobalScope.launch { val user = retrofit .create<UserService>() // >= 2.5.0 .getUser() .await() }
104. Coroutines RxJava2 bit.ly/2DQ2ZYn org.jetbrains.kotlinx:kotlinx-coroutines-rx2:+
105. Name Result Scope Description [rxCompletable] Completable [CoroutineScope] Cold completable that starts coroutine on subscribe [rxMaybe] Maybe [CoroutineScope] Cold maybe that starts coroutine on subscribe [rxSingle] Single [CoroutineScope] Cold single that starts coroutine on subscribe [rxObservable] Observable [ProducerScope] Cold observable that starts coroutine on subscribe [rxFlowable] Flowable [ProducerScope] Cold observable that starts coroutine on subscribe with backpressure support
106. val service: UserService = /* ... */ GlobalScope.rxSingle { service.getUser() } .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()) .subscribe( { /* Do something with user */ }, { /* Handle error ... maybe */ } )
107. ! Conclusion
109. Cheers! ! ashdavies.io - @askashdavies