rxtextview - ¿Cómo crear un observable desde OnClick Event Android?

com jakewharton rxbinding2 rxbinding

Question

Soy nuevo en programación reactiva. Por lo tanto, tengo problemas al crear una secuencia desde un evento, como onClick, onuch ...

Alguien puede ayudarme a resolver este problema.

Gracias.

Answer 1

Harías algo como esto

 Observable<View> clickEventObservable = Observable.create(new Observable.OnSubscribe<View>() {
@Override
public void call(final Subscriber<? super View> subscriber) {
viewIWantToMonitorForClickEvents.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (subscriber.isUnsubscribed()) return;
subscriber.onNext(v);
}
});
}
});
// You can then apply all sorts of operation here
Subscription subscription = clickEventObservable.flatMap(/* */);
// Unsubscribe when you''re done with it
subscription.unsubscribe();

Ya que está usando Android, es posible que ya incluya la rxjava-android contrib ahora conocida como ioreactivex:rxandroid . Ya tienen una clase para facilitar esto. El método es ViewObservable.clicks . Puedes usarlo así.

Observable<View> buttonObservable = ViewObservable.clicks(initiateButton, false);
buttonObservable.subscribe(new Action1<View>() {
@Override
public void call(View button) {
// do what you need here
}
});

Edición: Desde la versión 1.x, ViewObservable y muchas clases de ayuda se eliminan de RxAndroid . Necesitará la biblioteca RxBinding en su lugar.

Observable<Void> buttonObservable = RxView.clicks(initiateButton);
buttonObservable.subscribe(new Action1<Void>() {
@Override
public void call(Void x) {
// do what you need here
}
});

Answer 2

Para el desarrollo de Android, eche un vistazo a RxBindings de Jake Wharton. Por ejemplo, le permite crear un observable y suscribirse para hacer clic en eventos con:

RxView.clicks(myButton)
.subscribe(new Action1<Void>() {
@Override
public void call(Void aVoid) {
/* do something */
}
});

O, mejor aún, con expresiones lambda (utilizando Kotlin , Java 8 o Retrolambda ):

RxView.clicks(myButton)
.subscribe(aVoid -> /* do something */);

Si está utilizando Kotlin, vale la pena señalar que RxBindings también proporciona funciones de extensión de Kotlin que le permiten aplicar cada función de enlace directamente en el tipo de destino.

Answer 3

Podrías usar un Asunto.

Un Subject es una especie de puente o proxy que actúa como un Suscriptor y como un Observable. Debido a que es un Suscriptor, puede suscribirse a uno o más Observables, y como es un Observable, puede pasar a través de los elementos que observa reemitiéndolos, y también puede emitir nuevos elementos.

public class Events {
public static PublishSubject <Object> myEvent = PublishSubject.create ();
}

Cuando quieras publicar algo.

Events.myEvent.onNext(myObject);

Cuando quieres recibir un evento.

Events.myEvent.subscribe (...);

Editar

El uso de los Componentes de Arquitectura LiveData es mejor porque maneja el ciclo de vida y la actividad o el fragmento y no tiene que preocuparse por cancelar la suscripción de eventos porque maneja ''per se''

MutableLiveData<Object> event = new MutableLiveData<>();

cuando quieres publicar algo

event.postValue(myObject);

Cuando quieres recibir y evento.

event.observe(lifeCycleOwner, (myObject)->...);

Answer 4

Utilizando RxJava 2:

return Observable.create(new ObservableOnSubscribe<View>() {
@Override
public void subscribe(ObservableEmitter<View> e) throws Exception {
clickView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
e.setCancellable(new Cancellable() {
@Override
public void cancel() throws Exception {
view.setOnClickListener(null);
}
});
e.onNext(view); // Or whatever type you''re observing
}
});
}
});

Se ve mucho mejor usando lambdas:

return Observable.create(new ObservableOnSubscribe<View>() {
@Override
public void subscribe(ObservableEmitter<View> e) throws Exception {
keypad.setOnClickListener(view -> {
e.setCancellable(() -> view.setOnClickListener(null));
e.onNext(view);
});
}
});

O simplemente use RxBinding como lo indican otros.

Mi solución anterior es un patrón bastante general para envolver a los oyentes en un Observable.