Android: Cancel Async Task

I use an async task to upload an image and get some results.

While uploading the image I see a progress dialog, written in onPreExecute() method like this:

    protected void onPreExecute() { 
         uploadingDialog = new ProgressDialog(MyActivity.this); 
         uploadingDialog.setMessage("uploading"); 
         uploadingDialog.setCancelable(true);
         uploadingDialog.show();
    }

Ok when I press the back button, obviously the dialog disappears because of the setCancelable(true).

But (obviously) the async task doesn't stop.

So how can I fix this? I want to cancel both dialog and async task when I press the back button. Any ideas?

From SDK:

> Cancelling a task >
> A task can be cancelled at any time by invoking cancel(boolean). > Invoking this method will cause subsequent calls to isCancelled() > to return true.

> After invoking this method, onCancelled(Object), instead of > onPostExecute(Object) will be invoked after doInBackground(Object[]) returns.

> To ensure that a task is cancelled as quickly as possible, > you should always check the return value of isCancelled() periodically from > doInBackground(Object[]), if possible (inside a loop for instance.)

So your code is right for dialog listener:

uploadingDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
    public void onCancel(DialogInterface dialog) {
        myTask.cancel(true);
        //finish();
    }
});

Now, as I have mentioned earlier from SDK, you have to check whether the task is cancelled or not, for that you have to check isCancelled() inside the onPreExecute() method.

For example:

if (isCancelled()) 
	break;
else
{
   // do your work here
}

FOUND THE SOLUTION: I added an action listener before uploadingDialog.show() like this:

    uploadingDialog.setOnCancelListener(new DialogInterface.OnCancelListener(){
          public void onCancel(DialogInterface dialog) {
              myTask.cancel(true);
              //finish();
          }
    });

That way when I press the back button, the above OnCancelListener cancels both dialog and task. Also you can add finish() if you want to finish the whole activity on back pressed. Remember to declare your async task as a variable like this:

    MyAsyncTask myTask=null;

and execute your async task like this:

    myTask = new MyAsyncTask();
    myTask.execute();

I spent a while figuring this out, all I wanted was a simple example of how to do it, so I thought I'd post how I did it. This is some code that updates a library and has a progress dialog showing how many books have been updated and cancels when a user dismisses the dialog:

private class UpdateLibrary extends AsyncTask<Void, Integer, Boolean>{
	private ProgressDialog dialog = new ProgressDialog(Library.this);
	private int total = Library.instance.appState.getAvailableText().length;
	private int count = 0;
	
	//Used as handler to cancel task if back button is pressed
	private AsyncTask<Void, Integer, Boolean> updateTask = null;
	
	@Override
	protected void onPreExecute(){
		updateTask = this;
		dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
		dialog.setOnDismissListener(new OnDismissListener() {				
			@Override
			public void onDismiss(DialogInterface dialog) {
				updateTask.cancel(true);
			}
		});
		dialog.setMessage("Updating Library...");
		dialog.setMax(total);
		dialog.show();
	}

	@Override
	protected Boolean doInBackground(Void... arg0) {
			for (int i = 0; i < appState.getAvailableText().length;i++){
				if(isCancelled()){
					break;
				}
				//Do your updating stuff here
			}
		}
	
	@Override
	protected void onProgressUpdate(Integer... progress){
		count += progress[0];
		dialog.setProgress(count);
	}
	
	@Override
	protected void onPostExecute(Boolean finished){
		dialog.dismiss();
		if (finished)
			DialogHelper.showMessage(Str.TEXT_UPDATELIBRARY, Str.TEXT_UPDATECOMPLETED, Library.instance);
		else 
			DialogHelper.showMessage(Str.TEXT_UPDATELIBRARY,Str.TEXT_NOUPDATE , Library.instance);
	}
}

create some member variables in your activity like

YourAsyncTask mTask;
Dialog mDialog;

use these for your dialog and task;

in onPause() simply call

if(mTask!=null) mTask.cancel(); 
if(mDialog!=null) mDialog.dismiss();

I would like to improve the code. When you canel the aSyncTask the onCancelled() (callback method of aSyncTask) gets automatically called, and there you can hide your progressBarDialog.

You can include this code as well:

public class information extends AsyncTask<String, String, String>
	{
		@Override
		protected void onPreExecute() {
			super.onPreExecute();
		}

		@Override
		protected String doInBackground(String... arg0) {
			return null;
		}
		
		@Override
		protected void onPostExecute(String result) {
			super.onPostExecute(result);
			this.cancel(true);
		}
		
		@Override
		protected void onProgressUpdate(String... values) {
			super.onProgressUpdate(values);
		}
		
		@Override
		protected void onCancelled() {
			Toast.makeText(getApplicationContext(), "asynctack cancelled.....", Toast.LENGTH_SHORT).show();
			dialog.hide(); /*hide the progressbar dialog here...*/
			super.onCancelled();
		}
		
	}

Most of the time that I use AsyncTask my business logic is on a separated business class instead of being on the UI. In that case, I couldn't have a loop at doInBackground(). An example would be a synchronization process that consumes services and persist data one after another.

I end up handing on my task to the business object so it can handle cancelation. My setup is like this:

public abstract class MyActivity extends Activity {

	private Task mTask;
	private Business mBusiness;

	public void startTask() {
		if (mTask != null) {
			mTask.cancel(true);
		}
		mTask = new mTask();
		mTask.execute();
	}
}

protected class Task extends AsyncTask<Void, Void, Boolean> {
	@Override
	protected void onCancelled() {
		super.onCancelled();
		
		mTask.cancel(true);

		// ask if user wants to try again
	}

	@Override
	protected Boolean doInBackground(Void... params) {
		return mBusiness.synchronize(this);
	}
	
	@Override
	protected void onPostExecute(Boolean result) {
		super.onPostExecute(result);
		
		mTask = null;
		
		if (result) {
			// done!
		}
		else {
			// ask if user wants to try again
		}
	}
}

public class Business {
	public boolean synchronize(AsyncTask<?, ?, ?> task) {
		boolean response = false;
		response = loadStuff(task);
		
		if (response)
			response = loadMoreStuff(task);
			
		return response;
	}

	private boolean loadStuff(AsyncTask<?, ?, ?> task) {
		if (task != null && task.isCancelled()) return false;

		// load stuff

		return true;
	}
}

I had a similar problem - essentially I was getting a NPE in an async task after the user had destroyed the activity. After researching the problem on Stack Overflow, I adopted the following solution:

volatile boolean running;

public void onActivityCreated (Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    
    running=true;
    ...
    }


public void onDestroy() {
    super.onDestroy();

    running=false;
    ...
}

Then, I check "if running" periodically in my async code. I have stress tested this and I am now unable to "break" my activity. This works perfectly and has the advantage of being simpler than some of the solutions I have seen on SO.

You can just ask for cancellation but not really terminate it. See this answer.

How to cancel AsyncTask

Full answer is here - Android AsyncTask Example

AsyncTask provides a better cancellation strategy, to terminate currently running task.

cancel(boolean mayInterruptIfitRunning)

myTask.cancel(false)- It makes isCancelled returns true. Helps to cancel the task.

myTask.cancel(true) – It also makes isCancelled() returns true, interrupt the background thread and relieves resources .

It is considered as an arrogant way, If there is any thread.sleep() method performing in background thread, cancel(true) will interrupt background thread at that time. But cancel(false) will wait for it and cancel task when that method completes.

If you invoke cancel() and doInBackground() hasn’t begun execute yet. onCancelled() will invoke.

After invoking cancel(…) you should check value returned by isCancelled() on doInbackground() periodically. just like shown below.

protected Object doInBackground(Params… params)  { 
 while (condition)
{
 ...
if (isCancelled()) 
break;
}
return null; 
}