Threading in Android part 2 Async Tasks

In the previous post we saw one way to deal with threads in Android, which is by using Handlers. In this post well see how to use another technique which is using AsyncTask class.

AsyncTask is an abstract class that provides several methods managing the interaction between the UI thread and the background thread. its implementation is by creating a sub class that extends AsyncTask and implementing the different protected methods it provides.

Lets demonstrate how to user AsyncTask by creating a simple activity that has two buttons and a progress bar:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
 
 android_layout_width="match_parent"
 android_layout_height="match_parent"
 android_orientation="vertical"
 >
 <Button
 android_id="@+id/btn"
 android_layout_width="fill_parent"
 android_layout_height="wrap_content"
 android_text="Show Progress"
 ></Button>
 <ProgressBar
 android_layout_width="fill_parent"
 android_layout_height="wrap_content"
 android_id="@+id/progress"
 style="?android:attr/progressBarStyleHorizontal"
 ></ProgressBar>
 <Button
 android_id="@+id/btnCancel"
 android_layout_width="fill_parent"
 android_layout_height="wrap_content"
 android_text="Cancel"
 ></Button>
</LinearLayout>

Here we have two buttons: one to start progress and the other to stop it.

Creating the AsyncTask sub class:

The first step in implementing AsyncTask is to create a sub class like this:

class ProgressTask extends AsyncTask<Params, Progress, Result>{
}

The AsyncTask declaration has three Varargs parameters which are:

1. Params: parameter info passed to be used by the AsyncTask.
2. Progress: the type of progress that the task accomplishes.
3. The result returned after the AsyncTask finishes.

These parameters are of type Varargs which provide the flexibility to pass dynamic sized arrays as parameters.

In our example our class will be like this:

class ProgressTask extends AsyncTask<Integer, Integer, Void>{
}

The parameter and the progress are of type Integer and the result is Void as our tasks does not return anthing (returns null).
The second step is overriding the protected methods defined by the AsyncTask class that handle the execution life cycle of the AsyncTask.

We have five methods to implement which are:

1. onPreExecute: the first method called in the AsyncTask, called on the UI thread.
2. doInBackground: the method that executes the time consuming tasks and publish the task progress, executed in background thread.
3. onProgressUpdate: method that updates the progress of the AsyncTask, run on the UI thread.
4. onPostExecute: the final method that gets called after doInBackground finishes, here we can update the UI with the results of the AsyncTask.
5. onCancelled: gets called if the AsyncTask.cancel() methods is called, terminating the execution of the AsyncTask.

Starting the AsyncTask:

To start the AsyncTask we create an instance of it, then call the execute() method passing the initial parameters like this:

ProgressTask task=new ProgressTask();
// start progress bar with initial progress 10
task.execute(10);

Implementing the AsyncTask:

class ProgressTask extends AsyncTask<Integer, Integer, Void>{

 @Override
 protected void onPreExecute() {
 // initialize the progress bar
 // set maximum progress to 100.
 progress.setMax(100);

 }

 @Override
 protected void onCancelled() {
 // stop the progress
 progress.setMax(0);

 }

 @Override
 protected Void doInBackground(Integer... params) {
 // get the initial starting value
 int start=params[0];
 // increment the progress
 for(int i=start;i<=100;i+=5){
 try {
 boolean cancelled=isCancelled();
 //if async task is not cancelled, update the progress
 if(!cancelled){
 publishProgress(i);
 SystemClock.sleep(1000);

 }

 } catch (Exception e) {
 Log.e("Error", e.toString());
 }

 }
 return null;
 }

 @Override
 protected void onProgressUpdate(Integer... values) {
 // increment progress bar by progress value
 progress.setProgress(values[0]);

 }

 @Override
 protected void onPostExecute(Void result) {
 // async task finished
 Log.v("Progress", "Finished");
 }

 }

Here are the steps:

1. onPreExecute() method first gets called initializing the maximum value of the progress bar.
2. doInBackground(Integer... params) methods gets called by obtaining the initial start value of the progress bar then incrementing the value of the progress bar every second and publishing the progress as long as the async task is not cancelled.
3. onProgressUpdate(Integer... values) method is called each time progress is published from doInBackground, thus incrementing the progress bar.
4. onPostExecute(Void result) is called after doInBackground finished execution.
5. void onCancelled() is called if task.cancel(true) is called from the UI thread. it may interrupt the execution preventing onPostExecute from being executed.

The onClick handler of our buttons is like this:

@Override
 public void onClick(View v) {
 ProgressTask task=new ProgressTask();
 switch(v.getId()){
 case R.id.btn:
 task.execute(10);
 break;
 case R.id.btnCancel:
 task.cancel(true);
 break;
 }

 }

Read More..

Explicit Intent Android Tutorial for Beginners Part 2

Having introduced you to the basic anatomy of an android application in the Part 1 of the series, I would like to show you an example where communication between 2 activities happens through an intent.

However, just one more detail to be introduced as promised and that is -

There are 2 types of intents that Android understands.

1. Explicit Intent

2. Implicit Intent

In an Explicit intent, you actually specify the activity that is required to respond to the intent. In other words, you explicitly designate the target component. This is typically used for application internal messages.

In an Implicit intent (the main power of the android design), you just declare an intent and leave it to the platform to find an activity that can respond to the intent. Here, you do not declare the target component and hence is typically used for activating components of other applications seamlessly

Note: Here for simplicity sake I tell an activity responds to an intent, it could as well be other types of components.

Now I will jump into the example which you can download from here:

This example has 2 activities:
1. InvokingActivity
2. InvokedActivity
The InvokingActivity has a button "Invoke Next Activity" which when clicked explicitly calls the "InvokedActivity" class.
The relevant part of the code is here:

        Button invokingButton = (Button)findViewById(R.id.invokebutton);
        invokingButton.setOnClickListener(new OnClickListener() {
        
         public void onClick(View v) {
         Intent explicitIntent = new Intent(InvokingActivity.this,InvokedActivity.class);
         startActivity(explicitIntent);
         }
        });

As explained in part 1 of the series, this is very much like an API call with compile time binding.

NOTE: The layout for InvokingActivity is defined in main.xml and for InvokedActivity in InvokedActivity.xml. The downloadable example can be opened in Eclipse Ganymede as an android project and can be executed.

In the next part of the series, we will see how to work with implicit intents which also needs us to understand intent-filters. 

Read More..