RxJava for Android - GDG DevFest LA 2016

This is an introduction talk on RxJava for Android. I talked about why RxJava makes sense for me and some caveats.

Transcript

1. RxJava for Android Aaron He
2. aggregate all amb ambWith and asyncAction asyncFunc averageDouble averageFloat averageInteger averageLong buffer byLine cache cast chunkify collect combineLatest concat concatMap concatWith connect contains count countLong create debounce decode defaultIfEmpty defer deferFuture deferCancellableFuture delay dematerialize distinct distinctUntilChanged doOnCompleted doOnEach doOnError doOnNext doOnRequest doOnSubscribe doOnTerminate doOnUnsubscribe doWhile elementAt elementAtOrDefault empty encode error exists filter finallyDo first first firstOrDefault flatMap flatMapIterable forEach forEachFuture forIterable from fromAction fromCallable fromCancellableFuture fromFunc0 fromFuture fromRunnable generate generateAbsoluteTime getIterator groupBy groupByUntil groupJoin ifThen ignoreElements interval isEmpty join just last lastOrDefault latest limit map mapMany materialize max maxBy merge mergeDelayError mergeMap mergeMapIterable mergeWith min minBy mostRecent multicast never observeOn ofType onBackpressureBlock onBackpressureBuffer onBackpressureDrop onErrorFlatMap onErrorResumeNext onErrorReturn onExceptionResumeNext parallel parallelMerge pivot publish publishLast range reduce refCount repeat repeatWhen replay retry retrywhen runAsync sample scan sequenceEqual serialize share single singleOrDefault skip skipLast skipUntil
3. And More…
4. And More…
5. Async on Android
6. Async on Android • AsyncTask
7. Async on Android • AsyncTask • Loaders
8. Async on Android • AsyncTask • Loaders • Services
9. Async Task public class Task extends AsyncTask<Void, Void, Void> { } @Override protected Void doInBackground(Void... params) { return null; }
10. Async Task public class Task extends AsyncTask<Void, Void, Void> { } @Override protected Void doInBackground(Void... params) { return null; } @Override protected void onPostExecute(Void aVoid) { // Update UI. }
11. Async Task public class Task extends AsyncTask<Void, Void, Void> { } @Override protected Void doInBackground(Void... params) { return null; } @Override protected void onPreExecute() { // Show progress bar. } @Override protected void onPostExecute(Void aVoid) { // Update UI. }
12. Async Task public class Task extends AsyncTask<Void, Void, Void> { } @Override protected Void doInBackground(Void... params) { return null; } @Override protected void onProgressUpdate(Void... values) { // Update progress bar. } @Override protected void onPreExecute() { // Show progress bar. } @Override protected void onPostExecute(Void aVoid) { // Update UI. }
13. Async Task public class Task extends AsyncTask<Void, Void, Void> { } @Override protected Void doInBackground(Void... params) { return null; } @Override protected void onProgressUpdate(Void... values) { // Update progress bar. } @Override protected void onCancelled(Void aVoid) { } @Override protected void onPreExecute() { // Show progress bar. } @Override protected void onPostExecute(Void aVoid) { // Update UI. }
14. Async Task • Doesn’t work with Android lifecycle
15. Async Task • Doesn’t work with Android lifecycle • Look at how many methods we might need to override
16. Async Task • Doesn’t work with Android lifecycle • Look at how many methods we might need to override • Difficult to compose multiple tasks together
17. Loader public class NetworkLoader extends AsyncTaskLoader<Void> { public NetworkLoader(Context context) { super(context); } @Override public Void loadInBackground() { return null; } }
18. Loader public class NetworkLoader extends AsyncTaskLoader<Void> { public NetworkLoader(Context context) { super(context); } @Override public Void loadInBackground() { return null; } } getLoaderManager().initLoader(id, bundle, new LoaderManager.LoaderCallbacks<Void>() { @Override public Loader<Void> onCreateLoader(int id, Bundle args) { return new NetworkLoader(MainActivity.this); } @Override public void onLoadFinished(Loader<Void> loader, Void data) { } @Override public void onLoaderReset(Loader<Void> loader) { } });
19. Loader • Difficult to unit test • Difficult to compose
20. Services • It’s meant for long running background tasks • A little bit more code to talk back to UI
22. Rx
23. • Rx: Reactive Extension Rx
24. • Rx: Reactive Extension • Other implementations: RxKotlin, RxSwift, RxJs Rx
25. • Rx: Reactive Extension • Other implementations: RxKotlin, RxSwift, RxJs • Everything is a stream. Rx
26. • Rx: Reactive Extension • Other implementations: RxKotlin, RxSwift, RxJs • Everything is a stream. • Easy to specify concurrency model. Rx
27. Observer
28. Observer public interface Observer<T> { 
 }
29. Observer public interface Observer<T> { 
 } void onNext(T t);
30. Observer public interface Observer<T> { 
 } void onNext(T t); void onError(Throwable e);
31. Observer public interface Observer<T> { 
 } void onNext(T t); void onError(Throwable e); void onCompleted();
32. Observable
33. Observable Observable
34. Observable Observable .subscribe(
 
 
 
 
 
 );
35. Observable Observable .subscribe(
 
 
 
 
 
 ); new Observer<T>() {
 @Override public void onNext(T data) {
 }
 
 @Override public void onError(Throwable e) {
 }
 
 @Override public void onCompleted() {
 }
 }
36. Observable creation
37. Observable creation Observable.just("Hello DevFest LA 2016");
38. Observable creation Observable.just("Hello DevFest LA 2016"); Observable.from(list);
39. Observable creation Observable.just("Hello DevFest LA 2016"); Observable.fromCallable(new Callable<String>() {
 @Override public String call() throws Exception {
 return "Hello DevFest LA 2016";
 }
 }); Observable.from(list);
40. Observable creation
41. Observable creation Observable.create(new Observable.OnSubscribe<T>() {
 @Override public void call(Subscriber<? super T> subscriber) {
 }
 });
42. Observable creation Observable.create(new Observable.OnSubscribe<T>() {
 @Override public void call(Subscriber<? super T> subscriber) {
 }
 });
43. Observable creation
44. Observable creation interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
 }
45. Observable creation interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
 } abstract class Subscriber<T> implements Observer<T>, Subscription { }
46. Observable creation interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
 } abstract class Subscriber<T> implements Observer<T>, Subscription { } interface Subscription {
 void unsubscribe(); 
 boolean isUnsubscribed();
 }
47. Observable creation
48. Observable creation Observable.create(new Observable.OnSubscribe<String>() {
 @Override public void call(Subscriber<? super String> subscriber) { 
 }
 });
49. Observable creation Observable.create(new Observable.OnSubscribe<String>() {
 @Override public void call(Subscriber<? super String> subscriber) { 
 }
 }); subscriber.onNext("Hello DevFest LA 2016");
50. Observable creation Observable.create(new Observable.OnSubscribe<String>() {
 @Override public void call(Subscriber<? super String> subscriber) { 
 }
 }); subscriber.onNext("Hello DevFest LA 2016"); subscriber.onCompleted();
51. Observable creation Observable.create(new Observable.OnSubscribe<String>() {
 @Override public void call(Subscriber<? super String> subscriber) {
 try {
 subscriber.onNext(expensiveOperation());
 } catch (IOException e) {
 subscriber.onError(e);
 }
 subscriber.onCompleted();
 }
 });
52. Concurrency
53. Concurrency • RxJava is single-threaded by default
54. Concurrency • RxJava is single-threaded by default • Call SubscribeOn and ObserveOn to specify concurrency model
55. Concurrency
56. Concurrency Observable.just("Hello DevFest LA 2016")
 .subscribeOn(Schedulers.io())
57. Concurrency Observable.just("Hello DevFest LA 2016")
 .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread())
58. Concurrency
59. Concurrency • Where to put subscribeOn and observeOn?
60. Concurrency • Where to put subscribeOn and observeOn? • Should only be invoked by the the final subscriber.
61. Concurrency
62. Concurrency Observable.fromCallable(() -> "Hello DevFest LA 2016")
 .subscribeOn(Schedulers.io())
 .subscribeOn(Schedulers.computation())
 .subscribeOn(Schedulers.immediate())
 .observeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe();
63. Operators
64. Operators
65. Operators
66. Operators Observable.from(schedules)
 
 

67. Operators Observable.from(schedules)
 
 
 .map(schedule -> schedule.speaker)
68. Operators Observable.from(schedules)
 
 
 .map(schedule -> schedule.speaker) .filter(speaker -> "Chat Haase".equals(speaker.name))
69. Operators Observable.from(schedules)
 
 
 .map(schedule -> schedule.speaker) .filter(speaker -> "Chat Haase".equals(speaker.name)) .flatMap(speaker -> getGitHubProfile(speaker.gitHubUrl))
70. Operators
71. Operators Observable.from(schedules)
72. Operators Observable.from(schedules) .map(schedule -> schedule.speaker)
73. Operators Observable.from(schedules) .map(schedule -> schedule.speaker) .filter(speaker -> "Chat Haase".equals(speaker.name))
74. Operators Observable.from(schedules) .map(schedule -> schedule.speaker) .filter(speaker -> "Chat Haase".equals(speaker.name)) .flatMap(speaker -> getGitHubProfile(speaker.gitHubUrl)
75. Operators Observable.from(schedules) .map(schedule -> schedule.speaker) .filter(speaker -> "Chat Haase".equals(speaker.name)) .flatMap(speaker -> getGitHubProfile(speaker.gitHubUrl) .zipWith(getLinkedInProfile(speaker.linkedInUrl),
76. Operators Observable.from(schedules) .map(schedule -> schedule.speaker) .filter(speaker -> "Chat Haase".equals(speaker.name)) .flatMap(speaker -> getGitHubProfile(speaker.gitHubUrl) .zipWith(getLinkedInProfile(speaker.linkedInUrl), (gitHubProfile, linkedInProfile) -> new Profile()));
77. Reusing operators
78. Reusing operators .compose()!
79. Reusing operators Observable.from(schedules)
 .compose(new Transformer<Schedule, GitHubStatus>() {
 @Override public Observable<GitHubStatus> call(Observable<Schedule> source) {
 return source.map(schedule -> schedule.speaker)
 .flatMap(speaker -> getGitHubProfile(speaker.gitHubUrl));
 }
 }); .compose()!
80. onError
81. onError • Will crash if onError not implemented
82. onError • Will crash if onError not implemented • Centralized error handling
83. Error handling • Don’t care then just log it • onErrorReturn/onErrorResumeNext for default values
84. Standardized listener APIs
85. Standardized listener APIs • Observer is a perfect contract for listeners
86. Lifecycle
87. Lifecycle • RxJava is unaware of Android lifecycle
88. Lifecycle • RxJava is unaware of Android lifecycle • Add multiple Subscriptions into a CompositeSubscription • Call .clear() when lifecycle ends • Don’t call .unsubscribe
89. Unit test
90. Unit test • Legacy code is code without tests.
91. Unit test • Legacy code is code without tests. • TestSubscriber
92. Unit test • Legacy code is code without tests. • TestSubscriber • TestScheduler
93. Unit test • Legacy code is code without tests. • TestSubscriber • TestScheduler • A great way to lean RxJava
94. Other RxJava types
95. Other RxJava types • Completable
96. Other RxJava types • Completable • Single
97. Plugins
98. Plugins • RxJavaHooks in 1.x
99. Plugins • RxJavaHooks in 1.x • Fine grained control for changing default behavior
100. Plugins • RxJavaHooks in 1.x • Fine grained control for changing default behavior • Override Scheulders.IO/MainThreadScheudler in unit tests
101. Plugins • RxJavaHooks in 1.x • Fine grained control for changing default behavior • Override Scheulders.IO/MainThreadScheudler in unit tests • onError hook
102. RxJava 2 • Matches Reactive Stream specification • No longer accepts null • Observable -> Flowable or Observable • Single/Completable remains the same • Maybe • Subscription -> Disposable
103. References • RxJava: https://github.com/ReactiveX/RxJava • RxAndroid: https://github.com/ReactiveX/RxAndroid • RxBinding: https://github.com/JakeWharton/RxBinding • Introduction to Rx: http://www.introtorx.com/ • Demystifying RxJava Subscribers by Jake Wharton: http://jakewharton.com/ demystifying-rxjava-subscribers/ • What’s different in 2.0: https://github.com/ReactiveX/RxJava/wiki/What's- different-in-2.0 • Reactive Programming with RxJava By Tomasz Nurkiewicz, Ben Christensen • Advanced RxJava by David Karnok : http://akarnokd.blogspot.com/
104. Thank you! @aaronhe42 aaronhe42@gmail.com Tinder is hiring: https://www.gotinder.com/jobs