RxAndroid toma de contacto

Cada vez hay más eventos y nuestras apps tienen que reaccionar mejor a cada cosa que ocurra con un delay de milisegundos. Si ha cambiado la forma en que una aplicación tiene que reaccionar y ha aumentado sus eventos, ¿porqué no cambiar la forma en que programamos?

Con programación Rx podemos reaccionar mejor, controlar más eventos y tener un código más sostenible.

Seguramente en algún momento has usado JQuery para hacer una petición al servidor:

$.get('/androidconnect/apps')
.done(function(data){});

Pues bien ese formato de programación es reactivo.
Con RxAndroid es algo diferente al concentrarnos en 2 cosas. Todo puede ser streams y todo puede ser observable.

De este modo solamente tenemos que reconvertir el evento que queramos capturar en un stream observable.

Vamos a fijarnos en el ejemplo de RxAndroid:

static Observable<String> sampleObservable() {
        return Observable.defer(new Func0<Observable<String>>() {
            @Override public Observable<String> call() {
                try {
                    // Do some long running operation
                    Thread.sleep(TimeUnit.SECONDS.toMillis(5));
                } catch (InterruptedException e) {
                    throw OnErrorThrowable.from(e);
                }
                return Observable.just("one", "two", "three", "four", "five");
            }
        });
    }

Creamos un Observable de ejemplo, donde emitirá “one”, “two” despues de un delay.
Una vez tenemos el stream que nos proporciona los eventos solo necesitamos registrarnos.

 sampleObservable()
                // Run on a background thread
                .subscribeOn(HandlerScheduler.from(backgroundHandler))
                // Be notified on the main thread
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override public void onCompleted() {
                        Log.d(TAG, "onCompleted()");
                    }

                    @Override public void onError(Throwable e) {
                        Log.e(TAG, "onError()", e);
                    }

                    @Override public void onNext(String string) {
                        Log.d(TAG, "onNext(" + string + ")");
                    }
                });

Usamos un handler para suscribirnos al thread y le indicamos que queremos correrlo en el thread de la ui, luego solamente tendremos que controlar los 3 eventos.

  • onNext: se irá lanzando a medida que llegan los eventos
  • onError: devuelve error del stream
  • onCompleted: cuando se acaban las trazas

Ahora bien te preguntarás a que eventos me puedo registrar. Pues a todo tipo de eventos que ocurran con asincronía. El más común es onClick, pero tienes respuestas de red, de posición, incluso puedes crear tu propio bus interno para cambiar el estado de varios elementos al mismo tiempo.

Para ver un caso práctico puedes descargarte el proyecto RxJava-Android-Samples, incorpora una serie de ejemplos muy interesantes que es lo que verás en la mayoría de tus proyectos.

  • Auto búsqueda
  • Uso de retrofit con RxAndroid
  • Binding entre datos y vista al más puro estilo AngularJS

Para nombrar algunos de los ejemplos. Miramos el de auto búsqueda.

DebounceSearchEmitterFragment nos permite asociar eventos a medida que cambia el textview pero no cuando cambia cada letra, sino con un pequeño delay para evitar búsquedas antes de que el usuario haya escrito la palabra.

Miramos como creamos el observer:

 _subscription = RxTextView.textChangeEvents(_inputSearchText)//
              .debounce(400, TimeUnit.MILLISECONDS)// default Scheduler is Computation
              .observeOn(AndroidSchedulers.mainThread())//
              .subscribe(_getSearchObserver());

.debounce es el que nos ofrece el delay al emitir nuevos eventos, miramos la clase _getSearchObserver()

private Observer<TextViewTextChangeEvent> _getSearchObserver() {
    return new Observer<TextViewTextChangeEvent>() {
        @Override
        public void onCompleted() {
            Timber.d("--------- onComplete");
        }

        @Override
        public void onError(Throwable e) {
            Timber.e(e, "--------- Woops on error!");
            _log("Dang error. check your logs");
        }

        @Override
        public void onNext(TextViewTextChangeEvent onTextChangeEvent) {
            _log(format("Searching for %s", onTextChangeEvent.text().toString()));
        }
    };
}

Esto se parece a lo que ya hemos visto. Por lo que puedes ver que en el onNext será donde aparecerá el texto cambiado del TextView.
Más claro de usar que un TextWatcher y aporta algunas características como el debounce que no tendríamos.

Espero que este pequeño snack de RxAndroid haya servido para que tengas ganas y pierdas el miedo a probarlo. Para aprofundizar en la teoría puedes leer Introduction to Reactive Programing you’ve been missing si en cambio quieres saltar a la práctica prueba RxJava y RxJava-Android-Samples.

Introduction to Reactive Programing you’ve been missing
RxJava
RxJava-Android-Samples
Grokking RxJava, Part 1: The Basics

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *