Krótkie pytanie jak zastąpić tego rodzaju callback za pomocą RxJavy.
Klasa A, B i interfejs. Standardowo wygląda to tak:
interface CustomCallback {
void onCallbackCalled(String str);
}
class ClassA {
private ClassB classB;
public ClassA() {
classB = new ClassB(new CustomCallback() {
@Override
public void onCallbackCalled(String str) {
System.out.println("Callback called " + str);
}
});
}
}
class ClassB {
private CustomCallback customCallback;
public ClassB(CustomCallback callback) {
customCallback = callback;
}
private void somethingHappened() {
customCallback.onCallbackCalled("method somethingHappened");
}
}
Metodę onCallbackCalled(String str) z poziomu klasy B mogę wywoływać wielokrotnie;
KLASA A
↓ ............................................ wstrzyknięcie interfejsu przez konstruktor
................↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ onCallbackCalled(...) ile razy chcę
KLASA B
RxJava
W 99% przypadków które znalazłem, powtarza się schemat:
class ClassA {
private ClassB classB;
public ClassA() {
classB = new ClassB();
}
public void rxJavaMethod() {
DisposableObserver<String> observer = classB.getObservable()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new DisposableObserver<String>() {
@Override
public void onNext(String s) {}
@Override
public void onError(Throwable e) {}
@Override
public void onComplete() {}
});
}
}
class ClassB {
private Observable<String> getObservable() {
return Observable.just(jakiś AsyncTask, Http connection czy cokolwiek innego do wykonania, 128218 opcji);
}
}
Oczywiście schemat wygląda jak:
KLASA A
↓ jedno żądanie zwrócenia zasobu Observable
................↑ zwraca 0...n obiektów observable na jedno żądanie
KLASA B
Myślałem, że jeżeli zrobię w klasie B zmienną Observable, to później będzie możliwe wykonywanie callbacków na takiej samej zasadzie jak standardowo w Java... wszak jest połączenie z obserwatorem za pomocą subskrybcji ( załóżmy, że obserwator też jest zadeklarowany jako pole w klasie A).
class ClassB {
private Observable<String> observable;
// wywołane z poziomu klasy A, nawiązanie połączenia z obserwatorem
private Observable<String> getObservable() {
observable = new Observable<String>() {
....
}
return observable;
}
// wywołanie już po nawiązaniu połączenia z obserwatorem z klasy A
// pytanie -> jak to osiągnąć?
private void callbackByRxJava {
observable. ( tutaj czary-mary i callback do klasy A)
}
}
Pytania:
- Jak osiągnąć taki callback za pomocą RxJava.
- Czy jest sens? Jakaś przewaga nad standardowym callbackiem za pomocą interfejsu?
- Słowa-klucze do poszukania przeze mnie i poczytania w dokumentacji ( związane z tym zagadnieniem)?
- Dlaczego na forum jest tak mało pytań odnośnie RxJavy? ( tag rxjava raptem 4 razy, wliczając dwa tematy zrobione przeze mnie)?
Mam nadzieję, że mniej więcej objaśniłem o co mi chodzi. Trzeba sporo napisać, żeby się dobrze wysłowić, ale nie chcę dodawać tutaj epopei.