tech meetup: be reactive with android

#TechMeetup

Be Reactive

Be Reactive

Agenda

Intro

Anatomia

Operadores

Showtime!

Be Reactive - Intro

Qué diferencia hay entre una consulta DB y las transmisiones de un mouse por puerto serie?

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

Be Reactive - Intro

Rx es:

Set of types -> Representing async data stream

Set of Operators -> Query async data stream

Set of Types -> Parameterize concurrency

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


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()


Si combinamos Observables y Observers:

Observable.from() .subscribeOn() .observeOn() .subscribe()


Y la concurrencia....? Schedulers

Observable.from() .subscribeOn() .observeOn() .subscribe()

subscribeOn() -> realizá todas las operaciones en este Thread.observerOn() -> pusheá los resultados a este Thread.

Observers / Subscriber

new Observer<T>() { @Override public void onCompleted() {} @Override public void onError(Throwable throwable) {} @Override public void onNext(T t) {}};



Subscriptions = Observable Observer

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.


create() crea un Observable desde cero.from() convierte otros objetos en Observablesjust() convierte otro objeto u objetos en Observables que emita esos objetos.


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(); }});


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); }})


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); }});


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


debounce() (filtering)

Solo emite un ítem si un tiempo particular ha transcurrido.

myObservable.debounce(400, TimeUnit.MILLISECONDS)

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); }};

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>() { ... });

Be Reactive - Cooking, Cooking, Cooking

santexgroup.com

tech meetup: be reactive with android

Software