Reservoir alternatives and similar packages
Based on the "Utility" category.
Alternatively, view Reservoir alternatives based on common mentions on social networks and blogs.
-
timber
A logger with a small, extensible API which provides utility on top of Android's normal Log class. -
ExpirableDiskLruCache
DISCONTINUED. Java implementation of a Disk-based LRU cache which specifically targets Android compatibility. -
Android-Templates-And-Utilities
Collection of source codes, utilities, templates and snippets for Android development. -
secure-preferences
DISCONTINUED. Android Shared preference wrapper than encrypts the values of Shared Preferences. It's not bullet proof security but rather a quick win for incrementally making your android app more secure. -
greenrobot-common
General purpose utilities and hash functions for Android and Java (aka java-common) -
Androl4b
A Virtual Machine For Assessing Android applications, Reverse Engineering and Malware Analysis -
vector-compat
A support library for VectorDrawable and AnimatedVectorDrawable classes introduced in Lollipop -
CastCompanionLibrary-android
DISCONTINUED. CastCompanionLibrary-android is a library project to enable developers integrate Cast capabilities into their applications faster and easier. -
motion
An Android library allowing images to exhibit a parallax effect that reacts to the device's tilt -
Colours
A beautiful set of predefined colors and a set of color methods to make your Android development life easier.
InfluxDB high-performance time series database

* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of Reservoir or a related project?
README
Deprecated
This library is now deprecated.
Please look into Store instead.
Reservoir
Reservoir is a simple library for Android that allows you to easily serialize and cache your objects to disk using key/value pairs.
Including in your project
Add the jcenter repository to your gradle build file if it's not already present:
repositories {
jcenter()
}
Next, add Reservoir as a dependency:
dependencies {
compile 'com.anupcowkur:reservoir:3.1.0'
}
Usage
Initialize
Reservoir uses the internal cache storage allocated to your app. Before you can do anything, you need to initialize Reservoir with the cache size.
try {
Reservoir.init(this, 2048); //in bytes
} catch (IOException e) {
//failure
}
If you want to pass in a custom GSON instance for whatever reason, you can do that too:
try {
Reservoir.init(this, 2048, myGsonInstance);
} catch (IOException e) {
//failure
}
The best place to do this initialization would be in your application's onCreate()
method.
Since this library depends directly on DiskLruCache, you can refer that project for more info on the maximum size you can allocate etc.
Put stuff
You can put objects into Reservoir synchronously or asynchronously.
Async put will you give you a callback on completion:
//Put a simple object
Reservoir.putAsync("myKey", myObject, new ReservoirPutCallback() {
@Override
public void onSuccess() {
//success
}
@Override
public void onFailure(Exception e) {
//error
}
});
//Put collection
List<String> strings = new ArrayList<String>();
strings.add("one");
strings.add("two");
strings.add("three");
Reservoir.putAsync("myKey", strings, new ReservoirPutCallback() {
@Override
public void onSuccess() {
//success
}
@Override
public void onFailure(Exception e) {
//error
}
});
synchronous put:
//Put a simple object
try {
Reservoir.put("myKey", myObject);
} catch (IOException e) {
//failure;
}
//Put collection
List<String> strings = new ArrayList<String>();
strings.add("one");
strings.add("two");
strings.add("three");
try {
Reservoir.put("myKey", strings);
} catch (IOException e) {
//failure;
}
Async put uses the standard AsyncTask provided by the Android framework.
Get Stuff
You can get stuff out of Reservoir synchronously or asynchronously as well.
Async get will give you a callback on completion:
//Get a simple object
Reservoir.getAsync("myKey", MyClass.class, new ReservoirGetCallback<MyClass>() {
@Override
public void onSuccess(MyClass myObject) {
//success
}
@Override
public void onFailure(Exception e) {
//error
}
});
//Get collection
Type resultType = new TypeToken<List<String>>() {}.getType();
Reservoir.getAsync("myKey", resultType, new ReservoirGetCallback<List<String>>() {
@Override
public void onSuccess(List<String> strings) {
//success
}
@Override
public void onFailure(Exception e) {
//error
}
});
synchronous get:
//Get a simple object
try {
Reservoir.get("myKey", MyClass.class);
} catch (IOException e) {
//failure
}
//Get collection
Type resultType = new TypeToken<List<String>>() {}.getType();
try {
Reservoir.get("myKey", resultType);
} catch (IOException e) {
//failure
}
Check for existence
If you wish to know whether an object exists for the given key, you can use:
try {
boolean objectExists = Reservoir.contains("myKey");
} catch (IOException e) {}
Delete Stuff
deleting stuff can also be synchronous or asynchronous.
Async delete will give you a callback on completion:
Reservoir.deleteAsync("myKey", new ReservoirDeleteCallback() {
@Override
public void onSuccess(MyClass myObject) {
//success
}
@Override
public void onFailure(Exception e) {
//error
}
});
synchronous delete:
try {
Reservoir.delete("myKey");
} catch (IOException e) {
//failure
}
Clearing the cache
You can clear the entire cache at once if you want.
asynchronous clear:
Reservoir.clearAsync(new ReservoirClearCallback() {
@Override
public void onSuccess() {
try {
assertEquals(0, Reservoir.bytesUsed());
} catch (Exception e) {
}
}
@Override
public void onFailure(Exception e) {
}
});
synchronous clear:
try {
Reservoir.clear();
} catch (IOException e) {
//failure
}
RxJava
Reservoir is down with RxJava! All the async methods have RxJava variants that return observables. These observables are scheduled on a background thread and observed on the main thread by default (you can change this easily by assigning your own schedulers and observers to the returned observable).
First, you'll need to add RxJava dependency to your app since Reservoir does not come bundled with it:
compile 'io.reactivex:rxandroid:<rxandroid-version>' - tested with v1.2.1
compile 'io.reactivex:rxjava:<rxjava-version>' - tested with v1.1.6
Then you can use the RxJava variants of all the regular Reservoir methods.
put:
//Put a simple object
Reservoir.putUsingObservable("myKey", myObject) returns Observable<Boolean>
//Put collection
List<String> strings = new ArrayList<String>();
strings.add("one");
strings.add("two");
strings.add("three");
Reservoir.putUsingObservable("myKey", strings) returns Observable<Boolean>
get:
//Get a simple object
Reservoir.getUsingObservable("myKey", MyClass.class) returns Observable<MyClass>
//Get collection
//Note : Rx observables return items one at a time. So even if you put in a complete collection, the items in the collection will be returned
//one by one by the observable.
Type collectionType = new TypeToken<List<String>>() {}.getType();
Reservoir.getUsingObservable("myKey", String.class, collectionType) returns Observable<String>
delete:
Reservoir.deleteUsingObservable("myKey") returns Observable<Boolean>
clear:
Reservoir.clearUsingObservable() returns Observable<Boolean>
If you'd like to see examples of using these observables, check out the tests in the sample application.
FAQs
What kind of objects can I add to Reservoir?
Anything that GSON can serialize.
What happens if my cache size is exceeded?
Older objects will be removed in a LRU (Least Recently Used) order.
Can I use this a SharedPreferences replacement?
NO! This is a cache. You should store stuff in here that is good to have around, but you wouldn't mind if they were to be removed. SharedPreferences are meant to store user preferences which is not something you want to lose.
Sample
Check out the sample application tests for complete examples of API usage.
Contributing
Contributions welcome via Github pull requests.
Credits
Reservoir is just a tiny little convenience wrapper around the following fantastic projects:
License
This project is licensed under the MIT License. Please refer the License.txt file.
*Note that all licence references and agreements mentioned in the Reservoir README section above
are relevant to that project's source code only.