Android: Polling a server with Retrofit

Question

I\'m building a 2 Player game on Android. The game works turnwise, so player 1 waits until player 2 made his input and vice versa. I have a webserver where I run an API with the

Answer 1

Let's say the interface you defined for Retrofit contains a method like this:

public Observable loadGameState(@Query("id") String gameId);

Retrofit methods can be defined in one of three ways:

1.) a simple synchronous one:

public GameState loadGameState(@Query("id") String gameId);

2.) one that take a Callback for asynchronous handling:

public void loadGameState(@Query("id") String gameId, Callback callback);

3.) and the one that returns an rxjava Observable, see above. I think if you are going to use Retrofit in conjunction with rxjava it makes the most sense to use this version.

That way you could just use the Observable for a single request directly like this:

mApiService.loadGameState(mGameId)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() {

    @Override
    public void onNext(GameState gameState) {
        // use the current game state here
    }

    // onError and onCompleted are also here
});

If you want to repeatedly poll the server using you can provide the "pulse" using versions of timer() or interval():

Observable.timer(0, 2000, TimeUnit.MILLISECONDS)
.flatMap(mApiService.loadGameState(mGameId))
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() {

    @Override
    public void onNext(GameState gameState) {
        // use the current game state here
    }

    // onError and onCompleted are also here
}).

It is important to note that I am using flatMap here instead of map - that's because the return value of loadGameState(mGameId) is itself an Observable.

But the version you are using in your update should work too:

Observable.interval(2, TimeUnit.SECONDS, Schedulers.io())
.map(tick -> Api.ReceiveGameTurn())
.doOnError(err -> Log.e("Polling", "Error retrieving messages" + err))
.retry()
.observeOn(AndroidSchedulers.mainThread())
.subscribe(sub);

That is, if ReceiveGameTurn() is defined synchronously like my 1.) above, you would use map instead of flatMap.

In both cases the onNext of your Subscriber would be called every two seconds with the latest game state from the server. You can process them one after another of limit the emission to a single item by inserting take(1) before subscribe().

However, regarding the first version: A single network error would be first delivered to onError and then the Observable would stop emitting any more items, rendering your Subscriber useless and without input (remember, onError can only be called once). To work around this you could use any of the onError* methods of rxjava to "redirect" the failure to onNext.

For example:

Observable.timer(0, 2000, TimeUnit.MILLISECONDS)
.flatMap(new Func1>(){

    @Override
    public Observable call(Long tick) {
        return mApiService.loadGameState(mGameId)
        .doOnError(err -> Log.e("Polling", "Error retrieving messages" + err))
        .onErrorResumeNext(new Func1(){
            @Override
            public Observable call(Throwable throwable) {
                return Observable.emtpy());
            }
        });
    }
})
.filter(/* check if it is a valid new game state */)
.take(1)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() {

    @Override
    public void onNext(GameState gameState) {
        // use the current game state here
    }

    // onError and onCompleted are also here
}).

This will every two seconds: * use Retrofit to get the current game state from the server * filter out invalid ones * take the first valid one * and the unsubscribe

In case of an error: * it will print an error message in doOnNext * and otherwise ignore the error: onErrorResumeNext will "consume" the onError-Event (i.e. your Subscriber's onError will not be called) and replaces it with nothing (Observable.empty()).

And, regarding the second version: In case of a network error retry would resubscribe to the interval immediately - and since interval emits the first Integer immediately upon subscription the next request would be sent immediately, too - and not after 3 seconds as you probably want...

Final note: Also, if your game state is quite large, you could also first just poll the server to ask whether a new state is available and only in case of a positive answer reload the new game state.

If you need more elaborate examples, please ask.

UPDATE: I've rewritten parts of this post and added more information in between.

UPDATE 2: I've added a full example of error handling with onErrorResumeNext.