This lesson teaches you to
Video
Volley: Easy, Fast Networking for Android
The previous lesson showed you how to use the convenience method
Volley.newRequestQueue
to set up a
RequestQueue
, taking advantage of
Volley's default behaviors. This lesson walks you through the explicit steps of creating a
RequestQueue
, to allow you to supply your own custom behavior.
This lesson also describes the recommended practice of creating a
RequestQueue
as a singleton, which makes the
RequestQueue
last the lifetime of your app.
Set Up a Network and Cache
A
RequestQueue
needs two things to do its job: a network to perform transport
of the requests, and a cache to handle caching. There are standard implementations of these
available in the Volley toolbox:
DiskBasedCache
provides a one-file-per-response
cache with an in-memory index, and
BasicNetwork
provides a network transport based
on your choice of
AndroidHttpClient
or
HttpURLConnection
.
BasicNetwork
is Volley's default network implementation. A
BasicNetwork
must be initialized with the HTTP client your app is using to connect to the network.
Typically this is
AndroidHttpClient
or
HttpURLConnection
:
-
Use
AndroidHttpClient
for apps targeting Android API levels lower than API Level 9 (Gingerbread). Prior to Gingerbread,HttpURLConnection
was unreliable. For more discussion of this topic, see Android's HTTP Clients . -
Use
HttpURLConnection
for apps targeting Android API Level 9 (Gingerbread) and higher.
To create an app that runs on all versions of Android, you can check the version of Android the device is running and choose the appropriate HTTP client, for example:
HttpStack stack; ... // If the device is running a version >= Gingerbread... if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) { // ...use HttpURLConnection for stack. } else { // ...use AndroidHttpClient for stack. } Network network = new BasicNetwork(stack);
This snippet shows you the steps involved in setting up a
RequestQueue
:
RequestQueue mRequestQueue; // Instantiate the cache Cache cache = new DiskBasedCache(getCacheDir(), 1024 * 1024); // 1MB cap // Set up the network to use HttpURLConnection as the HTTP client. Network network = new BasicNetwork(new HurlStack()); // Instantiate the RequestQueue with the cache and network. mRequestQueue = new RequestQueue(cache, network); // Start the queue mRequestQueue.start(); String url ="http://www.myurl.com"; // Formulate the request and handle the response. StringRequest stringRequest = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() { @Override public void onResponse(String response) { // Do something with the response } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { // Handle error } }); // Add the request to the RequestQueue. mRequestQueue.add(stringRequest); ...
If you just need to make a one-time request and don't want to leave the thread pool
around, you can create the
RequestQueue
wherever you need it and call
stop()
on the
RequestQueue
once your response or error has come back, using the
Volley.newRequestQueue()
method described in
Sending a Simple
Request
. But the more common use case is to create the
RequestQueue
as a
singleton to keep it running for the lifetime of your app, as described in the next section.
Use a Singleton Pattern
If your application makes constant use of the network, it's probably most efficient to
set up a single instance of
RequestQueue
that will last the lifetime of your app.
You can achieve this in various ways. The recommended approach is to implement a singleton
class that encapsulates
RequestQueue
and other Volley
functionality. Another approach is to subclass
Application
and set up the
RequestQueue
in
Application.onCreate()
.
But this approach is
discouraged
; a static singleton can provide the same functionality in a more modular
way.
A key concept is that the
RequestQueue
must be instantiated with the
Application
context, not an
Activity
context. This
ensures that the
RequestQueue
will last for the lifetime of your app, instead of
being recreated every time the activity is recreated (for example, when the user
rotates the device).
Here is an example of a singleton class that provides
RequestQueue
and
ImageLoader
functionality:
private static MySingleton mInstance; private RequestQueue mRequestQueue; private ImageLoader mImageLoader; private static Context mCtx; private MySingleton(Context context) { mCtx = context; mRequestQueue = getRequestQueue(); mImageLoader = new ImageLoader(mRequestQueue, 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 synchronized MySingleton getInstance(Context context) { if (mInstance == null) { mInstance = new MySingleton(context); } return mInstance; } public RequestQueue getRequestQueue() { if (mRequestQueue == null) { // getApplicationContext() is key, it keeps you from leaking the // Activity or BroadcastReceiver if someone passes one in. mRequestQueue = Volley.newRequestQueue(mCtx.getApplicationContext()); } return mRequestQueue; } public <T> void addToRequestQueue(Request<T> req) { getRequestQueue().add(req); } public ImageLoader getImageLoader() { return mImageLoader; } }
Here are some examples of performing
RequestQueue
operations using the singleton
class:
// Get a RequestQueue RequestQueue queue = MySingleton.getInstance(this.getApplicationContext()). getRequestQueue(); ... // Add a request (in this example, called stringRequest) to your RequestQueue. MySingleton.getInstance(this).addToRequestQueue(stringRequest);