A Practical Guide To understand Rx Streams

RxJava has helped us solve complex problems with ease and made our code manageable. In this talk we discuss how Capital One Wallet app uses RxJava 2, with practical examples. In our app, we follow Uncle Bob’s Clean Architecture with reactive approach. Our app has come a long way from using callbacks to RxJava 1 and eventually to RxJava 2. During this talk, we will discuss lots of tips and tricks that can help you prevent common mistakes.

This talk is suitable for intermediate users of Rx.

Transcript

1. A Practical Guide To master Rx Streams @Mayank_Mehta Capital One
2. Pre-requisite • Curious about using RxJava 2.0 in clean architecture
3. Agenda • Terminology • Operators • Subject • Schedulers • Reactive Source • Architecture • Appendix
4. Architecture View state Repository Use case Presenter View Presentation Layer Domain Layer Data Layer Observable<T> Observable<T> Observable<T>
5. MVVM + RxJava • Modular • Testable • Concurrency is easy • Better code • Happy developers
6. Terminology
7. Source • Something that provides data
8. Sources in RxJava • Observable<T> • Flowable<T> • Single<T> • Maybe<T> • Completable<T>
9. Observable • Emits 0 – n items • Terminates with complete or error 1 3 2 4
10. Observable subscribe with observer public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete() }
11. Observable subscribe with observer public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete(); }
12. Observable subscribe with observer public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete(); }
13. Observable subscribe with observer public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete(); }
14. Observable subscribe with observer public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete(); }
15. Observable subscribe with consumer public interface Consumer<T> { void accept(@NonNull T t) throws Exception; }
16. Observable subscribe with consumer public interface Consumer<T> { void accept(@NonNull T t) throws Exception; }
17. Single • Emits an item or errors out 1
18. Maybe • Emits an item or completes or errors out 1
19. Completable • Either completes or errors out
20. Operators
21. What are Operators? • They are functions to create, transform, filter, combine etc reactive source • Like builder pattern, you can chain methods, except order matters
22. Merge • Combine output of multiple observables into one 1 Merge 4 3 5 1 2 3 4 5 2
23. Concat • Concatenates output of multiple observables • Subscribes to one observable at a time and waits for current one to complete 1 Concat 4 3 5 1 2 3 4 5 2
24. FlatMap • Transform the items emitted by an Observable into Observables • Flatten the emissions • Emissions may interleave 1 FlatMap 3 2 4 1 2 3 4
25. Problem • User does multiple search • Reflect changes from last API call
26. SwitchMap • Like flatmap • Except, mirrors recently emitted source observable SwitchMap 1 2 2
27. ConcatMap • Like FlatMap • Except, emissions do not interleave 1 ConcatMap 3 2 4 2 1 3 4
28. Problem • Multiple API calls simultaneously • Wait for response from each API • Apply transformation
29. Zip • Combine emissions of multiple Observables • Waits for one item from each source Zip 1 1A A 2 B 2B
30. Problem • Wait for search to finish
31. Debounce • Only emit an item from an Observable if a particular timespan has passed without it emitting another item Debounce (500 msec) 1 3 2 4 5 1 4 5
32. Subject
33. What are Subject? • Broadcasts to many • Broadcasts when no one is listening • Listens from many pc - http://www.iconsplace.com/e13491-icons/walkie-talkie-radio-icon
34. Subject public abstract class Subject<T> extends Observable<T> implements Observer<T> { } public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete(); }
35. Do you really need Subject? public abstract class Subject<T> extends Observable<T> implements Observer<T> { } public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete(); } Terminal event
36. RxRelay to Rescue public abstract class Relay<T> extends Observable<T> implements Consumer<T> { } public interface Consumer<T> { void accept(@NonNull T t) throws Exception; }
37. RxRelay to Rescue public abstract class Relay<T> extends Observable<T> implements Consumer<T> { } public interface Consumer<T> { void accept(@NonNull T t) throws Exception; }
38. Types of RxRelay • PublishRelay • BehaviorRelay
39. PublishRelay • Only emit items after observer subscribes • Login/Logout events PublishRelay 0 2 1 3 subscribe() 1 2 2 3 3 subscribe()
40. BehaviorRelay • Emits most recent item and all subsequent items BehaviorRelay 0 2 1 3 1 2 2 3 3 0 1 subscribe() subscribe()
41. Reactive Source
42. Convert to reactive source • Callback • Function
43. Legacy code with callback public interface GetLocationCallback { void onSuccess(@NonNull Location location); void onFailure(@Nullable Status locationSettingsStatus); } public class LocationService { public void getCurrentLocation(final GetLocationCallback newPendingLocationRequest) { } }
44. Source wraps callback with create public Single<Location> getCurrentLocation() { return Single.create(emitter -> { final GetLocationCallback callback = new GetLocationCallback() { @Override public void onSuccess(@NonNull Location location) { emitter.onSuccess(location); } @Override public void onFailure(@Nullable Status locationSettingsStatus) { emitter.onError(new LocationServiceException(locationSettingsStatus)); } }; getCurrentLocation(callback); }); }
45. Source wraps callback with create public Single<Location> getCurrentLocation() { return Single.create(emitter -> { final GetLocationCallback callback = new GetLocationCallback() { @Override public void onSuccess(@NonNull Location location) { emitter.onSuccess(location); } @Override public void onFailure(@Nullable Status locationSettingsStatus) { emitter.onError(new LocationServiceException(locationSettingsStatus)); } }; getCurrentLocation(callback); }); }
46. Source wraps callback with create public Single<Location> getCurrentLocation() { return Single.create(emitter -> { final GetLocationCallback callback = new GetLocationCallback() { @Override public void onSuccess(@NonNull Location location) { emitter.onSuccess(location); } @Override public void onFailure(@Nullable Status locationSettingsStatus) { emitter.onError(new LocationServiceException(locationSettingsStatus)); } }; getCurrentLocation(callback); }); }
47. Source wraps callback with create public Single<Location> getCurrentLocation() { return Single.create(emitter -> { final GetLocationCallback callback = new GetLocationCallback() { @Override public void onSuccess(@NonNull Location location) { emitter.onSuccess(location); } @Override public void onFailure(@Nullable Status locationSettingsStatus) { emitter.onError(new LocationServiceException(locationSettingsStatus)); } }; getCurrentLocation(callback); }); }
48. Source wraps function with fromCallable Single.fromCallable(() -> someHeavyComputation()); • Defers execution until subscription • Handles checked exception • Invokes function for each observer that subscribes
49. Schedulers
50. Types of Schedulers Method Description # of Thread computation Event loops, callbacks and computation work Available processors io Asynchronously blocking IO Unbound newThread Casual use Unbound
51. Operators • subscribeOn • observeOn
52. No thread operator specified Observable.fromCallable(() -> getName()) .doOnNext(id -> {}) .subscribe()
53. Defaults to current thread Observable.fromCallable(() -> getName()) // On Main Thread .doOnNext(id -> {}) // On Main Thread .subscribe() // On Main Thread
54. subscribeOn Observable.fromCallable(() -> getName()) .subscribeOn(Schedulers.computation()) .doOnNext(id -> {}) .subscribe()
55. subscribeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .doOnNext(id -> {}) .subscribe()
56. subscribeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .doOnNext(id -> {}) // Computation Thread .subscribe()
57. subscribeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .doOnNext(id -> {}) // Computation Thread .subscribe() // Computation Thread
58. Multiple subscribeOn Observable.fromCallable(() -> getName()) .subscribeOn(Schedulers.computation()) .subscribeOn(Schedulers.io()) .doOnNext(id -> {}) .subscribe()
59. Multiple subscribeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .subscribeOn(Schedulers.io()) .doOnNext(id -> {}) .subscribe()
60. Multiple subscribeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .subscribeOn(Schedulers.io()) .doOnNext(id -> {}) // Computation Thread .subscribe()
61. Multiple subscribeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .subscribeOn(Schedulers.io()) .doOnNext(id -> {}) // Computation Thread .subscribe() // Computation Thread
62. Multiple subscribeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .subscribeOn(Schedulers.io()) // Has no impact .doOnNext(id -> {}) // Computation Thread .subscribe() // Computation Thread
63. subscribeOn + observeOn Observable.fromCallable(() -> getName()) .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .doOnNext(id -> {}) .subscribe()
64. subscribeOn + observeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .doOnNext(id -> {}) .subscribe()
65. subscribeOn + observeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .doOnNext(id -> {}) // Main Thread .subscribe()
66. subscribeOn + observeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .doOnNext(id -> {}) // Main Thread .subscribe() // Main Thread
67. subscribeOn + observeOn + observeOn Observable.fromCallable(() -> getName()) .subscribeOn(Schedulers.computation()) .observeOn(Schedulers.io()) .doOnNext(id -> {}) .observeOn(AndroidSchedulers.mainThread()) .subscribe()
68. subscribeOn + observeOn + observeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .observeOn(Schedulers.io()) .doOnNext(id -> {}) .observeOn(AndroidSchedulers.mainThread()) .subscribe()
69. subscribeOn + observeOn + observeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .observeOn(Schedulers.io()) .doOnNext(id -> {}) // IO Thread .observeOn(AndroidSchedulers.mainThread()) .subscribe()
70. subscribeOn + observeOn + observeOn Observable.fromCallable(() -> getName()) // Computation Thread .subscribeOn(Schedulers.computation()) .observeOn(Schedulers.io()) .doOnNext(id -> {}) // IO Thread .observeOn(AndroidSchedulers.mainThread()) .subscribe() // Main Thread
71. Architecture
72. Discounts Feature
73. Architecture View state Repository Use case Presenter View Presentation Layer Domain Layer Data Layer Observable<T> Observable<T> Observable<T>
74. Architecture – Data Layer View state Repository Use case Presenter View DB Cloud
75. Repository Single.concat(discountCacheStore.fetchNearbyDiscounts(), discountCloudStore.fetchNearbyDiscount(NearbyRequestBody(lat,lng))) .firstOrError()
76. Cloud Store discountCloudStore .fetchNearbyDiscount(NearbyRequestBody(lat, lng))// Single<NearbyResponse> .filter { it.nearbyMerchants.isNotEmpty() } .map { it.nearbyMerchants } .doOnSuccess { discountCacheStore.updateNearbyCache(it) }
77. Cloud Store discountCloudStore .fetchNearbyDiscount(NearbyRequestBody(lat, lng))// Single<NearbyResponse> .filter { it.nearbyMerchants.isNotEmpty() } // Maybe<NearbyResponse> .map { it.nearbyMerchants } .doOnSuccess { discountCacheStore.updateNearbyCache(it) }
78. Cloud Store discountCloudStore .fetchNearbyDiscount(NearbyRequestBody(lat, lng))// Single<NearbyResponse> .filter { it.nearbyMerchants.isNotEmpty() } // Maybe<NearbyResponse> .map { it.nearbyMerchants } // Maybe<List<Merchants>> .doOnSuccess { discountCacheStore.updateNearbyCache(it) }
79. Cloud Store discountCloudStore .fetchNearbyDiscount(NearbyRequestBody(lat, lng))// Single<NearbyResponse> .filter { it.nearbyMerchants.isNotEmpty() } // Maybe<NearbyResponse> .map { it.nearbyMerchants } // Maybe<List<Merchants>> .doOnSuccess { discountCacheStore.updateNearbyCache(it) } // Side effect
80. Architecture – Domain Layer View state Repository Use case Presenter View public interface WalletUseCase<I, O> { O execute(I input); }
81. Architecture – Presentation Layer View state Repository Use case Presenter View
82. What are view states?
83. Declaring view state sealed class DiscountsViewState { object Loading : DiscountsViewState() data class Error(val error: Throwable) : DiscountsViewState() data class DataReady(val merchantWrappers: List<MerchantWrapper>) :DiscountsViewState() }
84. Declaring view state sealed class DiscountsViewState { object Loading : DiscountsViewState() data class Error(val error: Throwable) : DiscountsViewState() data class DataReady(val merchantWrappers: List<MerchantWrapper>) :DiscountsViewState() }
85. Declaring view state sealed class DiscountsViewState { object Loading : DiscountsViewState() data class Error(val error: Throwable) : DiscountsViewState() data class DataReady(val merchantWrappers: List<MerchantWrapper>) :DiscountsViewState() }
86. onDestroy onDestroy onDetach onDetach onAttach onAttach onCreate onCreate Presenter View Exposes PublishRelay as observable for input Subscribes to BehaviorRelay and updates view Dispose composite disposable for UI Dispose composite disposable for Presenter
87. Presenter View Presentation Layer onAttach Requests Data
88. Presenter View Presentation Layer onAttach Presenter View onDetach Data is received Requests Data Creates UI View State Passes to BehaviorRelay
89. Presenter View Presentation Layer onAttach Presenter View onDetach Data is received Requests Data Presenter View onAttach Subscribes to BehaviorRelay Updates UI with missed view state Only distinct view state Creates UI View State Passes to BehaviorRelay
90. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream
91. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> } // DiscountViewState
92. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> .toObservable() // Maybe to Observable } // DiscountViewState
93. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> .toObservable() // Maybe to Observable .map { DiscountsViewState.DataReady(it) } // Transform } // DiscountViewState
94. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> .toObservable() // Maybe to Observable .map { DiscountsViewState.DataReady(it) } // Transform .onErrorReturn { t: Throwable -> DiscountsViewState.Error(t) } // handle error } // DiscountViewState
95. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> .toObservable() // Maybe to Observable .map { DiscountsViewState.DataReady(it) } // Transform .onErrorReturn { t: Throwable -> DiscountsViewState.Error(t) } // handle error .startWith(DiscountsViewState.Loading) } // DiscountViewState
96. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> .toObservable() // Maybe to Observable .map { DiscountsViewState.DataReady(it) } // Transform .onErrorReturn { t: Throwable -> DiscountsViewState.Error(t) } // handle error .startWith(DiscountsViewState.Loading) } // DiscountViewState .observeOn(AndroidSchedulers.mainThread()) // RxAndroid – Main Thread
97. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> .toObservable() // Maybe to Observable .map { DiscountsViewState.DataReady(it) } // Transform .onErrorReturn { t: Throwable -> DiscountsViewState.Error(t) } // handle error .startWith(DiscountsViewState.Loading) } // DiscountViewState .observeOn(AndroidSchedulers.mainThread()) // RxAndroid – Main Thread .subscribe({ viewState -> statesBehaviorRelay.accept(viewState) }, { // processError })
98. Presenter – onCreate compositePresenterDisposable += fetchNearbyCoupons // PublishRelay - to initiate stream .flatMap { fetchNearbyDiscountsUseCase .execute() // Maybe<List<MerchantWrapper>> .toObservable() // Maybe to Observable .map { DiscountsViewState.DataReady(it) } // Transform .onErrorReturn { t: Throwable -> DiscountsViewState.Error(t) } // handle error .startWith(DiscountsViewState.Loading) } // DiscountViewState .observeOn(AndroidSchedulers.mainThread()) // RxAndroid – Main Thread .subscribe({ viewState -> statesBehaviorRelay.accept(viewState) }, { // processError })
99. Presenter - onAttach compositeUiDisposable += statesBehaviorRelay .distinctUntilChanged() .observeOn(AndroidSchedulers.mainThread()) .subscribe({ viewState -> view.render(viewState) })
100. Presenter - onAttach compositeUiDisposable += statesBehaviorRelay .distinctUntilChanged() .observeOn(AndroidSchedulers.mainThread()) .subscribe({ viewState -> view.render(viewState) })
101. Presenter - onAttach compositeUiDisposable += statesBehaviorRelay .distinctUntilChanged() .observeOn(AndroidSchedulers.mainThread()) .subscribe({ viewState -> view.render(viewState) })
102. Presenter - onAttach compositeUiDisposable += statesBehaviorRelay .distinctUntilChanged() .observeOn(AndroidSchedulers.mainThread()) .subscribe({ viewState -> view.render(viewState) })
103. Presenter - onAttach compositeUiDisposable += states // BehaviorRelay .distinctUntilChanged() .observeOn(AndroidSchedulers.mainThread()) .subscribe({ viewState -> view.render(viewState) })
104. Composite Disposable – clear Vs dispose • Clear will dispose all added disposables • Dispose is like clear except you can not add any more disposables
105. Blogs to bookmark • Jake Wharton - http://jakewharton.com/blog/ • Dan Lew - http://blog.danlew.net/ • Kaushik Gopal - https://kaush.co/ • David Karnok - http://akarnokd.blogspot.com/
106. The End @Mayank_Mehta
107. Appendix
108. What are Subjects • Inherit Observable and implements Observer • Hot Observables • toSerialized() to make Observer method thread safe • Type of Subjects • PublishSubject • BehaviorSubject • ReplaySubject • AsyncSubject
109. Architecture – Presentation Layer • Presenter is aware when view is attached and detached • Presenter creates view states and passes it to BehaviorRelay • Whenever view is attached it gets its states from BehaviorRelay