How to use Runnable.wait() in AsyncTask? Why does the AsyncTask NOT wait...?

Question

I am using AsyncTask to run a background operation. Of course switching to another thread while already working in a background thread does not make a lot of sense in general, except the other thread is the UI thread. This what I would like to to: While the task is running I need to "access" the UI, e.g. to show a dialog to ask the user how to proceed. - run the background task - stop the task at some point to get user feedback - switch to the UI thread to show dialog and ask for input - switch back to background task and continue work How can this be done? I thought I could use `Runnable` with `myActivity.runOnUiThread(runnable)` but this does not work: ``` private void copyFiles() { CopyTask copyTask = new CopyTask(this); copyTask.execute(); } // CustomAsyncTask is a AsyncTask subclass that takes a reference to the current // activity as parameter private class CopyTask extends CustomAsyncTask<Void, Void, Void> { private doCopy; @Override protected Boolean doInBackground(Void... par…

Accepted Answer

The Basics

When you start an `AsyncTask` first the `onPreExecute()` method runs on the UI thread. You can override this method to make changes to the UI prior to the `doInBackground()` method running.

After the `doInBackground()` method finishes, the `onPostExecute()` method runs on the UI thread, so you can use this to make changes to the UI from here. If you need to make regular changes to the UI Thread during the `doInBackground()` method you override the `onProgressUpdate()` method which runs on the UI Thread, and then call it from within `doInBackground()`, which will allow you to periodically update the UI.

You could use something like the following;

```
private class DoStuffTask extends AsyncTask {

@Override
   protected void doInBackground(Object... args) {
       // Do stuff
       onProgressUpdate(x);
       // Do more stuff
   }

@Override
   protected void onProgressUpdate(Object... args) {
       // Update your UI here
   }
}
```

Now if this doesn't quite do it and you want the AsyncTask to wait for input during the `doInBackground()` method it is probably worth considering using multiple `AsyncTasks` instead. You can then finish each `AsyncTask`, ask for input, and then start a new `AsyncTask` to continue working.

Given that `AlertDialog` instances are asynchronous, this is probably the preferred solution because you can start the next `AsyncTask` from the `AlertDialog` itself.

Using wait() in an AsyncTask

If you would prefer to use a single `AsyncTask` you can use wait from within your `AsyncTask` to prevent execution continuing until some condition is met. Instead of using a new `Runnable` we are just using two threads in this instance, the thread running `doInBackground()` and the main thread, and we are synchronizing on the `AsycTask` itself.

Example below;

```
public class TestTask extends AsyncTask{

private boolean notified;
    private Promptable p;
    public interface Promptable { public abstract void prompt(); }

public TestTask(Promptable p){
        this.p = p;
    }

@Override
    protected Object doInBackground(Object... arg0) {
        Log.d("First", "First");
        onProgressUpdate(null);
        synchronized(this){
            while(!notified){
                try{
                    this.wait();
                }
                catch(InterruptedException e){ }                    
            }
        }
        Log.d("Second", "Second");
        return null;
    }

@Override 
    protected void onProgressUpdate(Object... args){       
        synchronized(this){
            notified = true;
            p.prompt();               
            this.notify();
        }
    }
}
```

In the example above, assume that your `Activity` is parsed into the `AsyncTask`'s constructor, and that it implements an interface we create called `Promptable`. You'll notice that even though we're calling `wait()` we are putting it in a while loop. If we didn't do this, and somehow `notify()` got called before `wait()` then your thread would lock up indefinitely. Also, you can't depend on the fact that your thread will wait forever, so the while loop ensures that it doesn't continue until notify is called.

I hope this helps.

How to use Runnable.wait() in AsyncTask? Why does the AsyncTask NOT wait...?

Solution

Problem