Android AsyncTask

sirin sevinc — Tue, 11 May 2010 16:19:44 +0000

My Android Experience

AsyncTask

AysncTask is another way of making some background work without blocking the UI thread. You can also create your own runnable implementation and run it by posting it to the handler. However I find using AsyncTask more simplier.

In my project I wanted to display a ProgressDialog until the screen is filled with data. Data could be fetched from a server or a local database. In order to achieve this task I decided to use AsyncTask. This class has two important methods ,

protected Result doInBackground(Params… params)

where all the background operations should be made whitin this method but you can not make any UI updates.

and

protected void onPostExecute(Result result)

where the UI could be updated according to the result of the background operation.

What I needed was a some kind of AsyncTask which displays a ProgressDialog until the background operation is finished and when onPostExecute method is called it would dismiss the dialog. When you think like that it looks very simple.

Creating a progressDialog in the constructor and displaying it immediately and dismissing it in onPostExecute method. Unfortunately this didnt work because UI thread was blocked by the ProgessDialog, it was tied to it and that’s why it wasn’t possible to dismiss the dialog. Finally I came up with another idea. First I created another class “ProgressTimedTask” which extends AsyncTask. It has a progressDialog as a member field. The source code looks like this.

//this is an abstract class which basically does nothing but works as a template for other task classes
public abstract class ProgressTimedTask extends AsyncTask {
private ProgressDialog dialog;

public void showWarningMessage() {
Toast.makeText(dialog.getContext(), "Sorry but no response from the server, why dont you try again later!",
Toast.LENGTH_LONG).show();
}

public final void dismiss() {
cancel(true);
dialog.dismiss();
}

@Override
protected final void onPostExecute(Result result) {
super.onPostExecute(result);
runOnPostExecute(result);
dialog.dismiss();
}

protected void runOnPostExecute(Result result) {
// delegate method
}

@Override
protected final Result doInBackground(Params... params) {
return runInBackground(params);
}

protected abstract Result runInBackground(Params... params);

public final void setDialog(ProgressDialog dialog) {
this.dialog = dialog;
}

public final void showProgressDialog() {
 if (this.dialog != null) {
    this.dialog.show();
  }
 }
}

As you can see the methods overridden from AsyncTask class are marked as final as I don’t want sub classes of this ProgessTimedTask class to override these methods. I wanted this class to act as a template and I wanted to keep the control of the ProgressDialog’s lifecycle within that class, that’s why it cannot be accessed from outside. And here is a class which extends ProgessTimedTask .

public class BasicTimedTask extends ProgressTimedTask {

private DelegateTaskActivity delegateTaskActivity;

private BasicTimedTask(DelegateTaskActivity delegateTaskActivity) {
    this.delegateTaskActivity = delegateTaskActivity;
}

@Override
protected Void runInBackground(Void... xxx) {
    return delegateTaskActivity.getData(xxx);
}

@Override
protected void runOnPostExecute(Void x) {
   delegateTaskActivity.updateUI(x);
 }
}

Here DelegateTaskActivity is an interface, I assumed that the class which instantiates BasicTimedTask should also provide the class which does the background job and update the UI. in my example this class is the activity class, simply whenever I want to display a ProgressDialog in my activity while fetching data from somewhere , my activity class implements DelegateTaskActivity.

And now it’s time to create an instance of this BasicTimedTask class. Here how I do it …

ProgressDialog progressDialog = new ProgressDialog(context);
progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
progressDialog.setMessage("Loading ... ");
progressDialog.setIndeterminate(true);
progressDialog.setCancelable(true);

ProgressTimedTask timedTask = new BasicTimedTask(delegateTaskActivity);
timedTask.setDialog(progressDialog);
timedTask.showProgressDialog();

As you can see before executing the task I called showProgressDialog() method which displays the progress dialog.I also wanted to add a timeout functionality so that after certain amount of time the task will stop executing and null result will be returned. In order to do that I needed a Future task which will be responsible of executing the timedTask. Here is the source code of FutureTask

final FutureTask futureTask = new FutureTask(new Runnable() {

@Override
public void run() {
task.execute(params);
try {
task.get();
} catch (InterruptedException e) {
task.cancel(true);
} catch (ExecutionException e) {
task.cancel(true);
} catch (CancellationException e) {
task.cancel(true);
}
}
}, null);

Because I dont want to block the UI thread here is the trick. This future task will be executed by another thread and if the timeout occurs then the message is displayed to the users. It seems a bit complicated but certainly it works! Here is the last bit of the code

Runnable r = new Runnable() {

			@Override
			public void run() {
				boolean timeout = false;
				try {

					Executors.newSingleThreadExecutor().execute(futureTask);
					futureTask.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
				} catch (InterruptedException e) {
					Log.d(TAG, "InterruptedException dismissing the task", e);
				} catch (ExecutionException e) {
					Log.d(TAG, "ExecutionException dismissing the task", e);
				} catch (TimeoutException e) {
					Log.d(TAG, "TimeoutException dismissing the task", e);
					timeout = true;
				} catch (CancellationException e) {
					Log.d(TAG, "CancellationException dismissing the task", e);
				} finally {
					task.dismiss();
					if (timeout && showWarningMessage) {
						handler.post(new Runnable() {
							@Override
							public void run() {
								task.showWarningMessage();
							}
						});

					}

				}

			}
		};

		Executors.newSingleThreadExecutor().execute(r);

Filed under: android

Android ArrayAdapter

sirin sevinc — Tue, 11 May 2010 14:18:40 +0000

My Android Experience

ArrayAdapter

Let’s say you need a simple ArrayAdapter but it might not be as simple as you think if you want to use List of complex objects in that adapter.

Here is my solution…

 ArrayAdapter greetingAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1,greetings) {
 @Override
 public View getView(int position, View convertView, ViewGroup parent) {

 TextView view = (TextView) super.getView(position, convertView, parent);
 view.setText(greetings.get(position).getName());
 return view;
 }
 };

How about you want to use your own layout rather than the built-in one. It’s possible but with a limitation. You can not simple call getView method of the super class as it requires only TextView to be present in your layout. If it’s what you need then no problem but if you want to display more than one column in your ArrayAdapter then you should create your own view using the inflater. Here is my sample…

ArrayAdapter arrayAdapter=new ArrayAdapter(this, R.layout.forwardingphonelist_item, forwardingPhones) {
@Override
 public View getView(int position, View convertView, ViewGroup parent) {

 LinearLayout view = (convertView != null) ? (LinearLayout) convertView : createView(parent);

 ForwardingPhone forwardingPhone = forwardingPhones.get(position);

 if (forwardingPhone.getPhoneEnabled()) {
 view.setBackgroundColor(Color.parseColor("#99CCFF"));
 }

 TextView nameView = (TextView) view.findViewById(R.id.phoneName);
 nameView.setText(forwardingPhone.getPhoneName());

 TextView type = (TextView) view.findViewById(R.id.phoneType);
 type.setText(forwardingPhone.getPhoneType());

 TextView phoneNumber = (TextView) view.findViewById(R.id.phoneNumber);
 phoneNumber.setText(forwardingPhone.getPhoneNumber());

 return view;
 }

 private LinearLayout createView(ViewGroup parent) {
 LinearLayout item = (LinearLayout) getLayoutInflater().inflate(R.layout.forwardingphonglist_item,
 parent, false);
 return item;
 }
};

the layout xml file for R.layout.forwardingphonelist_item is as follows :

Filed under: android

handy

Android AsyncTask

My Android Experience

AsyncTask

Android ArrayAdapter

My Android Experience

ArrayAdapter