Aprender a usar RxJava y RxAndroid para crear Apps más flexibles, de bajo acoplamiento y escalables.

2. #TechMeetup
Be Reactive

3. Be Reactive
Agenda
Intro
Anatomia
Operadores
Showtime!

4. Be Reactive - Intro
Qué diferencia hay entre una consulta DB y las
transmisiones de un mouse por puerto serie?

5. Be Reactive - Intro
Programación reactiva es programar usando stream de datos de
manera asíncrona.
Combinación de Patrones Observer e Interator junto
Programación Funcional

6. Be Reactive - Intro
Rx es:
Set of types -> Representing async data stream
Set of Operators -> Query async data stream
Set of Types -> Parameterize concurrency

7. Be Reactive - Anatomia
Los bloques básicos son: Observables y Observers
Una implementación común de los Observers son los Subscribers
Un Observable emite items y un Subscriber los consume

8. Be Reactive - Anatomia
Pero el patrón Observer…
Una diferencia, es que un Observable no emite items hasta no alguien no se
suscriba explícitamente.
Pero el patrón Iterator…
Hay una dualidad con este patrón,
Evento Iterable (pull) Observable (push)
Recuperar datos T next() onNext(T)
Descubrir errores throws Exception onError(Exception)
Completado returns onCompleted()

9. Be Reactive - Anatomia
Si combinamos Observables y Observers:
Observable.from()
.subscribeOn()
.observeOn()
.subscribe()

10. Be Reactive - Anatomia
Y la concurrencia....? Schedulers
Observable.from()
.subscribeOn()
.observeOn()
.subscribe()
subscribeOn() -> realizá todas las operaciones en este Thread.
observerOn() -> pusheá los resultados a este Thread.

11. Observers / Subscriber
new Observer<T>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable throwable) {}
@Override
public void onNext(T t) {}
};
Be Reactive - Anatomia

12. Be Reactive - Anatomia
Subscriptions = Observable Observer

13. Be Reactive - Operadores
Permiten componer secuencias asíncronas de manera declarativa.
Operan sobre Observables y retornan Observables
Permiten encadenarse, como el patrón Builder, pero en este caso el orden si
importa.

14. Be Reactive - Operadores
create() crea un Observable desde cero.
from() convierte otros objetos en Observables
just() convierte otro objeto u objetos en Observables que emita esos objetos.

15. Be Reactive - Operadores
map() (Transforming)
Puede ser usado para transformar un ítem emitido en otro tipo.
myObservable.map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return s.hashCode();
}
});

16. Be Reactive - Operadores
flatMap() (Transforming)
Transforma los ítems emitidos por un Observable en Observables, y luego
“aplana” la emisión de esos Observables en un solo.
myObservable.flatMap(new Func1<List<String>, Observable<String>>()
{
@Override
public Observable<String> call(List<String> list) {
return Observable.from(list);
}
})

17. Be Reactive - Operadores
zip() (Combining)
Combina los ítems emitidos por múltiples Observables y emite un solo ítem
basado en el resultado de una función.
Observable.zip(myObservable,
myObservable2,
new Func2<String, String, Pair<String, String>>() {
@Override
public Pair<String, String> call(String s, String s2) {
return new Pair<String, String>(s, s2); }});

18. Be Reactive - Operadores
combineLastest() (Combining)
Cuando un ítem es emitido por alguno de los Observables, lo combina con el
último emitido por cada Observable y emite el resultado basado en una función

19. Be Reactive - Operadores
debounce() (filtering)
Solo emite un ítem si un tiempo particular ha transcurrido.
myObservable.debounce(400, TimeUnit.MILLISECONDS)

20. Be Reactive - Example
AsyncTask
new AsyncTask<String, Void ,User>(){
@Override
protected User doInBackground(String... values) {
return githubApi.getUser(values[0]);
}
@Override
protected void onPostExecute(User user) {
super.onPostExecute(user);
}
};

21. Be Reactive - Example
Rx
Observable.create(new Observable.OnSubscribe<User>() {
@Override
public void call(Subscriber<? super User> subscriber) {
User user = githubApi.getUser("username");
subscriber.onNext(user);
subscriber.onCompleted();
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<User>() {
...
});

22. Be Reactive - Cooking, Cooking, Cooking

23. santexgroup.com