Mehrere API-Aufrufe mit RxJava und Android

Question

Ich habe eine Liste von Objekten, die nacheinander an eine API übergeben werden sollen und einen endgültigen Rückruf benötigen, wenn alle Anrufe abgeschlossen sind. Die Codestruktur sieht aus wie

//Singleton class 
public class RestAPIManager { 

    public Completable doSomething(A a) { 
     //Make API call here and return Completeable 
    } 
} 

//Class from which the above API call is made 
public class FragmentA extends Fragment { 
    List<A> aList = new ArrayList<A>; 

    //This method should return completable after all calls are made 
    private Completable callDoSomething(List<A> data) { 
     // The code that I tried 
     Observable.just(data) 
      .flatMap(new <List<A>, Observable<?>>() { 
       @Override 
       public Observable<?> call(List<A> dataList) { 
        //WHAT SHOULD BE RETURNED FROM HERE 
        for (A a : dataList) { 
         RestAPIManager.getInstance().doSomething(a)  
        } 
       } 
      }) 
      .doOnCompleted(new Action0() { 
       @Override 
       public void call() { 

       } 
      }) 
      .doOnError(new Action1<Throwable>() { 
       @Override 
       public void call(Throwable throwable) { 

       } 
      }) 
      .toCompletable(); 
    } 
} 

ich mit RxJava gerade begonnen haben, so bin wirklich nicht sicher, wie man damit weitermachen.

Answer 1

können Sie from Operator verwenden, um die Liste zu glätten, dann concatMap jedes Element der Reihe nach zu verarbeiten:

Observable.from(data) 
    .concatMap(new Func1<A, Observable<?>>() { 
     @Override 
     public Observable<?> call(A a) { 
      return RestAPIManager.getInstance().doSomething(a); 
     } 
    }) 
    .toCompletable(); 

Answer 2

für Android Verwendung so etwas wie diese

public void doIt(List<String> data) { 
    final Subscription subscription = proceed(data) 
      .subscribe(new Subscriber<List<String>>() { 
       @Override 
       public void onCompleted() { 
        //final callback here 
        System.out.println("on completed"); 
       } 

       @Override 
       public void onError(Throwable e) { 
        //invokes on error 
        System.out.println("on error"); 
       } 

       @Override 
       public void onNext(List<String> strings) { 
        //invokes on items emits 
        strings.forEach(System.out::print); 
       } 
      }); 
} 

private Observable<List<String>> proceed(List<String> data) { 
    return Observable.from(data) 
      .map(RestApiManager.getInstance()::doSomething) 
      .toList(); 
} 

und durch Zeichnung von Anforderungsausführungs abmelden. Abmelden(); Wenn onStop() aufgerufen wird, um Lecks zu vermeiden. Und vergessen Sie nicht die Scheduler