Wie handle paging mit RxJava?

Also, wenn das ein-Wege-paging, hier ist ein Muster, das Sie versuchen könnten. Dieser code wurde nicht ausgeführt oder kompiliert, aber ich habe versucht, über-kommentieren, um zu erklären, was Los ist.

private static final int LIMIT = 50;

//Given: Returns a stream of dummy event objects telling us when
//to grab the next page. This could be from a click or wherever.
Observable<NextPageEvent> getNextPageEvents();  

//Given:
//The search query keywords. Each emission here means a new top-level
//request;
Observable<String> queries;

queries.switchMap((query) -> getNextPageEvents()
        //Ignore 'next page' pokes when unable to take them.
        .onBackPressureDrop()
        //Seed with the first page.
        .startWith(new NextPageEvent())
        //Increment the page number on each request.
        .scan(0, (page, event) -> page + 1) 
        //Request the page from the server.
        .concatMap((page) -> getUsersByKeyword(query, LIMIT, LIMIT * page)
                //Unroll Observable<List<User> into Observable<User>
                .concatMap((userList) -> Observable.from(userList))
                .retryWhen(/** Insert your favorite retry logic here. */))
        //Only process new page requests sequentially.
        .scheduleOn(Schedulers.trampoline())
        //Trampoline schedules on the 'current thread', so we make sure that's
        //a background IO thread.
        .scheduleOn(Schedulers.io());

Sollte lassen Sie die "nächste Seite" events " - signal trigger-ein laden der nächsten Seite die Daten zu jeder Zeit, so gut wie nicht springen Seiten sollte es ein Fehler auftreten, laden ein. Es auch wieder ganz auf der obersten Ebene, wenn es erhält eine neue Suchabfrage. Wenn ich (oder jemand anderes?) hat Zeit, ich möchte prüfen, meine Annahmen über das Trampolin und Gegendruck und sicherstellen, dass es blockiert jeden Versuch vorzeitig zu Holen der nächsten Seite beim laden.

Klar zu sein, ich nehme an, Ihr Fragen ist vielmehr, wie sich zu bewerben RxJava in Ihrem Android-Anwendung, anstatt auf dem back-end (obwohl es möglich ist, gelten auch, aber nicht so typisch wie die front-end).
Und ich bin mir nicht ganz sicher, ob dieses Beispiel ist ein typischer Anwendungsfall für die Verwendung von reaktiven funktionalen Programmierung (RFP) - Modell, außer für den clean-code-Konstrukte.

Jedem stream unten ist eine Observable. Persönlich würde ich mag zu denken, es als stream, da es einfach zu Grund, über die Ereignisse.
Paginierung flow dargestellt werden kann durch 6 streams:

firstPageStream -f-------------------> //this is actually to produce very first event to obtain the first page result. The event can come from a touch in one of the screen that navigates to this list screen.
nextPageStream  -----n-------n-------> //this is the source of events coming from Next button 'touch' actions
prevPageStream  ---------p-------p---> //this is the source of events coming from Previous button 'touch' actions
requestStream   -r---r---r---r---r---> //this is to consume the signal from 3 streams above and spawn events (r) which create a query and pagination details i.e.: offset and limit
responseStream  -R---R---R---R---R---> //this is to take each r and invoke your web service getUsersByKeyword() then spawn the response (R)

Den oben genannten streams dargestellt werden können, in pseudo-code (JS Stil) unten (es wäre ziemlich einfach zu übersetzen, um RxJava oder andere Sprachen)

firstPageStream = Observable.just(0); //offset=0
nextPageStream = Observable.fromEvent(nextButton, 'touch')
                           .map(function() {
                              offset = offset + limit;
                              return offset;
                            });
prevPageStream = Observable.fromEvent(prevButton, 'touch')
                           .map(function() {
                              offset = offset - limit; //TODO some check here
                              return offset;
                            });
requestStream = Observable.merge(firstPageStream, nextPageStream, prevPageStream)
                            .map(function(offsetValue) {
                               return {offset : offsetValue, limit: limit};
                            });
responseStream = requestStream.flatMap(function(pagination) {
                                return webservice.getUsersByKeyword(query, pagination.offset, pagination.limit); //assume this is async response
                              });
responseStream.subscribe(function(result) {
  //use result to render the display
});

PS1: habe ich nicht getestet, den obigen code. Ich bin Lern-RFP, so kann ich nur versuchen zu denken, in reaktiver Weise durch aufschreiben. Willkommen, jede Anregung.

PS2: ich bin stark beeinflusst von https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 für die Art und Weise zu erklären, reaktive Datenströme.