Comment créer un Observable à partir de OnClick Event Android?
je suis nouveau dans la programmation réactive. Donc j'ai un problème quand créer un flux à partir d'un événement, comme onClick, ontouch...
quelqu'un Peut-il m'aider à résoudre ce problème.
Merci.
4 réponses
Vous ferait quelque chose comme ceci
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();
puisque vous utilisez Android alors vous pouvez déjà inclure le contrib rxjava-android dépendance maintenant connu comme ioreactivex:rxandroid.
Ils ont déjà un cours pour faciliter cela. La méthode est ViewObservable.clicks. Vous pouvez l'utiliser comme si.
Observable<View> buttonObservable = ViewObservable.clicks(initiateButton, false);
buttonObservable.subscribe(new Action1<View>() {
@Override
public void call(View button) {
// do what you need here
}
});
Edit: Depuis la version 1.x,ViewObservable et beaucoup de classes d'aide sont supprimé à partir de RxAndroid. Vous aurez besoin d' RxBinding bibliothèque plutôt.
Observable<Void> buttonObservable = RxView.clicks(initiateButton);
buttonObservable.subscribe(new Action1<Void>() {
@Override
public void call(Void x) {
// do what you need here
}
});
pour Android development, jetez un oeil à Jake Wharton RxBindings. Par exemple, il vous permet de créer un observable et de vous abonner pour cliquer sur Événements avec:
RxView.clicks(myButton)
.subscribe(new Action1<Void>() {
@Override
public void call(Void aVoid) {
/* do something */
}
});
ou, encore mieux, avec des expressions lambda (en utilisant Kotlin, Java 8 ou Retrolambda):
RxView.clicks(myButton)
.subscribe(aVoid -> /* do something */);
si vous utilisez Kotlin, il est intéressant de noter que RxBindings fournit aussi Kotlin fonctions d'extension qui permettent vous devez appliquer chaque fonction de liaison directement sur le type cible.
vous pourriez utiliser un sujet.
Sujet est une sorte de pont ou de mandataire qui agit à la fois comme abonné et comme Observable. Parce que C'est un abonné, il peut souscrire à un ou plusieurs Observables, et parce que c'est un Observable, il peut passer à travers les éléments qu'il observe en les réémettant, et il peut également émettre de nouveaux éléments.
public class Events {
public static PublishSubject <Object> myEvent = PublishSubject.create ();
}
Lorsque vous voulez publier quelque chose
Events.myEvent.onNext(myObject);
quand vous voulez recevoir un événement
Events.myEvent.subscribe (...);
Modifier
utilisation de composants D'Architecture LiveData est mieux car il gère le cycle de vie et l'activité ou le fragment et vous n'avez pas à vous soucier de vous désabonner des événements car il gère 'per se'
MutableLiveData<Object> event = new MutableLiveData<>();
lorsque vous voulez publier quelque chose
event.postValue(myObject);
Si vous souhaitez recevoir et d'événements
event.observe(lifeCycleOwner, (myObject)->...);
À L'Aide De 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
}
});
}
});
Regarde beaucoup plus agréable à l'aide de lambda:
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);
});
}
});
ou utilisez simplement RxBinding comme indiqué par d'autres.
ma solution ci-dessus est un modèle assez général pour envelopper les auditeurs dans un Observable cependant.