Subscribe RxJava vs LiveData English

2018 edition, in English

Transcript

1. Subscribe { RxJava vs LiveData }
2. @brunoaybarg @bruno.aybar Bruno125 Bruno Aybar Android Dev Peru Organizer
 Android Engineer
3. • Allow us to observe changes over some kind of data, and to react to those changes. • Propose a reactive paradigm • Do they do the same? RxJava & LiveData
4. OBSERVER pattern
5. OBSERVER pattern Design pattern that defines a dependency between objects (…), in which one of them changes its state, it notifies about it to all of its dependants
6. OBSERVER RxJava LiveData pattern
7. RxJava
8. RxJava An API for asynchronous programming
 with observable streams Is a combination of the best ideas from
 the Observer pattern, the Iterator pattern, and functional programming ReactiveX RxJava RxSwift RxJS Rx.NET RxPY RxPHP …
9. Stream of Data states events data data data
10. Fuente: Imagen tomada de https://www.pinterest.com/pin/749708669188692420/
11. Subscriber<T>
12. Observable<T>
13. Flowable<T> RxJava 2:
14. package org.reactivestreams; public interface Subscriber<T> {
 
 public void onNext(T t);
 
 public void onError(Throwable t);
 
 public void onComplete();
 }

15. Flowable.just(1)
16. Flowable.just(1) Flowable.fromArray(1,2,3)
17. Flowable.create<Int>({ s ->
 
 }, BackpressureStrategy.BUFFER) Flowable.fromArray(1,2,3) Flowable.just(1)
18. Flowable.create<Int>({ s ->
 s.onNext(1)
 
 
 
 }, BackpressureStrategy.BUFFER) Flowable.fromArray(1,2,3) Flowable.just(1)
19. Flowable.create<Int>({ s ->
 s.onNext(1)
 s.onNext(2)
 
 
 }, BackpressureStrategy.BUFFER) Flowable.just(1) Flowable.fromArray(1,2,3)
20. Flowable.create<Int>({ s ->
 s.onNext(1)
 s.onNext(2)
 s.onNext(3)
 
 }, BackpressureStrategy.BUFFER) Flowable.just(1) Flowable.fromArray(1,2,3)
21. Flowable.create<Int>({ s ->
 s.onNext(1)
 s.onNext(2)
 s.onNext(3)
 s.onComplete() 
 }, BackpressureStrategy.BUFFER) Flowable.just(1) The stream ends here! Flowable.fromArray(1,2,3)
22. Flowable.create<Int>({ s ->
 s.onNext(1)
 s.onNext(2)
 s.onNext(3)
 s.onComplete() s.onNext(4)
 }, BackpressureStrategy.BUFFER) Flowable.just(1) Not emitted Flowable.fromArray(1,2,3)
23. Flowable.create<Int>({ s ->
 s.onNext(1)
 s.onNext(2)
 s.onNext(3)
 s.onError(Throwable(“Error!")) s.onNext(4)
 }, BackpressureStrategy.BUFFER) Flowable.just(1) Not emitted Flowable.fromArray(1,2,3)
24. Flowable.fromArray(1,2,3) Flowable.create<Int>({ s ->
 // heavy transaction... // async operation... }, BackpressureStrategy.BUFFER) Flowable.just(1)
25. Event subscription
26. Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 )
27. Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 )
28. val subscription = Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 ) subscription.dispose()
29. Handling Threads
30. Controller UI DataSource
31. Controller Presenter ViewModel DataSource UI
32. Controller DataSource UI
33. Controller DataSource UI Background
34. Controller DataSource UI UI Thread
35. Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 )
36. Flowable.just(1)
 .subscribeOn(Schedulers.computation()) .subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 ) Thread in which the operation
 will be performed
37. Flowable.just(1)
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread()) .subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 ) Thread in which we will listen 
 to the stream emissions
38. Operations
39. Flowable.fromArray(1,2,3,4)
 .filter { it % 2 == 0 }

40. Flowable.fromArray(1,2,3,4)
 .filter { it % 2 == 0 }
 .map { it + 10 } Flowable.just(User(“1”, “Bruno”))
 .map { it.name }
41. Combine CombineLatest And/Then/When Zip Switch Join ... Filtering Filter Distinct First Last Take ... Transform Map FlatMap Scan GroupBy Buffer ... More: http:/ /reactivex.io/documentation/ operators.html
42. Steep learning curve
43. LiveData
44. LiveData Room Lifecycle ViewModel ARCHITECTURE COMPONENTS
45. LiveData Lifecycle +
46. Flowable.fromArray(1,2,3)
47. Flowable.fromArray(1,2,3) 1 2 3 LiveData<Int>
48. Flowable.fromArray(1,2,3) 1 2 3 MutableLiveData<Integer> data = 
 new MutableLiveData<>();
 data.setValue(1); //UI thread
 data.setValue(2); //UI thread
 data.postValue(3); //Background thread
49. Flowable.fromArray(1,2,3) 1 2 3 MutableLiveData<Integer> data = 
 new MutableLiveData<>();
 data.setValue(1); //UI thread
 data.setValue(2); //UI thread
 data.postValue(3); //Background thread
50. Event subscription
51. data.observe(lifecycleOwner, new Observer<Integer>() {
 @Override
 public void onChanged(@Nullable Integer value) {
 log("onChanged: $value”)
 }
 });
52. data.observe(lifecycleOwner, Observer<Int> { value -> log("onChanged: $value”) })
53. data.observe(lifecycleOwner, Observer<Int> { value -> log("onChanged: $value”) })
54. data.observe(lifecycleOwner, Observer<Int> { value -> log("onChanged: $value”) })
56. LifecycleOwner class that contains information about a component lifecycle, and allow other objects to observe its changes
57. LifecycleOwner class that contains information about a component lifecycle, and allow other objects to observe its changes Destroyed Created Started Resumed Initialized
59. LifecycleObserver allows you to observe the current state of a LifecycleOwner
60. LifecycleObserver public class MyObserver implements LifecycleObserver { 
 @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
 public void connectListener() {
 
 }
 
 @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
 public void disconnectListener() {
 
 }
 }

61. Flowable
 <Int> Activity 1 2 3 subscribes to data.subscribe { value -> textView.setText("Text " + value) }
62. Flowable
 <Int> Activity subscribes to data.subscribe { value -> textView.setText("Text " + value) } destroyed 4 5 6
63. LiveData
 <Int> Activity subscribes to data.observe(lifecycleOwner, { value -> textView.setText("Text " + value) }) destroyed X
64. LiveData
 <Int> Activity subscribes to data.observe(lifecycleOwner, { value -> textView.setText("Text " + value) }) STARTED | RESUMED
65. LiveData
 <Int> Activity subscribes to data.observe(lifecycleOwner, { value -> textView.setText("Text " + value) }) STARTED | RESUMED 6
66. Handling threads
67. MutableLiveData<Integer> data = 
 new MutableLiveData<>();
 data.setValue(1); //UI thread
 data.postValue(2); //Background thread
68. MutableLiveData<Integer> data = 
 new MutableLiveData<>();
 data.setValue(1); //UI thread
 data.postValue(2); //Background thread data.observe(lifecycleOwner, { value -> // executes in UI thread })
69. Operations
70. val userLiveData: LiveData<User> = … 
 val userNameLiveData = Transformations.map( userLiveData, { it.name }) Map SwitchMap Custom Transformations
71. + LiveData Lifecycle + ViewModel + Room
72. RxJava vs LiveData Explicit code ✔ Thread handling ✔ Powerful Operators ✔ Steep learning curve ✘ Really simple ✔ Android-oriented ✔ Integration with AC ✔ Not so powerful
 operators ✘ Library compatibility 
 (i.e. Retrofit) ✔ Over-engineered? ✘ Portable knowledge ✔
73. ¯\_(ツ)_/¯ RxJava vs LiveData
74. Controller Presenter ViewModel Data Sources UI
75. Controller Presenter ViewModel Data Sources UI LiveData
76. Controller Presenter ViewModel Data Sources UI RxJava
77. ¯\_(ツ)_/¯ RxJava vs LiveData
78. Additional Material Intro to RxJava (Christina Lee) https:/ /www.youtube.com/watch?v=XLH2v9deew0 Learning Rx (for Android) by Example https:/ /www.youtube.com/watch?v=k3D0cWyNno4 Common RxJava Mistakes https:/ /www.youtube.com/watch?v=QdmkXL7XikQ RxJava in Baby Steps https:/ /www.youtube.com/watch?v=YPf6AYDaYf8 RxMarbles http:/ /rxmarbles.com/
79. Live Data docs https:/ /developer.android.com/topic/libraries/architecture/livedata.html LiveData & Lifecycle https:/ /www.youtube.com/watch?v=jCw5ib0r9wg ViewModels, LiveData and Lifecycles, oh my! https:/ /www.youtube.com/watch?v=SlZVYkhoSq8 Android lifecycle-aware components codelab https:/ /codelabs.developers.google.com/codelabs/android-lifecycles Additional Material
80. @brunoaybarg @bruno.aybar Bruno125 Bruno Aybar Android Dev Perú Organizer Android Engineer @ Avantica Gracias! https://speakerdeck.com/bruno125/subscribe-rxjava-vs-livedata-2018