RxJava Android - Load-cache-display data on proper threads

Question

I'm exploring the RxJava and its applicability to Android, and I'm trying to implement a simple load-cache-display use case, as depicted on the following ASCII graph:

                    ---------------
      --- failure --|  Load data  |-- success ---
      |             ---------------             |
      V                                         V
-------------------                       -------------
|  Get from cache |                       |   Filter  |
-------------------                       -------------
      |                                         |
      |                                         V
      |            ----------------       -------------
      ------------>|    Display   |<------|    Cache  |
                   ----------------       -------------

Here's the code that I initially came up with:

subscription = AndroidObservable.bindFragment(this, restClient.getItems())
                .onErrorReturn(new Func1<Throwable, List<Item>>() {
                    @Override public List<Item> call(Throwable throwable) {
                        return itemsDao.getCachedItems();
                    }
                })
                .flatMap(new Func1<ItemContainer, Observable<Item>>() {
                    @Override public Observable<Item> call(ItemContainer itemContainer) {
                        return Observable.from(itemContainer.getItems());
                    }
                })
                .filter(new Func1<Item, Boolean>() {
                    @Override public Boolean call(Item item) {
                        return item.getName().startsWith("B");
                    }
                })
                .toList()
                .map(new Func1<List<Item>, List<Item>>() {
                    @Override public List<Item> call(List<Item> items) {
                        itemsDao.cacheItems(items);
                        return items;
                    }
                })
                .subscribeOn(Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR))
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<Item>>() {
                    @Override public void call(List<Item> items) {
                        displayData(items);
                    }
                });

As expected, networking and caching are performed on a background thread, and displaying the data happens on UI thread. The problem is that data returned by onErrorReturn() goes through the same filtering and caching cycle, which is redundant. However, if I change the code to this:

subscription = AndroidObservable.bindFragment(this, restClient.getItems())
                    .flatMap(new Func1<ItemContainer, Observable<Item>>() {
                        @Override public Observable<Item> call(ItemContainer itemContainer) {
                            return Observable.from(itemContainer.getItems());
                        }
                    })
                    .filter(new Func1<Item, Boolean>() {
                        @Override public Boolean call(Item item) {
                            return item.getName().startsWith("B");
                        }
                    })
                    .toList()
                    .map(new Func1<List<Item>, List<Item>>() {
                        @Override public List<Item> call(List<Item> items) {
                            itemsDao.cacheItems(items);
                            return items;
                        }
                    })
                    .onErrorReturn(new Func1<Throwable, List<Item>>() {
                        @Override public List<Item> call(Throwable throwable) {
                            return itemsDao.getCachedItems();
                        }
                    })
                    .subscribeOn(Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR))
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Action1<List<Item>>() {
                        @Override public void call(List<Item> items) {
                            displayData(items);
                        }
                    });

displayData() is never called. What would be the right way to compose these observables to implement the scheme that I have?

Answer 1

Solved by replacing onErrorReturn() call with onErrorResumeNext(Observable.just(itemsDao.getCachedItems()))