neues Abonnement hinzufügen, wenn vorherige komplette

Question

Ich habe 3 Disposaple Objekte in meinem CompositeDisposable:

CompositeDisposable disposables = new CompositeDisposable(); 

disposables.add(
    interactor1 
    .someMethod1() 
    .subscribe(...some handling logic)); 

disposables.add(
    interactor 
    .someMethod2() 
    .subscribe(...some handling logic)); 

disposables.add(
    interactor 
    .someMethod3() 
    .subscribe(...some handling logic)); 

Die ersten beiden Methoden einige Daten zurückgeben und es zu anderen Methoden übertragen. Die dritte Methode muss aufgerufen werden, wenn die ersten beiden abgeschlossen sind. Wie kann ich es tun?

Beispiel Methoden Signatur:

Single<List<String>> someMethod1(); 
Single<List<Integer>> someMethod2(); 
Single<String> someMethod3(); 

Answer 1

würden Sie die ersten 2 Observablen zip und dann flatmap am Ausgang verwendet diesen. Die Zip-Funktion würde ein Objekt projizieren, wenn beide Observables einen Wert erzeugt haben, das kombinierte Objekt würde dann an die Flatmap übergeben, die dann an Ihre dritte beobachtbare Funktion übergeben werden könnte.

Answer 2

Ein Beispiel dafür ist mehr als tausend Worte:

public void SO() { 
    Single.zip(someMethod1(), 
      someMethod2(), 
      Pair::create) // (1) create pair from results of someMethod1 and someMethod2 
      .flatMap(methodsResultPair -> { 
       // (2) handling logic of combined result 
       // methodsResultPair.first is result of someMethod1 
       // methodsResultPair.second is result of someMethod2 
       return someMethod3(); 
      }) 
      .subscribe((resultOfMethod3, throwable) -> { 
       // process resultOfMethod3 
       // process error 
      }); 
} 

public Single<List<String>> someMethod1() { 
    return Single.just(Collections.<String>emptyList()) 
      .doOnSuccess(objects -> { /* (3) handling logic of someMethod1 result */ }); 
} 

public Single<List<Integer>> someMethod2() { 
    return Single.just(Collections.<Integer>emptyList()) 
      .doOnSuccess(objects -> { /* (4) handling logic of someMethod2 result */ }); 
} 

public Single<String> someMethod3() { 
    return Single.just(""); 
} 

Damit Sie eine Einweg statt drei, weil sie alle jetzt Teil einer reaktiven Kette sind. Single.just() Methoden werden nur zur Bereitstellung einiger Dummy-Daten verwendet.