ObservableCache

RxJava has become a standard in Android development. It's great until you have to deal with Android lifecycle. Normally you unsubscribe when view is destroyed and create new Observable after view is recreated. It's ok in most cases but sometimes there are actions, which cannot be done more than once i.e. HTTP Request which must be done once and Resposne must be received. In that cases Observables must be kept in place which lifecyle is different than destroyed view. This is where ObservableCache can be used. Library allows to cache Observable in global singleton map and retrieve same Observable after view is recreated. Internally library uses cache() for caching. Observables are automatically removed after onComplete.

RxJava 1.x

Observable Cache

Usage

Add it in your root build.gradle at the end of repositories:

allprojects {
 repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}

Add the dependency

dependencies {
    compile 'com.github.AleksanderMielczarek.ObservableCache:observable-cache-1:1.2.2'
}

Example

public class MainActivity extends AppCompatActivity {

    public static final String OBSERVABLE_CACHE_KEY_REQUEST = "observableRequest";

    private ObservableCache observableCache;
    private CompositeSubscription subscriptions;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        observableCache = LruObservableCache.getDefault();//get default singleton instance
        subscriptions = new CompositeSubscription();

    }

    public void performObservableAction() {
        Observable<String> observable = Observable.just("Test Action");
        observableAction(observable
                .compose(observableCache.cacheObservable(OBSERVABLE_CACHE_KEY_REQUEST)));//this line is responsible for caching observable
    }

    private void observableAction(Observable<String> testObservable) {
        subscriptions.add(testObservable
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(s -> {/*do sth with result*/});
    }

    @Override
    protected void onStart() {
        super.onStart();
        observableCache.<String>getObservable(OBSERVABLE_CACHE_KEY_REQUEST).ifPresent(this::observableAction);//retrieve observable from cache and perform action if observable exists
    }

    @Override
    protected void onStop() {
        super.onStop();
        subscriptions.clear();
    }
}

More information

caching Observable:

CacheableObservable<T> cachable = observableCache.cacheObservable(KEY);

caching Single:

CacheableSingle<T> cachable = observableCache.cacheSingle(KEY);

caching Completable:

CacheableCompletable<T> cachable = observableCache.cacheCompletable(KEY);

retrieve Observable:

ObservableFromCache<T> fromCache = observableCache.<T>getObservable(KEY);

retrieve Single:

SingleFromCache<T> fromCache = observableCache.<T>getSingle(KEY);

retrieve Completable:

CompletableFromCache<T> fromCache = observableCache.<T>getCompletable(KEY);

remove cached value:

boolean removed = observableCache.remove(KEY);

get new instance of cache:

ObservableCache observableCache = LruObservableCache.newInstance();

cache based on Map:

ObservableCache observableCache = MapObservableCache.newInstance();