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

Starting a service from an IntentService allows long-running services to be managed on a separate thread from the main UI thread and should be strongly considered when creating services to use with your application.

Working Asynchronously

When creating an application, there are times when you may want to perform an action without interrupting application processing. This process is known as asynchronous processing and is not limited to application development.

Web developers have struggled against loading scripts and processes for years. In HTML5, the addition of the async property to a <script> element allows scripts to be queued up and requested without stopping the rendering of the web page.

Android applications are visually run on one UI thread that is not thread-safe. This means that you must do all visual updates on the UI thread, but it also means that you cannot use operations that slow down or interrupt the UI thread, such as network or Web API operations. If you do manage to interrupt the thread, your application will stall and you may experience an ANR error due to exceptions being thrown by the system.

To get around the limitations of the UI thread, you can create worker threads. This still requires a bit of finesse because you have to be careful not to create a process that is not thread-safe. You can leverage three methods to help maintain thread-safe operations:

runOnUiThread(Runnable action): Will queue the task to run on the UI thread. If the task is already on the UI thread, it will run immediately.

post(Runnable action): Adds the action to the message queue to be run on the UI thread. Returns true if the action is successfully placed into the queue.

postDelayed(Runnable action, long delayMillis): Adds the action to the message queue, with the condition of waiting to run until the specified time has been reached. Returns true if the action is successfully placed into queue.

The following is an example of using the post() method to perform thread-safe work:

new Thread(new Runnable() {
public void run() {
// create bitmap and retrieve from network
final Bitmap bitmap =
loadNetworkImage("http://example.com/my-image.png");
// Use .post() method on ImageView to place image
myImageView.post(new Runnable() {
public void run() {
// When queue is reached, place image
myImageView.setImageBitmap(bitmap);
}
});
}
}).start();

Depending on the work you are doing, you may also consider using AsyncTask. The AsyncTask will move processes from the main UI thread to a background process and return results without interrupting the rendering process of the application.

AsyncTask

The AsyncTask should be used with regard to the name it bears. This means you have a somewhat simple or short task that needs to be done.

Using AsyncTask requires you to set up a subclass with at least one method. Three parameterized types are used with AsyncTask: Params, Progress, and Result. Should you not want to use a particular argument, you may use Void.

The following demonstrates a skeleton AsyncTask subclass with a method to run the AsyncTask:

private class MyAsyncTask extends AsyncTask<String, Integer, String> {
@Override
protected String doInBackground(String... parameter) {
// code to run in background as an AsyncTask
}
@Override
protected void onProgressUpdate(Integer... progress){
// code to run for update of AsyncTask
}
@Override
protected void onPostExecute(String result) {
// return data from AsyncTask as well as clean up
}
}

// run the AsyncTask
public void executeAsync(View view) {
MyAsyncTask task = new MyAsyncTask();
task.execute("String value passed to AsyncTask");
}

If the AsyncTask is set to update a progress indicator, the onProgressUpdate() method could be used to pass information to update the indicator. The onPostExecute() method is used to return data to a view, widget, or other component.

Performing service-level operations with an AsyncTask opens up potential application and memory problems. One such potential problem is that an AsyncTask does not recognize configuration changes that cause Activities to be destroyed and re-created. That includes deviceorientation changes. If the AsyncTask happens to be in the middle of processing when the screen is rotated, your progress is lost and an exception will be thrown.

Getting past this issue requires keeping track of the AsyncTask instance by either implementing setRetainInstance(true) or creating a fragment with logic to check whether the AsyncTask is running when the orientation is changed.

Summary

In this chapter, you learned about Model-View-Controller architecture and how it can be applied to Android application development.

You learned that content providers are similar to Models and that information can be accessed between applications by using a content provider, but applications that do not wish to share data may still use a content provider.

You learned that Views and Activities make up the View component of MVC architecture and that activities follow a lifecycle that helps developers understand when callback methods are executed.

You learned that services can make up the Controller component of MVC architecture. Services are long-running components that do not strictly follow application lifecycles and are perfect for keeping things running even when the application is paused.

Finally, you learned about running processes asynchronously to avoid ANR errors and to speed up your application. You learned methods to pass data to the UI thread in a thread-safe manner, and you learned when you should use AsyncTask.