Subscribe { RxJava vs LiveData }

Transcript

1. Subscribe { RxJava vs LiveData }
2. @brunoaybarg @bruno.aybar Bruno125 Bruno Aybar Android Lead @ Fandango Latam
3. • Trending entre Android devs • Nos permiten observar cambios sobre algún tipo de información, y operar sobre ellos • Proponen un paradigma distinto al convencional • ¿Hacen lo mismo? RxJava y LiveData
4. OBSERVER pattern
5. OBSERVER pattern Es un patrón de diseño de software que define una dependencia entre objetos (…), de manera que cuando uno de los objetos cambia su estado, notifica este cambio a todos los dependientes
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 flujo de información estados eventos data 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) Aquí termina el flujo 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) No es emitido 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) No es emitido Flowable.fromArray(1,2,3)
24. Flowable.fromArray(1,2,3) Flowable.create<Int>({ s ->
 // heavy transaction... // async operation... }, BackpressureStrategy.BUFFER) Flowable.just(1) no es la mejor idea…
26. Subscripción a los eventos
27. Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 ) Kotlin ❤ (o Retrolambda, en su defecto)
28. Flowable.just(1).subscribe(new Consumer<Integer>() {
 @Override
 public void accept(Integer integer) throws Exception {
 log("onNext: " + integer);
 }
 }, new Consumer<Throwable>() {
 @Override
 public void accept(Throwable throwable) throws Exception {
 log("onError" + throwable);
 }
 }, new Action() {
 @Override
 public void run() throws Exception {
 log("onComplete!");
 }
 }); Java
29. Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 )
30. val subscription = Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 ) subscription.dispose()
31. Manejo de hilos
32. Controller UI DataSource
33. Controller Presenter ViewModel DataSource UI
34. Controller DataSource UI
35. Controller DataSource UI Background
36. Controller DataSource UI UI Thread
37. Flowable.just(1).subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 )
38. Flowable.just(1)
 .subscribeOn(Schedulers.computation()) .subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 ) Hilo (Thread) en el que se realizará la operación
39. Flowable.just(1)
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread()) .subscribe(
 { value -> log("onNext: $value") },
 { error -> log("onError: $error")},
 { log("onComplete!") }
 ) Hilo (Thread) en el que se escuchará el resultado
40. Operaciones
41. Flowable.fromArray(1,2,3,4)
 .filter { it % 2 == 0 }

42. Flowable.fromArray(1,2,3,4)
 .filter { it % 2 == 0 }
 .map { it + 10 } Flowable.just(User(“1”, “Bruno”))
 .map { it.name }
43. 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
44. Curva de aprendizaje
45. LiveData
46. LiveData Room Lifecycle ViewModel ARCHITECTURE COMPONENTS
47. LiveData Lifecycle +
48. Flowable.fromArray(1,2,3)
49. Flowable.fromArray(1,2,3) 1 2 3 LiveData<Int>
50. 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
51. 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
52. Subscripción a los eventos
53. data.observe(lifecycleOwner, new Observer<Integer>() {
 @Override
 public void onChanged(@Nullable Integer value) {
 log("onChanged: $value”)
 }
 });
54. data.observe(lifecycleOwner, Observer<Int> { value -> log("onChanged: $value”) })
55. data.observe(lifecycleOwner, Observer<Int> { value -> log("onChanged: $value”) })
56. data.observe(lifecycleOwner, Observer<Int> { value -> log("onChanged: $value”) })
58. LifecycleOwner es una clase que contiene información sobre el ciclo de vida de un componente, y permite a otros objetos observar su estado
59. LifecycleOwner es una clase que contiene información sobre el ciclo de vida de un componente, y permite a otros objetos observar su estado Destroyed Created Started Resumed Initialized
61. LifecycleObserver te permite observar el estado actual de un LifecycleOwner
62. LifecycleObserver public class MyObserver implements LifecycleObserver { 
 @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
 public void connectListener() {
 
 }
 
 @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
 public void disconnectListener() {
 
 }
 }

63. Flowable
 <Int> Activity 1 2 3 se suscribe data.subscribe { value -> textView.setText("Text " + value) }
64. Flowable
 <Int> Activity se suscribe data.subscribe { value -> textView.setText("Text " + value) } destroyed 4 5 6
65. LiveData
 <Int> Activity se suscribe data.observe(lifecycleOwner, { value -> textView.setText("Text " + value) }) destroyed X
66. LiveData
 <Int> Activity se suscribe data.observe(lifecycleOwner, { value -> textView.setText("Text " + value) }) STARTED | RESUMED
67. Manejo de hilos
68. MutableLiveData<Integer> data = 
 new MutableLiveData<>();
 data.setValue(1); //UI thread
 data.postValue(2); //Background thread
69. MutableLiveData<Integer> data = 
 new MutableLiveData<>();
 data.setValue(1); //UI thread
 data.postValue(2); //Background thread data.observe(lifecycleOwner, { value -> // executes in UI thread })
70. Operaciones
71. val userLiveData: LiveData<User> = … 
 val userNameLiveData = Transformations.map( userLiveData, { it.name }) Map SwitchMap Custom Transformations
72. RxJava vs LiveData Simple y sencilla Operadores poderosos Manejo de hilos Código legible Curva de aprendizaje ✔ ✔ ✔ ✘ ✔ Enfocada a Android ✔ Integración con AC ✔ Operadores no tan 
 poderosos ✘ Compatibilidad con 
 librerías ✔ Over-engineered? ✘ Conocimiento portable ✔
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. Material adicional 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 Material adicional
80. @brunoaybarg @bruno.aybar Bruno125 Bruno Aybar Android Lead @ Fandango Latam Gracias! https://speakerdeck.com/bruno125/subscribe-rxjava-vs-livedata