Rxify - A talk to Remember - CODELAB

Codelab for the GDG New Delhi meetup. Source Here : https://github.com/ragdroid/rxify/tree/codelab

Readme : https://github.com/ragdroid/rxify/tree/codelab#code-lab

Transcript

1. `Rxify` Presented By : Garima Jain @ragdroid A Talk to Remember
2. `Rxify` Presented By : Garima Jain @ragdroid A Talk to Remember A Walk to Remember
3. `Rxify` Presented By : Garima Jain @ragdroid A Talk to Remember A Walk to Remember A Walk-through Remember
4. `Rxify` Presented By : Garima Jain @ragdroid A Talk to Remember A Walk to Remember A Walk-through Remember - CODELAB -
5. Who?
6. `Rxify` is for? • Already working on RxJava - More to learn.
7. `Rxify` is for? • Already working on RxJava - More to learn. • Beginner - Time to start Rxifying your apps
8. `Rxify` is for? • Already working on RxJava - More to learn. • Beginner - Time to start Rxifying your apps • Pros - Sit and relax!
9. What?
10. • `Rxify` - term signifies use of RxJava • RxJava makes our lives simpler. • Cast a spell (use an operator) and we are good to go. `Rxify`
11. • Reactive Extensions for JVM (Java Virtual Machine). • Observer pattern for sequences of data / events. RxJava
12. RxJava makes lives simpler • Never having to worry about : • Low-level Threading • Synchronisation • Background Processing
13. Why?
14. RxJava operators at first glance
15. RxJava operators at first glance
16. RxJava operators at first glance • Complex • Hard to understand • Marble Diagrams? What!!
17. `Rxify` your apps!
18. Basics
19. • Observable produces items, • Subscriber consumes those items. • Observable calls : (Actions) • onNext() multiple times • followed by onComplete() • OR onError() Basics
20. • Operators : • manipulate items between producer and consumer. • Schedulers • Main Thread • Computation (Background Thread) • Test Scheduler Basics
21. Observable Pattern Producer Consumer A B C items Observable emits Subscriber consumes
22. “Part 1” Spells
23. Just-ify “create an Observable that emits a particular item”
24. Just-ify
25. Check it Out! via-Hedwig Checkout commit : “Starting commit of Codelab" git checkout <sha>
26. Observable.just("Hello World!”); Just-ify
27. Empty “create an Observable that emits no items but terminates normally”
28. Empty
29. Empty Observable.empty()
30. Never “create an Observable that emits no items and does not terminate”
31. Never
32. Never Observable.never()
33. Throw “create an Observable that emits no items and terminates with an error”
34. Throw
35. Throw Observable.error(new RuntimeException(“BOOM!"))
36. Range “create an Observable that emits a particular range of sequential integers”
37. Range
38. Range Observable.range(1, 10)
39. Interval “create an Observable that emits a sequence of integers spaced by a given time interval”
40. Interval
41. Interval Observable.interval(1000, TimeUnit.MILLISECONDS)
42. IntervalRange Observable.intervalRange(20, 5, 1000, 1000, TimeUnit.MILLISECONDS)
43. From “convert various other objects and data types into Observables”
44. From
45. From Observable.fromIterable( Arrays.asList(1, 2, 3, 4, 5, 6))
46. “Part 2” TO-DOs
47. “emit only those items from an Observable that pass a predicate test” Filter-rum
48. Filter-rum Filter-rum Observable <Integer> Observable <Integer> 1 2 3 1 4 5 6 3 5 7 7
49. Check it Out! via-Hedwig Checkout commit : “starting part 2" git checkout <sha>
50. Filter-rum Input : Observable.range(0,10); //TODO Print all even numbers
51. Filter-rum Observable.range(0,10)
 .filter(new Predicate<Integer>() {
 @Override
 public boolean test(Integer integer) throws Exception {
 return integer % 2 == 0;
 }
 }) Solution :
52. Distinct “suppress duplicate items emitted by an Observable”
53. Distinct
54. Check it Out! via-Hedwig Checkout commit : “filterrum, distincto" git checkout <sha>
55. Input : Observable.fromIterable( Arrays.asList(1, 1, 2, 3, 2)); //TODO Print all distinct numbers Distinct
56. Solution : Distinct Observable.fromIterable(Arrays.asList(1, 1, 2, 3, 2)) .distinct()
57. Take “emit only the first n items emitted by an Observable”
58. Take
59. Check it Out! via-Hedwig Checkout commit : “distincto, takeo" git checkout <sha>
60. Take Input : Observable.range(0,10); //TODO Print only first five
61. Take Solution : Observable.range(0, 10) .take(5)
62. Skip “suppress the first n items emitted by an Observable”
63. Skip
64. Check it Out! via-Hedwig Checkout commit : “takeo, skippum" git checkout <sha>
65. Skip Input : Observable.range(0,10); //TODO Print all except first three
66. Skip Solution : Observable.range(0, 10) .skip(3)
67. TakeUntil “discard any items emitted by an Observable after a second Observable emits an item or terminates"
68. TakeUntil
69. Check it Out! via-Hedwig Checkout commit : “skippum, takun til" git checkout <sha>
70. TakeUntil Input : Observable.interval(100, TimeUnit.MILLISECONDS); Observable.timer(250, TimeUnit.MILLISECONDS); //TODO Print all values till 250 milliseconds
71. TakeUntil Solution : Observable.interval(100, TimeUnit.MILLISECONDS) .takeUntil(Observable.timer(250, TimeUnit.MILLISECONDS)))
72. Reduc-to “apply a function to each item emitted by an Observable, sequentially, and emit the final value”
73. Reduc-to
74. Check it Out! via-Hedwig Checkout commit : “takun, reducto" git checkout <sha>
75. Input : Observable.fromIterable(Arrays.asList( "Color : Red", "Size : M", "Occasion : Casual", "Type : T-Shirt")); //TODO Concatenate filters to send to API
 Desired Output : "Color : Red | Size : M | Occasion : Casual | Type : T-Shirt"
 Reduc-to
76. Reduc-to Solution : inputValues
 .reduce(new BiFunction<String, String, String>() {
 @Override
 public String apply(String old, String value) throws Exception {
 return old + " | " + value;
 }
 })
 .defaultIfEmpty("No item")
 .toObservable()
77. Map Transforms every element of a collection of items.
78. Map “Transform the items emitted by an Observable by applying a function to each item” - source Transforms every element of a collection of items.
79. Map-io Observable <Integer> Map Observable <Integer> 1 2 3 5 10 15 4 20
80. Check it Out! via-Hedwig Checkout commit : “reducto, mapio” git checkout <sha>
81. Input : Observable.intervalRange( 1, 10, 100, 500, TimeUnit.MILLISECONDS); //TODO Print multiples of 5
 Map-io
82. Map-io Solution : Observable.intervalRange(1, 10, 100, 500, TimeUnit.MILLISECONDS) .map(new Function<Long, Long>() {
 @Override
 public Long apply(Long aLong) throws Exception {
 return aLong * 5;
 }
 })
83. FlatMap Transforms every element of a collection into another collection of items and combines them into a single collection.
84. FlatMap “Transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable” - source Transforms every element of a collection into another collection of items and combines them into a single collection.
85. FlatMap-ium Observable <String> FlatMap Observable <String> Hello World How Are You? Hello World How Are You?
86. Check it Out! via-Hedwig Checkout commit : “mapio, flatmapum" git checkout <sha>
87. Input : Observable.fromIterable( Arrays.asList("Hello World!", "How Are You?")); //TODO Print all the words from strings
 Flatmap-um
88. Solution : Observable.fromIterable(Arrays.asList("Hello World!", "How Are You?")) .flatMap(new Function<String, ObservableSource<String>>() {
 @Override
 public ObservableSource<String> apply(String inputString) throws Exception {
 return Observable.fromArray(inputString.split(" "));
 }
 }) Flatmap-um
89. “Part 3” complex operators
90. “Concat-ify” concat() operator “Merge-os” merge() operator VS
91. Concat “Emit the emissions from two or more Observables without interleaving them” source “Combine multiple Observables into one by merging their emissions” source Merge
92. Concat Merge 1 2 3 4 8 9 1 2 3 4 8 9 1 2 3 4 8 9 1 2 3 4 8 9 Concat-ify Merge-os
93. Fictional Problem (Snape’s Assignment) • Professor Snape has requested all students to write an essay on werewolves. • The students who will turn in the essay first will get more points than the ones submitting later. • Students are divided into four house observables : • GryffindorObservable (G), • SlytherinObservable (S), • HufflepuffObservable (H) and • RavenclawObservable(R)).
94. Observable <Gryffindor> R1 R2 H1 H2 Observable <Ravenclaw> Observable <Hufflepuff> G1 G2 S1 S2 Observable <Slytherin> Snape’s Assignment - Submission
95. Snape’s Assignment - Draco’s trick S1 S2 H1 H2 R1 R2 G1 G2 Concat-ify Observable <Gryffindor> R1 R2 H1 H2 Observable <Ravenclaw> Observable <Hufflepuff> G1 G2 S1 S2 Observable <Slytherin>
96. Check it Out! via-Hedwig Checkout commit : “Start of Part 3, Assignment Evaluator" git checkout <sha>
97. Draco’s Trick - Concat-ify Input : gryffindorObservable & slytherinObservable //TODO Concat the observables
98. Draco’s Trick - Concat-ify Solution : slytherinObservable.
 concatWith(gryffindorObservable)
99. Guess who is not so pleased?
100. Guess who is not so pleased? YES!
101. Guess who is not so pleased? YES! Poor Hermione
102. Snape’s Assignment - Hermione’s fix G1 S1 G2 R1 H1 S2 R2 H2 Merge-os Observable <Gryffindor> R1 R2 H1 H2 Observable <Ravenclaw> Observable <Hufflepuff> G1 G2 S1 S2 Observable <Slytherin>
103. Draco’s Trick - Concat-ify Input : gryffindorObservable & slytherinObservable //TODO Merge the observables
104. Draco’s Trick - Concat-ify Solution : gryffindorObservable.
 mergeWith(slytherinObservable)
105. The Battle
106. Fictional Problem (The Battle) • Dumbledore’s army (Harry, Hermione, Ron and others) • Death Eaters (Lucius Malfoy, Bellatrix Lestrange and others) • Each team is casting lethal spells against the other team. • Dumbledore’s army is not as experienced as the Death Eaters. • Spells produced by Death Eaters is overwhelming the Dumbledore’s army (consumer).
107. Check it Out! via-Hedwig Checkout commit : “The Battle” git checkout <sha>
108. The Battle Input : Observable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO Run the code.
109. The Battle Input : Observable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO Limit the number of inputs to 129

110. The Battle Solution : Observable.interval(1, 1, TimeUnit.MICROSECONDS) .take(129)
111. “Buffer-undum” buffer() operator
112. Buffer Buffer small chunks of items and emit them instead of emitting one item at a time.
113. Buffer Buffer small chunks of items and emit them instead of emitting one item at a time. “Periodically gather items emitted by an Observable into bundles and emit these bundles rather than emitting the items one at a time" - source
114. Buffer-undum Buffer Observable <Spell> 1 2 3 4 Observable <Spell> 1 2 3 4
115. Observable <Spell> Buffer Observable <Spell> 1 2 3 4 1 2 getSpellsObservable()
 .buffer(2); //count 3 4
116. The Battle Input : Observable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO Buffer 10 items and concatenate them to a String

117. The Battle Solution : Observable.interval(1, 1, TimeUnit.MICROSECONDS) .take(129)
 .buffer(10)
 .flatMap(new Function<List<Long>, ObservableSource<String>>() {
 @Override
 public ObservableSource<String> apply(List<Long> longs) throws Exception {
 return Observable.fromIterable(longs)
 .reduce("", new BiFunction<String, Long, String>() {
 @Override
 public String apply(String oldString, Long aLong) throws Exception {
 return oldString + "\n" + aLong;
 }
 }).toObservable();
 }
 })
118. The Battle
119. “Debounce-y” debounce() operator
120. Debounce From a list of items emit an item only when, some time has passed since it last emitted anything.
121. Debounce From a list of items emit an item only when, some time has passed since it last emitted anything. “Only emit an item from an Observable if a particular timespan has passed without it emitting another item" - source
122. Debounce-y Debounce Observable <Spell> 1 2 3 4 Observable <Spell> 1 2 4
123. Observable <Spell> 1 2 3 4 Observable <Spell> 1 2 4 getSpellsObservable()
 .debounce(300, TimeUnit.MILLISECONDS); Debounce
124. Observable <Spell> 1 2 3 4 Observable <Spell> 1 2 4 Debounce
125. Observable <Spell> 1 2 3 4 Observable <Spell> 1 2 4 LOSSY Debounce
126. The Battle Input : Observable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO Use Debounce 1 Microsecond to drop some values

127. The Battle Solution : Observable.interval(1, 1, TimeUnit.MICROSECONDS) .take(129)
 .debounce(1, TimeUnit.MICROSECONDS)
128. Observable <Spell> 1 2 3 4 Observable <Spell> 1 2 4 PROBLEM SOLVED Debounce
129. Backpressure “Defence Against the Dark Arts”
130. Backpressure Frequency of Producer producing an item is more than the ability of Consumer to consume.
131. Backpressure Frequency of Producer producing an item is more than the ability of Consumer to consume. “Strategies for coping with Observables that produce items more rapidly than their observers consume them” - source
132. Backpressure via-Hedwig GOOD NEWS!
133. Backpressure via-Hedwig Usually you do not have to worry about back pressure in your applications.
134. Backpressure via-Hedwig RxJava 2 introduces Flowable which is an Observable with backpressure support.
135. Backpressure via-Hedwig With RxJava2, Observables do not support backpressure while Flowables do.
136. Check it Out! via-Hedwig Checkout commit : “The Battle Flow” git checkout <sha>
137. The Battle Input : Flowable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO Run the code.
138. The Battle Input : Flowable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO Limit the number of inputs to 129

139. The Battle Solution : Flowable.interval(1, 1, TimeUnit.MICROSECONDS) .take(129)
140. The Battle Input : Flowable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO Go inside FlowableInterval class to see where the Exception is thrown

141. The Battle Input : Flowable.interval(1, 1, TimeUnit.MICROSECONDS); • Flowable.interval() method is tagged as @BackpressureSupport(BackpressureKind.ERROR) • ERROR : The operator will emit a MissingBackpressureException if the downstream didn't request enough or in time. • Consumers should consider applying one of the {@code onBackpressureXXX} operators as well.
142. The Battle Input : Flowable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO apply onBackpressureBuffer() strategy

143. The Battle Solution : Flowable.interval(1, 1, TimeUnit.MICROSECONDS) .take(129)
 .onBackpressureBuffer()
144. The Battle Input : Flowable.interval(1, 1, TimeUnit.MICROSECONDS); //TODO apply onBackpressureDrop() strategy

145. The Battle Solution : Flowable.interval(1, 1, TimeUnit.MICROSECONDS) .take(129)
 .onBackpressureDrop()
146. “Part 4” Threading
147. observeOn vs subscribeOn What are those two?
148. observeOn vs subscribeOn
149. observeOn vs subscribeOn Sorry! I Don’t Know.
150. observeOn vs subscribeOn Let’s see code instead.
151. Check it Out! via-Hedwig Checkout commit : “Part-4, Threading excercise” git checkout <sha>
152. observeOn vs subscribeOn //TODO Uncomment

153. observeOn Default Flow - No ObserveOn
154. observeOn With ObserveOn
155. “Part 5” Testing
156. Check it Out! via-Hedwig Checkout commit : “Testing Emptiness” git checkout <sha>
157. EmptyPresenterTest //TODO test view.append() was called once. - to print Complete.
158. EmptyPresenterTest verify(view, times(1)).append("Completed.");
 Solution :
159. Check it Out! via-Hedwig Checkout commit : “Testing Neverland” git checkout <sha>
160. NeverPresenterTest //TODO test view.append() was called 0 times. - never.
161. Solution : verify(view, times(0)).append(anyString()); NeverPresenterTest
162. Check it Out! via-Hedwig Checkout commit : “TestObserver and TestSubscriber” git checkout <sha>
163. testGetFluxWeed() - TestObserver //TODO Create a TestObserver
 
 //TODO subscribe to getFluxWeed()
 
 //TODO tell observer to wait for terminal event
 
 //TODO assert there are no errors
 
 //TODO assert we received onComplete
164. Solution : //TODO Create a TestObserver
 TestObserver<Object> testObserver = TestObserver.create();
 //TODO subscribe to getFluxWeed()
 magicalDataSource.getFluxWeed().subscribe(testObserver);
 //TODO tell observer to wait for terminal event
 testObserver.awaitTerminalEvent();
 //TODO assert there are no errors
 testObserver.assertNoErrors();
 //TODO assert we received onComplete
 testObserver.assertComplete(); testGetFluxWeed() - TestObserver
165. testGetFluxWeedFlowable() - TestObserver //TODO Create a TestSubscriber
 
 //TODO subscribe to getFluxWeed()
 
 //TODO tell subscriber to wait for terminal event
 
 //TODO assert there are no errors
 
 //TODO assert we received onComplete
166. Solution : 
 //TODO Create a TestSubscriber
 TestSubscriber<Object> testSubscriber = TestSubscriber.create();
 //TODO subscribe to getFluxWeed()
 magicalDataSource.getFluxWeedFlowable().subscribe(testSubscriber);
 //TODO tell subscriber to wait for terminal event
 testSubscriber.awaitTerminalEvent();
 //TODO assert there are no errors
 testSubscriber.assertNoErrors();
 //TODO assert we received onComplete
 testSubscriber.assertComplete(); testGetFluxWeedFlowable() - TestObserver
167. Check it Out! via-Hedwig Checkout commit : “TestObserver and TestSubscriber” git checkout <sha>
168. CONGRATULATIONS! On Completing the code-lab!
169. • Learn by practice. • Make RxJava your friend and not a foe. • Learn by examples - Kaushik Gopal RxJava. https://github.com/kaushikgopal/RxJava-Android-Samples • Codelab - Full Extended Text version (coming soon on) : https://github.com/ragdroid/rxify/tree/codelab • My Medium blogs for more details. https://medium.com/@ragdroid What’s Next
170. Acknowledgements via-Hedwig The terms lossy and lossless have been inspired from the post here.
171. Acknowledgements via-Hedwig Technical Definitions have been taken from reactivex.io.
172. Acknowledgements via-Hedwig Part 1 and 2 examples inspired from Intro-to-Rx book.
173. Acknowledgements via-Hedwig observeOn diagrams from this article.
174. Thank You