Practical RxJava for Android

A practical guide to using RxJava on Android. Tips for improving your app architecture with reactive programming. What are the advantages and disadvantages of using RxJava over standard architecture? And how to connect with other popular Android libraries?
Presented at Droidcon Greece 2016.

Transcript

1. Practical RxJava for Android Tomáš Kypta @TomasKypta
2. What’s RxJava?
3. What’s RxJava? • composable data flow • push concept • combination of • observer pattern • iterator pattern • functional programming
4. RxJava…not sure if…
5. Typical App Event Source Views Network DB … Listener Listener Listener Listener logic logic logic logic State
6. Reactive App Transformation Event Source Observable Observable Observable Observable … Observer Observer Views Network DB
7. RxJava data flow Observable .from(new String[]{"Hello", "Droidcon!"}) creation
8. RxJava data flow Observable .from(new String[]{"Hello", "Droidcon!"}) .map(new Func1<String, String>() { @Override public String call(String s) { return s.toUpperCase(Locale.getDefault()); } }) creation
9. RxJava data flow Observable .from(new String[]{"Hello", "Droidcon!"}) .map(new Func1<String, String>() { @Override public String call(String s) { return s.toUpperCase(Locale.getDefault()); } }) .reduce(new Func2<String, String, String>() { @Override public String call(String s, String s2) { return s + ' ' + s2; } }) creation transformation
10. RxJava data flow Observable .from(new String[]{"Hello", "Droidcon!"}) .map(new Func1<String, String>() { @Override public String call(String s) { return s.toUpperCase(Locale.getDefault()); } }) .reduce(new Func2<String, String, String>() { @Override public String call(String s, String s2) { return s + ' ' + s2; } }) .subscribe(new Action1<String>() { @Override public void call(String s) { Timber.i(s); } }); creation transformation subscription
11. Java 8 & Android • use Retrolambda • or jack compiler • no support for annotation processors • ButterKnife • Dagger • AutoValue
12. RxJava data flow Observable .from(new String[]{"Hello", "Droidcon!"}) .map(new Func1<String, String>() { @Override public String call(String s) { return s.toUpperCase(Locale.getDefault()); } }) .reduce(new Func2<String, String, String>() { @Override public String call(String s, String s2) { return s + ' ' + s2; } }) .subscribe(new Action1<String>() { @Override public void call(String s) { Timber.i(s); } }); creation transformation subscription
13. RxJava flow with Java8 creation transformation subscription Observable .from(new String[]{"Hello", "Droidcon!"}) .map(s -> s.toUpperCase(Locale.getDefault())) .reduce((s,s2) -> s + ' ' + s2) .subscribe(s -> Timber.i(s));
14. Key parts • Observable • Observer or Subscriber • onNext(T) • onCompleted() • onError(Throwable) • Subject
15. What is RxJava good for? • making code simple and readable • Async processing • no AsyncTask, AsyncTaskLoader, … • Async composition • RxJava offers simple chaining of async operations • eliminates callback hell
16. Marble diagrams • RxMarbles
17. Subscription
18. Subscription Subscription s = mAppInfoProvider.getAppsObservable() .subscribe( appInfo -> Timber.i(appInfo.getPackageName() );
19. Subscription Subscription s = mAppInfoProvider.getAppsObservable() .subscribe( appInfo -> Timber.i(appInfo.getPackageName() ); s.unsubscribe();
20. Subscription Subscription s = mAppInfoProvider.getAppsObservable() .subscribe( appInfo -> Timber.i(appInfo.getPackageName() ); s.unsubscribe(); Timber.i("unsubscribed: " + s.isUnsubscribed());
21. CompositeSubscription CompositeSubscription compositeSubscription = new CompositeSubscription();
22. CompositeSubscription CompositeSubscription compositeSubscription = new CompositeSubscription(); compositeSubscription.add(subscription);
23. CompositeSubscription CompositeSubscription compositeSubscription = new CompositeSubscription(); compositeSubscription.add(subscription); compositeSubscription.unsubscribe();
24. CompositeSubscription CompositeSubscription compositeSubscription = new CompositeSubscription(); compositeSubscription.add(subscription); compositeSubscription.unsubscribe(); compositeSubscription.clear();
25. CompositeSubscription CompositeSubscription compositeSubscription = new CompositeSubscription(); compositeSubscription.add(subscription); compositeSubscription.unsubscribe(); compositeSubscription.clear();
26. Bridging non-Rx APIs
27. Bridging non-Rx APIs • create() private Object getData() {...} public Observable<Object> getObservable() { return Observable.create(subscriber -> { subscriber.onNext(getData()); subscriber.onCompleted(); }); }
28. Bridging non-Rx APIs • just() private Object getData() {...} public Observable<Object> getObservable() { return Observable.just(getData()); } !
29. just() & defer() • defer() private Object getData() {...} public Observable<Object> getObservable() { return Observable.defer( () -> Observable.just(getData()) ); }
30. Subject
31. Subject • Observable & Observer • bridge between non-Rx API • stateful • terminal state • don’t pass data after onComplete() or onError()
32. Subject • use carefully • cannot be reused • always create a new instance when subscribing to an Observable
33. Subject Subject subject = … subject.subscribe(subscriber); subject.onNext(A); subject.onNext(B);
34. RxRelay
35. RxRelay • Relay = Subject - onComplete() - onError() • Relay = Observable & Action1 • call() instead of onNext()
36. Subject vs. RxRelay • Subject • stateful • Relay • stateless
37. RxRelay Relay relay = … relay.subscribe(observer); relay.call(A); relay.call(B);
38. Threading
39. Threading • Parts of a data flow can run on different threads! • in RxJava defined by Schedulers
40. Schedulers • computation() • io() • newThread() • from(Executor)
41. Android Schedulers • mainThread() • from(Looper)
42. Threading • operators have default Schedulers • check Javadoc
43. Threading • just() • current thread • delay(long, TimeUnit) • computation() thread
44. Threading • subscribeOn(Scheduler) • subscribes to Observable on the Scheduler • observeOn(Scheduler) • Observable emits on the Scheduler
45. subscribeOn() • multiple calls useless • only the first call works! • for all operators
46. observeOn() • can be called multiple times
47. Async composition
48. Async composition apiEndpoint.login() .doOnNext(accessToken -> storeCredentials(accessToken))
49. Async composition apiEndpoint.login() .doOnNext(accessToken -> storeCredentials(accessToken)) .flatMap(accessToken -> serviceEndpoint.getUser())
50. Async composition apiEndpoint.login() .doOnNext(accessToken -> storeCredentials(accessToken)) .flatMap(accessToken -> serviceEndpoint.getUser()) .flatMap(user -> serviceEndpoint.getUserContact(user.getId()))
51. Async composition apiEndpoint.login() .doOnNext(accessToken -> storeCredentials(accessToken)) .flatMap(accessToken -> serviceEndpoint.getUser()) .flatMap(user -> serviceEndpoint.getUserContact(user.getId()))
52. Async composition
53. Android & RxJava
54. Android Lifecycle • few complications • continuing subscription during configuration change • memory leaks
55. Android Lifecycle • continuing subscription during configuration change • replay() • don’t use cache()
56. Android Lifecycle • memory leaks • bind to Activity/Fragment lifecycle • use RxLifecycle
57. RxLifecycle
58. RxLifecycle • auto unsubscribe based on Activity/Fragment lifecycle myObservable .compose( RxLifecycle.bindUntilEvent( lifecycleObservable, ActivityEvent.DESTROY ) ) .subscribe(…); myObservable .compose(RxLifecycle.bindActivity(lifecycleObs)) .subscribe(…);
59. RxLifecycle • How to obtain ActivityEvent or FragmentEvent? A. rxlifecycle-components + subclass RxActivity, RxFragment B. Navi + rxlifecycle-navi C. Write it yourself
60. RxLifecycle public class MyActivity extends RxActivity { @Override public void onResume() { super.onResume(); myObservable .compose(bindToLifecycle()) .subscribe(); } }
61. RxLifecycle & Navi public class MyActivity extends NaviActivity { private final ActivityLifecycleProvider provider = NaviLifecycle.createActivityLifecycleProvider(this); }
62. RxLifecycle & Navi public class MyActivity extends NaviActivity { private final ActivityLifecycleProvider provider = NaviLifecycle.createActivityLifecycleProvider(this); @Override public void onResume() { super.onResume(); myObservable .compose(provider.bindToLifecycle()) .subscribe(…); } }
63. Navi naviComponent.addListener(Event.CREATE, new Listener<Bundle>() { @Override public void call(Bundle bundle) { setContentView(R.layout.main); } } );
64. RxNavi RxNavi .observe(naviComponent, Event.CREATE) .subscribe(bundle -> setContentView(R.layout.main)); • converting lifecycle callbacks into Observables!
65. RxLifecycle public class MainActivityFragment extends Fragment { BehaviorSubject<FragmentEvent> mLifecycleSubject = BehaviorSubject.create(); }
66. RxLifecycle public class MainActivityFragment extends Fragment { BehaviorSubject<FragmentEvent> mLifecycleSubject = BehaviorSubject.create(); @Override public void onPause() { super.onPause(); Timber.i("onPause"); mLifecycleSubject.onNext(FragmentEvent.PAUSE); } }
67. RxLifecycle public class MainActivityFragment extends Fragment { BehaviorSubject<FragmentEvent> mLifecycleSubject = BehaviorSubject.create(); @Override public void onPause() { super.onPause(); Timber.i("onPause"); mLifecycleSubject.onNext(FragmentEvent.PAUSE); } @Override public void onResume() { super.onResume(); myObservable // e.g. UI events Observable .compose( RxLifecycle .bindUntilEvent(mLifecycleSubject, FragmentEvent.PAUSE)) .doOnUnsubscribe(() -> Timber.i("onUnsubscribe")) .subscribe(…); } }
68. RxBinding
69. RxBinding RxView.clicks(vBtnSearch) .subscribe( v -> { Intent intent = new Intent(getActivity(), SearchActivity.class); startActivity(intent); } );
70. RxBinding RxTextView.textChanges(vEtSearch) .observeOn(Schedulers.io()) .flatMap(s -> mApiService.search(s.toString())) .subscribe( response -> Timber.i("Count: " + response.totalCount()) );
71. RxBinding RxTextView.textChanges(vEtSearch) .debounce(2, TimeUnit.SECONDS) .observeOn(Schedulers.io()) .flatMap(s -> mApiService.search(s.toString())) .subscribe( response -> Timber.i("Count: " + response.totalCount()) );
72. RxBinding RxTextView.textChanges(vEtSearch) .debounce(2, TimeUnit.SECONDS) .observeOn(Schedulers.io()) .flatMap(s -> mApiService.search(s.toString())) .flatMap(response -> Observable.from(response.getItems()) .subscribe( s -> Timber.i("item: " + s) );
73. Retrofit
74. Retrofit • sync or async API (Retrofit 2) @GET("group/{id}/users") Call<List<User>> groupList(@Path("id") int groupId); @GET("group/{id}/users") Observable<List<User>> groupList(@Path("id") int groupId); • reactive API
75. Retrofit • onNext() with Response, then onComplete() • onError() in case of error @GET("/data") Observable<Response> getData( @Body DataRequest dataRequest);
76. Retrofit RxTextView.textChanges(vEtSearch) .debounce(2, TimeUnit.SECONDS) .observeOn(Schedulers.io()) .flatMap(s -> mApiService.search(s.toString()) ) .flatMap(list -> Observable.from(list)) .subscribe( s -> Timber.i("item: " + s) );
77. Retrofit RxTextView.textChanges(vEtSearch) .debounce(2, TimeUnit.SECONDS) .observeOn(Schedulers.io()) .flatMap(s -> mApiService.search(s.toString()) ) .flatMap(list -> Observable.from(list)) .subscribe( s -> Timber.i("item: " + s) );
78. SQLBrite
79. SQLBrite • by Square • wrapper around SQLiteOpenHelper and ContentResolver • not an ORM • not type-safe query mechanism
80. SQLBrite SqlBrite sqlBrite = SqlBrite.create();
81. SQLBrite SqlBrite sqlBrite = SqlBrite.create(); BriteDatabase db = sqlBrite .wrapDatabaseHelper(openHelper, Schedulers.io());
82. SQLBrite SqlBrite sqlBrite = SqlBrite.create(); BriteDatabase db = sqlBrite .wrapDatabaseHelper(openHelper, Schedulers.io()); Observable<Query> users = db .createQuery("users", "SELECT * FROM users");
83. SQLBrite • subscribed queries updated when insert/update/delete occurs • necessary to run it through the same BriteDatabase object • can cause backpressure • fix by using transactions = one update • or use debounce()
84. Antipatterns & Common Mistakes
85. Antipatterns • subscribing to an Observable inside an action or function
86. Antipatterns Subscription buttonSubscription = RxView.clicks(vButton) .subscribe(v -> { Timber.i("button click"); }); mCompositeSubscription.add(buttonSubscription);
87. Antipatterns Subscription buttonSubscription = RxView.clicks(vButton) .subscribe(v -> { Timber.i("button click"); Subscription s = mAppInfoProvider.getAppInfoObservable() .subscribe( appInfo -> Timber.i(appInfo.packageName()), e -> Timber.e(e.getMessage()) ); // and when do we unsubscribe s? }); mCompositeSubscription.add(buttonSubscription);
88. Antipatterns • correct solution Subscription buttonSubscription = RxView.clicks(vButton) .flatMap(v -> mAppInfoProvider.getAppInfoObservable()) .subscribe( appInfo -> Timber.i(appInfo.packageName()), e -> Timber.e(e.getMessage()) ); mCompositeSubscription.add(buttonSubscription);
89. Antipatterns • correct solution Subscription buttonSubscription = RxView.clicks(vButton) .flatMap(v -> mAppInfoProvider.getAppInfoObservable()) .subscribe( appInfo -> Timber.i(appInfo.packageName()), e -> Timber.e(e.getMessage()) ); mCompositeSubscription.add(buttonSubscription);
90. Common Mistakes • assuming mutability • operators return new Observable Observable<String> observable = Observable.from(new String[]{"Hello", "Droidcon!"}); obserable.map(s -> s.toUpperCase(Locale.getDefault())); obserable.reduce((s,s2) -> s + ' ' + s2); obserable.subscribe(s -> Timber.i(s));
91. Rules of Thumb • don’t write your own operators if possible • prefers stateless constructs over stateful variants
92. Exception Handling
93. onError() • use for unexpected exceptions • unrecoverable stream • because it’s terminal event • useless stack traces when missing
94. Expected Exceptions • make an Observable of a response wrapper
95. Exception Handling • recovering from bad usage of onError() • onErrorReturn() • convert to onNext() • onErrorResumeNext() • convert to Observable
96. Unit Testing with RxJava
97. Unit Testing with RxJava • piece of cake • compared to unit testing AsyncTasks • turn methods synchronous with toBlocking() • BlockingObservable
98. Q&A
99. References • https://github.com/ReactiveX/RxJava • https://github.com/ReactiveX/RxAndroid • https://github.com/JakeWharton/RxRelay • https://github.com/trello/RxLifecycle • https://github.com/trello/navi • https://github.com/JakeWharton/RxBinding • https://github.com/square/retrofit • https://github.com/square/sqlbrite • http://slides.com/yaroslavheriatovych/frponandroid