Android Development Patterns: Best Practices for Professional Developers (2016)

---

The CheckUrlTask class extends AsyncTask, allowing it to run separately from the UI thread. This helps keep applications responsive and protects the application from crashing in case of any network lag or delay. In fact, without specifically ordering your application to run network tasks on the UI thread, you will receive a NetworkOnMainThread error when your application runs. When CheckUrlTask() runs, it attempts to load the URL passed to it, and by using onPostExecute(), it displays a toast with the results returned from theurlResponse() method.

The urlResponse() method creates an InputStream that is used to contain the value of an HTTP request made to a remote server.

Another way to deal with network connections, including queuing and canceling, is to use Volley.

Volley

Volley is an HTTP library that is useful to developers who want to build scheduling and management into their network connections. Volley is particularly useful for fetching items to update widgets, return search results, or even as a network resource cache. The Volley library is available for download from the Android Open Source Project at https://android.googlesource.com/platform/frameworks/volley. To get started using Volley, you will need to find a compiled volley.jar file, clone the repository, and import the clone as a library project, or you will need to run the build scripts to make your own volley.jar file.

To clone the repository with Git, run the following command:

git clone https://android.googlesource.com/platform/frameworks/volley

After you have cloned the repository, open a terminal window and move into the folder and run the following build script (note that you must have Apache Ant installed in order for the build to work):

android update project -p .
ant jar

If running ant in your terminal does not work, make sure you have added the bin folder of Ant to your system path or environment variables.

When the build script is complete, you should have a volley.jar file that you can use in your Android project. Depending on the IDE you are using, this may be as simple as copying the file into your libs folder, or you may have to copy it as well as right-click the .jar file and choose Add as Library, and then perform a clean/build of your application.

Once the jar or library project has been added to your application, make sure you have added the android.permission.INTERNET to your application manifest.

Because Volley was created to make things easier for developers, several convenience methods have been built to help you perform otherwise manual tasks. To demonstrate this, instead of having to manually create a queue to handle network requests, you can use the following:

RequestQueue queue = Volley.newRequestQueue(this);

This creates a queue that can then be used to process requests that have been added. To add a request, you need to create one and then use the .add() method on your queue object. The following demonstrates how this is done:

String url = "http://developer.android.com/";
StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
new Response.Listener() {
@Override
public void onResponse(String response) {
// the server responded, handle response here
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// add error message here
}
});
queue.add(stringRequest);

Multiple requests can be built and will then be handled by worker threads in the background. Results are delivered to the main UI thread, allowing you to update controls and widgets. Requests that require data may be updated by data that is in the cache, thus speeding up processes and saving on network trips.

Another benefit of using Volley is that you can stop requests in the queue should you no longer need them. To stop requests, tag them to the Activity that calls them. This can be done as follows:

public static final String TAG = "DataRequestTag";
StringRequest stringRequest;
RequestQueue queue;

// Tag the request
stringRequest.setTag(TAG);

// Queue the request
queue.add(stringRequest);

Now that the requests have been tagged, you can cancel them from processing from the onStop() method of your Activity:

@Override
protected void onStop () {
super.onStop();
if (queue != null) {
queue.cancelAll(TAG);
}
}

So far, we have covered using a stringRequest, but a few other requests are built into Volley. You can also make an ImageRequest, JsonObjectRequest, and JsonArrayRequest.

When making an ImageRequest, you need to have an ImageView to place your image as well as the URL where the image lives. Once you have these, you can make the request. An ImageRequest may look like the following:

ImageRequest request = new ImageRequest(url,
new Response.Listener() {
@Override
public void onResponse(Bitmap bitmap) {
// set the image
mImageView.setImageBitmap(bitmap);
}
}, 0, 0, null,
new Response.ErrorListener() {
public void onErrorResponse(VolleyError error) {
// handle the error with error resource
mImageView.setImageResource(R.drawable.image_load_error);
}
});

You may have noticed that this example is missing the add() method. This is because you may want to work with a singleton class when using images. If you need an example of setting up a singleton, you can find one athttps://developer.android.com/training/volley/requestqueue.html#singleton.

After adding the class, you can then queue the imageRequest, as follows:

MySingleton.getInstance(this).addToRequestQueue(request);

To work with a JSON array or object, you should either use JsonArrayRequest or JsonObjectRequest, respectively. The following demonstrates working with a JSON object:

JsonObjectRequest jsonObjRequest = new JsonObjectRequest
(Request.Method.GET, url, null, new Response.Listener() {

@Override
public void onResponse(JSONObject response) {
// handle the response
}
}, new Response.ErrorListener() {

@Override
public void onErrorResponse(VolleyError error) {
// handle the error
}
});

Working with JSON data may also require the use of the singleton class, making use of the queue, similar to how the imageRequest was performed:

MySingleton.getInstance(this).addToRequestQueue(jsonObjRequest);

Summary

In this chapter, you learned about using an HTTP client and how to connect and send data. You also learned how to parse through XML files for data, and that using a skip method can help you return the data you want. You also learned why AsyncTasks are used when working with network functions. Lastly, you learned that, by using the Volley library, you can gain finer control over your network connections and requests.