Volley is an android library released by Google that can make your life easier when dealing with network operations. In this blog post I will mention the main features of the library and show a few example usages, in particular, how to make a request, how to download images, and how to use the cache.
Features of Volley library
a) Automatically schedules the network requests
b) Supports request prioritization. This means that you can load content depending of priorities, for example the main content could have a high priority, but the images a low priority.
c) Provides transparent disk and memory cache that allows for quick reloading of data. Transparent cache means that the caller doesn’t have to know about the existence of the cache. That is, the cache is implemented automatically. You do, however, have the possibility to disable the caching.
d) Provides a good API for canceling requests. You can cancel a single request, or cancel requests depending on some filters.
Besides the great features that Volley comes with, you don’t have to use it for everything. Volley is great for RPC-style network operations that populate UI, a typical example would be loading thumbnail images into a ListView, but not very good for streaming operations like downloading a video or mp3.
Getting started with Volley
1. Clone the Volley project:
git clone https://android.googlesource.com/platform/frameworks/volley
2. Import the library into your project
The most frequent classes of Volley that you will work with are RequestQueue and Request, and ImageLoader when dealing with images loading.
RequestQueue is used for dispatching requests to the network. It is recommended to create it early and use it as a Singleton.
Request is the base class for creating network requests (GET, POST).
ImageLoader is a helper class that handles loading and caching images from remote URLs.
Step 1: VolleySingleton.java
As recommended, lets create first a Singleton class that will return on demand an instance of RequestQueue and one of ImageLoader.
public class VolleySingleton {
private static VolleySingleton instance;
private RequestQueue requestQueue;
private ImageLoader imageLoader;
private VolleySingleton(Context context) {
requestQueue = Volley.newRequestQueue(context);
imageLoader = new ImageLoader(requestQueue, new ImageLoader.ImageCache() {
private final LruCache<String, Bitmap> cache = new LruCache<String, Bitmap>(20);
@Override
public Bitmap getBitmap(String url) {
return cache.get(url);
}
@Override
public void putBitmap(String url, Bitmap bitmap) {
cache.put(url, bitmap);
}
});
}
public static VolleySingleton getInstance(Context context) {
if (instance == null) {
instance = new VolleySingleton(context);
}
return instance;
}
public RequestQueue getRequestQueue() {
return requestQueue;
}
public ImageLoader getImageLoader() {
return imageLoader;
}
}
Step 2: Add internet permission
<uses-permission android:name="android.permission.INTERNET" />
Step 3: Create an instance of RequestQueue
RequestQueue queue = VolleySingleton.getInstance(this).getRequestQueue();
Step 4: Create the request
Volley comes with a class called JsonRequest that you can use to make requests to a server that returns a json response.
However, in this example we will query an RSS feed which returns a response in XML format. Volley does not include a similar class for handling xml responses, like JsonRequest, but it has StringRequest class that can be used to retrieve the response body as a String.
There are two ways to construct a StringRequest:
StringRequest(int method, String url, Listener<String> listener,
ErrorListener errorListener)
or
StringRequest(String url, Listener<String> listener, ErrorListener errorListener)
The second constructor does not take the request method as a parameter, when not specified, a GET request is created.
Listener is a callback interface for delivering the result, and
ErrorListener is a callback interface for delivering error responses.
Example:
String url = "http://www.pcworld.com/index.rss";
StringRequest request = new StringRequest(url, new Listener<String>() {
@Override
public void onResponse(String response) {
// we got the response, now our job is to handle it
parseXmlResponse(response);
}
}, new ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
//something happened, treat the error.
}
});
Step 6: Execute the request
queue.add(request);
And that is all! The execution of the request implies its addition to the RequestQueue.
Step 7: Loading thumbnail images
Loading images can be done easy if you replace the android’s ImageView with Volley’s NetworkImageView:
<com.android.volley.toolbox.NetworkImageView
android:id="@+id/icon"
android:layout_width="80dp"
android:layout_height="80dp"
android:src="@drawable/default_placeholder" />
then use setImageUrl() and you are done!
String url = "..."; // URL of the image ImageView imageView = (ImageView)view.findViewById(R.id.image); ImageLoader imageLoader = VolleySingleton.getImageLoader(); imageView.setImageUrl(url, imageLoader);
If, for some reason, you don’t want or can’t use NetworkImageView, then there’s an alternate method.
You can use the get() method of ImageLoader class which accepts the image url and an instance of ImageListener:
ImageLoader imageLoader = VolleySingleton.getImageLoader();
imageLoader.get(url, new ImageListener() {
public void onErrorResponse(VolleyError error) {
imageView.setImageResource(R.drawable.icon_error); // set an error image if the download fails
}
public void onResponse(ImageContainer response, boolean arg1) {
if (response.getBitmap() != null) {
imageView.setImageBitmap(response.getBitmap());
}
}
});
Reading from cache
One of the Volley’s features is that it provides transparent disk and memory cache. The cache is implemented automatically for classes that extends Request, such as JsonRequest and StringRequest.
To read the cache:
Entry entry = queue.getCache().get(url);
if(entry!=null){
String data = new String(entry.data, "UTF-8");
// process data
}
To turn off the cache:
request.setShouldCache(false);
to remove the cache for a specific request:
queue.getCache().remove(url);
to clear all cache:
queue.getCache().clear();
to invalidate the cache: this will allow to display the cached data until the response is received. When the response is received, it will automatically override the cached data.
queue.getCache().invalidate(url, true);
For more details about Volley you can watch the full video at: https://developers.google.com/events/io/sessions/325304728
Android Research Blog 