Observing RxJava on Android

Everyone wants smooth, responsive, and robust apps. Yet asynchronous programming on Android leaves a lot to be desired. RxJava brings the Functional Reactive Programming paradigm to Java, making concurrency easy and enjoyable!

This talk will discuss the fundamentals and benefits of RxJava on Android, and help ease the learning curve of the FRP paradigm. See how to take advantage of Observables and Subscribers to keep your apps fast and reliable.

Transcript

1. Observing RxJava on Android A taste of the reactive revolution Michael Torres
2. What is RxJava?
3. What is RxJava?
4. Reactive Extensions (Rx)
5. A library for composing asynchronous and event-based programs
6. App Data Asynchronous computation UI Layer Event-based computation
7. Rx brings easy concurrency and a beautiful api for event handling
8. RxJava: Reactive Extensions for the JVM
9. Apps React App Taps Keypresses Sensor updates Network Responses …. Update UI Change state Load data Save data ….
10. Functional Reactive Programming (FRP)
11. Functional Reduced state and side effects Same inputs produce same outputs every time Declarative
12. Declarative Imperative Declarative int last = myArray[myArray.length - 1]; from(myArray).last(); Describe what you want. Not how to do it.
13. Reactive Asynchronous Event streams Reacting to change
14. Reactive Programming: Programming with asynchronous event streams
15. Streams Events over time Time Event 1 Event 2 Event 3 “Event” can be anything!
16. Events Click events Text change events Network Response events Tweet events Sign in events … endless possibilities
17. Everything is a stream!
18. “What’s the difference between an array and events?” - Erik Meijer
19. Time Tweet 1 Tweet 2 Tweet 3 Event Stream [ ] Tweet 1 Tweet 2 Tweet 3 , ,
20. Event Stream Operate on stream like an array Time Tweet 1 Tweet 2 Tweet 3 Filter by HashTag Time Tweet 2
21. FRP: Event streams with functional methods
22. Observables emit event items Subscribers consume those items Subscriptions control the stream
23. Normally we pull items we need and work on them. The Rx way we push items and then work on them
24. Imperative Pull Iterator itr = getIterator(); while (itr.hasNext()) { Object element = itr.next(); } // Do something useful
25. Rx Push Observable.from(myList) .subscribe(element -> ); // Do something useful
26. Adhere to the Rx Contract
27. onNext(T item) onCompleted() onError(Throwable e) Observer Interface
28. onNext(T item) onCompleted() onError(Throwable e) Observer (push) T next() return throws Exception Iterator (pull)
29. Observables are the source of data
30. Observable Emit 0 or more items over time Knows if and when to complete Emit errors if necessary
31. Create Observable.create(new OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext("Hello, World!"); } });
32. Create Observable.create(new OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext("Hello, World!"); } });
33. Create with Lambdas Observable.create(new OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext("Hello, World!"); } }); Observable.create(subscriber -> subscriber.onNext("Hello, World!"));
34. Observable.create( subscriber -> { try { for (String filePath : getFilePaths()) { File file = expensiveFileOperation(filePath); subscriber.onNext(file); } subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(e); } }); Create
35. Observable.create( subscriber -> { try { for (String filePath : getFilePaths()) { File file = expensiveFileOperation(filePath); subscriber.onNext(file); } subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(e); } }); Create
36. Observable.create( subscriber -> { try { for (String filePath : getFilePaths()) { File file = expensiveFileOperation(filePath); subscriber.onNext(file); } subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(e); } }); Create
37. Observable.create( subscriber -> { try { for (String filePath : getFilePaths()) { File file = expensiveFileOperation(filePath); subscriber.onNext(file); } subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(e); } }); Create
38. Observable.just("Hello, World!"); T Iterable<T> Observable.from(filePaths); Observable.range(0, 10); 0..10 … and more Create
39. Subscribers receive emitted items
40. Implements the 3 Observer methods Used with Observable.subscribe() Subscribers
41. Subscriber Subscriber<Integer> mySubscriber = new Subscriber<Integer>() { @Override public void onCompleted() { Log.i(TAG, "Finished"); } @Override public void onError(Throwable e) { Log.e(TAG, "Error occurred", e); } @Override public void onNext(Integer i) { Log.i(TAG, "Received:" + i); } };
42. Subscriber Integer[] numbers = {1, 2, 3}; Observable.from(numbers) .subscribe(mySubscriber); Subscriber<Integer> mySubscriber = new Subscriber<Integer>() { @Override public void onCompleted() { Log.i(TAG, "Finished"); } @Override public void onError(Throwable e) { Log.e(TAG, "Error occurred", e); } @Override public void onNext(Integer i) { Log.i(TAG, "Received:" + i); } };
43. Subscriber Received: 1 Received: 2 Received: 3 Finished Subscriber<Integer> mySubscriber = new Subscriber<Integer>() { @Override public void onCompleted() { Log.i(TAG, "Finished"); } @Override public void onError(Throwable e) { Log.e(TAG, "Error occurred", e); } @Override public void onNext(Integer i) { Log.i(TAG, "Received:" + i); } }; Integer[] numbers = {1, 2, 3}; Observable.from(numbers) .subscribe(mySubscriber);
44. Often subscribe method starts Observable execution
45. Subscribe Observable<Long> timerObservable = Observable.timer(3, TimeUnit.SECONDS);
46. Subscribe Observable<Long> timerObservable = Observable.timer(3, TimeUnit.SECONDS); timerObservable.subscribe(); // Start observable
47. Control the stream with Subscriptions
48. Subscription Observable.subscribe() returns a subscription Just 2 methods 1. isUnsubscribed() 2. unsubscribe()
49. @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Observable.interval(3, TimeUnit.SECONDS) .subscribe(new Action1<Long>() { @Override public void call(Long interval) { } }); } Memory Leak // Leaking context
50. @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); intervalSubscription = Observable.interval(3, TimeUnit.SECONDS) .subscribe(new Action1<Long>() { @Override public void call(Long interval) { } }); } Subscription Subscription intervalSubscription; // Leaking context
51. Memory Leak Fix Subscription intervalSubscription; @Override protected void onDestroy() { super.onDestroy(); intervalSubscription.unsubscribe(); }
52. Operators are functions to manipulate streams
53. Operators Transform Filter Combine Concurrency Error handling
54. Transform via Map Movie myMovie = new Movie(); Observable.just(myMovie) .map(movie -> movie.getActors()) .subscribe(actors -> "List of actors");
55. Movie transformed to List<Actor> Movie myMovie = new Movie(); Observable.just(myMovie) .map(movie -> movie.getActors()) .subscribe(actors -> "List of actors"); Transform via Map
56. Returned an Observable Flattens the items from that observable Merges the flattened items together FlatMap
57. Transform via FlatMap Movie myMovie = new Movie(); Observable.just(myMovie) .flatMap(movie -> Observable.from(movie.getActors())) .subscribe(actor -> "Actor " + actor.getName());
58. Movie myMovie = new Movie(); Observable.just(myMovie) .flatMap(movie -> Observable.from(movie.getActors())) .subscribe(actor -> "Actor " + actor.getName()); Movie transformed to multiple Actor items Transform via FlatMap
59. Observable.from(myDataSet) .filter(item != null) .distinct() .take(3) .subscribe(item -> "3 non-null unique items!"); Filtering
60. Observable<Flight> flightObservable = fetchFlight(flightId); Observable<Hotel> hotelObservable = fetchHotel(hotelId); Combining
61. Observable<Flight> flightObservable = fetchFlight(flightId); Observable<Hotel> hotelObservable = fetchHotel(hotelId); Observable.zip(flightObservable, hotelObservable, (flight, hotel) -> { return new TravelInfo(flight, hotel); }) .subscribe(info -> "Got all travel info"); Combining via Zip
62. Powerful composability!
63. RxJava is synchronous by default!
64. Concurrency subscribeOn() - Thread to work on observeOn() - Thread to observe items on
65. fetchDataObservable .subscribe(data -> "Synchronous!"); Synchronous
66. fetchDataObservable .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(data -> "Easy concurrency!"); Asynchronous
67. fetchDataObservable .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(data -> "Easy concurrency!"); Asynchronous
68. Avoid nested callbacks
69. Fetching Files Fetch all folders via user id Fetch all folder’s files via folder id Collect every file from every folder
70. Observable.just(userId) .flatMap(userId -> fetchFolders(userId)) .map(folder -> folder.getId()) .flatMap(folderId -> fetchFiles(folderId)) .toList() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(files -> "Got all files"); Fetching Files
71. Observable.just(userId) .flatMap(userId -> fetchFolders(userId)) .map(folder -> folder.getId()) .flatMap(folderId -> fetchFiles(folderId)) .toList() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(files -> "Got all files"); Fetching Files
72. Observable.just(userId) .flatMap(userId -> fetchFolders(userId)) .map(folder -> folder.getId()) .flatMap(folderId -> fetchFiles(folderId)) .toList() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(files -> "Got all files"); Fetching Files
73. Accounting for errors
74. Observable.error(exception) .onErrorResumeNext(error -> defaultObservable); Observable.error(exception) .onErrorReturn(error -> defaultValue); Observable.error(exception) .retry(1); Error Handling
75. RxAndroid: Android specific components
76. Widget Observable WidgetObservable.text(myEditText); WidgetObservable.itemClicks(myListView); WidgetObservable.listScrollEvents(myListView); WidgetObservable.input(myCheckBox);
77. View Observable ViewObservable.clicks(myView); ViewObservable.bindView(myEditText, WidgetObservable.text(myEditText));
78. Content Observable ContentObservable.fromBroadcast(context, intentFilter); ContentObservable.fromSharedPreferencesChanges(mySharedPreferences); ContentObservable.fromCursor(myCursor);
79. Form validation
80. Observable<Boolean> emailObservable = WidgetObservable.text(emailTextField) .map(textChange -> isValidEmail(textChange.text())); Observable<Boolean> passwordObservable = WidgetObservable.text(passwordTextField) .map(textChange -> isValidPassword(textChange.text())); Func2<Boolean, Boolean, Boolean> combineFunction = (validEmail, validPassword) -> validEmail && validPassword; Form Validation
81. Observable<Boolean> emailObservable = WidgetObservable.text(emailTextField) .map(textChange -> isValidEmail(textChange.text())); Observable<Boolean> passwordObservable = WidgetObservable.text(passwordTextField) .map(textChange -> isValidPassword(textChange.text())); Func2<Boolean, Boolean, Boolean> combineFunction = (validEmail, validPassword) -> validEmail && validPassword; Form Validation
82. Observable<Boolean> emailObservable = WidgetObservable.text(emailTextField) .map(textChange -> isValidEmail(textChange.text())); Observable<Boolean> passwordObservable = WidgetObservable.text(passwordTextField) .map(textChange -> isValidPassword(textChange.text())); Func2<Boolean, Boolean, Boolean> combineFunction = (validEmail, validPassword) -> validEmail && validPassword; Form Validation
83. Observable.combineLatest(emailObservable, passwordObservable, combineFunction) .subscribe(isValid -> loginButton.setEnabled(isValid)); Form Validation
84. Observable.combineLatest(emailObservable, passwordObservable, combineFunction) .distinctUntilChanged() .subscribe(isValid -> loginButton.setEnabled(isValid)); Form Validation
85. Subscription validationSubscription = Observable.combineLatest(emailObservable, passwordObservable, combineFunction) .distinctUntilChanged() .subscribe(isValid -> loginButton.setEnabled(isValid)); validationSubscription.unsubscribe(); Form Validation // Avoid memory leaks
86. Unit testing streams
87. Blocking Observable<String> myObservable = Observable.just("one", "two", "three") .skip(1) .take(1) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.newThread()); String item = myObservable.toBlocking().single(); assertEquals(item, "two");
88. Blocking Observable<String> myObservable = Observable.just("one", "two", "three") .skip(1) .take(1) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.newThread()); String item = myObservable.toBlocking().single(); assertEquals(item, "two");
89. TestSubscriber TestSubscriber<String> subscriber = new TestSubscriber<>(); Observable.range(0, 3) .map(i -> String.valueOf(i)) .subscribe(subscriber); subscriber.assertReceivedOnNext(Arrays.asList("0", "1", "2")); subscriber.assertNoErrors(); subscriber.assertTerminalEvent(); subscriber.assertUnsubscribed();
90. TestSubscriber TestSubscriber<String> subscriber = new TestSubscriber<>(); Observable.range(0, 3) .map(i -> String.valueOf(i)) .subscribe(subscriber); subscriber.assertReceivedOnNext(Arrays.asList("0", "1", "2")); subscriber.assertNoErrors(); subscriber.assertTerminalEvent(); subscriber.assertUnsubscribed();
91. TestSubscriber TestSubscriber<String> subscriber = new TestSubscriber<>(); Observable.range(0, 3) .map(i -> String.valueOf(i)) .subscribe(subscriber); subscriber.assertReceivedOnNext(Arrays.asList("0", "1", "2")); subscriber.assertNoErrors(); subscriber.assertTerminalEvent(); subscriber.assertUnsubscribed();
92. When to be Reactive Any asynchronous operation Modeling events in motion or data over time
93. Downsides Over 3700 methods added Learning curve Avoiding memory leaks Java anonymous classes
94. Benefits Reduced state Easy concurrency Concise and readable Composable Robust and testable
95. More Information Reactivex.io RxMarbles.com Grokking RxJava - Dan Lew Mastering Observables - Couchbase