The Problem

---

In the previous post, we learnt how to receive data from a server. One of the requirements was to complete the long running task of receiving the data in a thread other than the UI thread. This was to avoid the Application Not Responding (ANR) problem. We chose AsyncTask to do this. Here we explain the what, why and how of the AsyncTask.

For more info on the application that we are building, click here.

The What and the Why?

---

As per the general working of an android application, everything happens in a single process in a single thread (unless otherwise specified). The main thread is the UI thread and all UI activities are to be done in this. Android suggests that no long running task should be done that could block the UI. If you do, then be sure to meet any android developer’s arch nemesis, the ANR! To avoid such scenarios, Android suggests using worker threads which take care of the heavy tasks and then use the main UI thread to update the UI.

This can be done using normal threads but Android was kind enough to provide a special way to perform such asynchronous tasks. Given the fact that multi-threading is an integral part of the design, AsyncTask definitely makes a developer’s life lot simpler.

The Android Developer’s site has to say the following about AsyncTask which is exactly what it is,

AsyncTask enables proper and easy use of the UI thread. This class allows to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers.

The How

---

Let us now get on to the more interesting part of the AsyncTask. But before that lets us just list down the main methods that you must know to use it in an optimum way.

• AsyncTask: This is the class declaration and must be subclassed in order to be used. The 3 generic types must be specified at the time of subclassing. They are,
  1. Params: This is the type that is sent when execute() is called. They are the parameters that would be required by the background execution. The parameters are always sent as an array.
  2. Progress: You can update the UI at regular intervals while the background execution is carried on. This type provides the unit in which the progress is to be reported. Eg int for a progressbar, String for progress messages.
  3. Result: This is used to specify the result type. Could be a computed value, a boolean to notify success.

Following are the 5 methods that have to be implemented to get the AsyncTask functioning well.

• onPreExecute(): This method is called as soon as we call execute() on the AsyncTask object. The method is called on the UI thread and as a result UI activities like setting up progress bars, initializing views etc can be done here.
• doInBackground(Params… params): This is where all the stuff happens and is a mandatory method to be implemented to get an AsyncTask up and running. All tasks running here are done in a separate thread. To update the UI with any progress, publishProgress(Progress…) can be used. We can either send string messages as updates or units of whatever progress type we have defined.
• onProgressUpdate(Progress… values): This is another method which runs on the UI thread and updates the UI with the progress of the task. The data sent by publishProgress(Progress…) is received here and utilized for updating the UI.
• onPostExecute(Result result): This is called after the task is completed. The return value of the doInBackground(Params… params) is received here. For example, you could receive a boolean value to denote whether the task was successful or not.
• onCancelled(Result result): This method is used to handle the UI activities if the action is cancelled midway. The result from doInBackground(Params… params) is received here, so that it can be used to handle the Cancel scenario. This has been introduced in API 11. Prior to this the method onCancelled() is used. It runs on the UI thread after cancel(boolean) is invoked and doInBackground() has finished.

Under the hood

---

In our previous post, we had written the HttpManager core code inside the AsyncTask. Here is the skeleton code of the AsyncTask. Since our HttpManager doesn’t require progress updates, we have not implemented the onProgressUpdate(Progress… values) method. HttpQuery is the extended AsyncTask() which has a constructor that is used to pass all the parameters that are required in the methods of the HttpQuery.

[sourcecode language="java"]
public class HttpQuery extends AsyncTask<String, String, Boolean>{

private Context mContext = null;
private HttpClient mClient = null;
private HttpGet mRequest = null;
private HttpResponse mResponse = null;

public HttpQuery( Context context, HttpClient client ) {
mContext = context;
mClient = client;
mRequest = new HttpGet();
}

@Override
protected Boolean doInBackground(String… url) {

}

@Override
protected void onCancelled() {
//Just call the super for this case.
//We call this since we hare using an API level
//less than 11.
super.onCancelled();
}

@Override
protected void onPreExecute() {

}

@Override
protected void onPostExecute(Boolean result) {

}
}
[/sourcecode]

We override the onPreExecute() to start a progress dialog and also implement the onCancel of the dialog, so that our user can stop updating the latest info if he wishes to do so.
[sourcecode language="java"]
protected void onPreExecute() {
mProgress = ProgressDialog.show(mContext, "Updating…", "Fetching Forex Rates…");
mProgress.setCancelable(true);
mProgress.setOnCancelListener(new OnCancelListener() {

@Override
public void onCancel(DialogInterface dialog) {
cancel(true);
}
});
super.onPreExecute();
}
[/sourcecode]

The doInBackground() takes the url that is to be downloaded and on success returns a true. The http related code has been explained in the previous post.
[sourcecode language="java"]
protected Boolean doInBackground(String… url) {
try {
mRequest.setURI(new URI(url[0]));
mResponse = mClient.execute(mRequest);
Log.i(TAG, mResponse.getStatusLine().getReasonPhrase());
return true;
} catch (ClientProtocolException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
} catch (URISyntaxException e) {
Log.i(TAG, "Please check the Url!");
e.printStackTrace();
return false;
}
}
[/sourcecode]

The onPostExecute() gets the result from the method above and based on it displays a message. And then dismisses the dialog.
[sourcecode language="java"]
protected void onPostExecute(Boolean result) {
Log.i(TAG, "Step 5");
if( result ){
mProgress.setMessage("Succesfully Downloaded!");
Log.i(TAG, "Successfully Downloaded!");
}else{
mProgress.setMessage("Failed to download ");
Log.i(TAG, "Failed to download ");
}
mProgress.dismiss();
super.onPostExecute(result);
}
[/sourcecode]

Final Review

---

We learnt,

• How to extend an AsyncTask to perform a long running task in a worker thread and as a result avoid an ANR.
• The various methods in the Asynctask that can be overridden and what they do.
• How to add a progress dialog and dismiss it while a long running task is run in the background.

The code provided in the previous post will suffice. Run it and observe the progress dialog. You can also check the LogCat in your Eclipse for the success/fail messages.