Return a value from AsyncTask in Android

Question

One simple question: is it possible to return a value in AsyncTask?

//AsyncTask is a member class
private class MyTask extends AsyncTask<Void, Void, Void>{

    protected Void doInBackground(Void... params) {
         //do stuff
         return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        //do stuff
        //how to return a value to the calling method?
    }
}

And then within my Activity/Fragment:

// The task is started from activity
myTask.execute()
// something like this?
myvalue = myTask.getvalue() 

EDIT: This was asked a long time ago where I wasn't familiar with Java, now that I'm better with it, I 'll do a quick summary:

The point of async task is that the task is asynchronous, meaning that after you call execute() on the task, the task starts running on a thread of its own. returning a value from asynctask would be pointless because the original calling thread has already carried on doing other stuff (thus the task is asynchronous).

Think of time: At one point of time, you started a task that will run in parallel with the main thread. When the parallel-running task completed, time has also elapsed on the main thread. The parallel task cannot go back in time to return a value to the main thread.

I was coming from C so I didn't know much about this. But it seems that lots of people are having the same question so I thought I would clear it up a bit.

Solution 1

Why not call a method that handles the value?

public class MyClass extends Activity {

    private class myTask extends AsyncTask<Void, Void, Void> {

        //initiate vars
        public myTask() {
            super();
            //my params here
        }

        protected Void doInBackground(Void... params) {
            //do stuff
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            //do stuff
            myMethod(myValue);
        }
    }

    private myHandledValueType myMethod(Value myValue) {
        //handle value 
        return myHandledValueType;
    }
}

Solution 2

That's what onPostExecute() is for. It runs on the UI thread and you can deliver your result from there to the screen (or anywhere else you need). It won't be called until the final result is available. If you want to deliver intermediate results, take a look at onProgressUpdate()

Solution 3

Easiest way is to pass the calling object into the async task (upon constructing it if you like):

public class AsyncGetUserImagesTask extends AsyncTask<Void, Void, Void> {

    private MyImagesPagerFragment mimagesPagerFragment;
    private ArrayList<ImageData> mImages = new ArrayList<ImageData>();

    public AsyncGetUserImagesTask(MyImagesPagerFragment imagesPagerFragment) {
        this.mimagesPagerFragment = imagesPagerFragment;
    }

    @Override
    public Void doInBackground(Void... records) {
        // do work here
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        mimagesPagerFragment.updateAdapter(mImages);
    }
}

And the in the calling class (your activity or fragment) execute the task:

public class MyImagesPagerFragment extends Fragment {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        AsyncGetUserImagesTask mGetImagesTask = new AsyncGetUserImagesTask(this);
        mGetImagesTask.execute();
    }

And then the onPostExecuteMethod will call any method on your originating class you like, eg:

    public void updateAdapter(List<ImageData> images) {
        mImageAdapter.setImages(images);
        mImageAdapter.notifyDataSetChanged();
    }
}

Solution 4

Code Example: Activity uses AsyncTask to get a value in a background thread, then AsyncTask returns the result back to the Activity by calling processValue:

public class MyClass extends Activity {
  private void getValue() {
      new MyTask().execute();
  }

  void processValue(Value myValue) {
     //handle value 
     //Update GUI, show toast, etc..
  }

  private class MyTask extends AsyncTask<Void, Void, Value> {
    @Override
    protected Value doInBackground(Void... params) {
      //do stuff and return the value you want 
      return Value;
    }

    @Override
    protected void onPostExecute(Value result) {
      // Call activity method with results
      processValue(result);
    }
  }
}

Solution 5

you can try this one: myvalue = new myTask().execute().get(); minus is it will freeze process until asyncron will not be finished ;

View more solutions

Comments

[tom91136]

and how do i access myMethod?

[tom91136]

yes i know doInBackground() returns data and puts it there, but how do i transfer the data to my main activity in a variable form?

[Ted Hopp]

@Tom91136 - Just override onPostExecute() to store the result in a variable of your choice. Note that your original code doesn't make sense because the (hypothetical) method myTask.getValue() would be called before a result was available. You can also call AsyncTask's get() method to obtain the result, but you shouldn't do this from the UI thread until you know for sure that the result is available. Otherwise, it will block the UI thread, defeating the purpose of using AsyncTask in the first place.

[Jake Wilson]

@TedHopp you say to store the result in a variable of your choice in onPostExecute() but how do you get that variable BACK to your activity? For example, if you want your task to connect to the internet and download some information and then you want to do something with that information... How do you .execute() the AsyncTask and then do something with that information if the next line of code runs before the AsyncTask is done?

[Ted Hopp]

@Jakobud - You can't do that. You need to move that "next line of code" somewhere else (e.g., onPostExecute()). I use this analogy: you don't write code that waits for user input (e.g., a button press); instead, you write event handlers that react when the user provides some input. Think of onPostExecute() as an event handler for when the results of the AsyncTask are available. That's where you put the code (or call the methods) that won't work unless the results are, indeed, available.

[Jake Wilson]

So the AsyncTask shouldn't really be thought of as a utility function that simply fetches and returns some information but rather something much larger that fetches info and also manipulates the UI (or whatever) after fetching that info?

[Ted Hopp]

@Jakobud - Indeed. An AsyncTask can manipulate the UI both before starting the time-consuming work (like fetching info) and after the work is done. (If you don't need to manipulate the UI either before or after, then it probably makes sense to use something other than AsyncTask for the worker thread.)

[tayler]

@Jakobud you can return something produced using an AsyncTask to your main activity using a listener.

[Ted Hopp]

@tayler - But if you do that, the listener will be called from the worker thread, not the UI thread.

[CoronaPintu]

any other way to avoide this freezing UI

[Cheung]

It not work, e.g. myTask mTask = new myTask(); mTask.execute(); will not return the myHandledValueType.

[KG -]

this is essentially dependency injection

[jt-gilkeson]

The formatting is poor, but basically the AsyncTask calls the activity method: myMethod with myValue (which supposedly is a class variable that gets set in doInBackground). In myMethod you process the result of the AsyncTask (there is No reason for a return value here, just do the work in this method for the result). A better implementation would be to extend AsyncTask<Void, Void, Value> and have doInBackground return Value and have OnPostExecute take in the Value and pass it to myMethod - this would avoid any messy class variables and is how AsyncTask is designed to work.

[jt-gilkeson]

@TedHopp It depends where you call the listener. If you call the listener in onPostExecute() the listener will execute on the UI thread. If you call the listener in doInBackground (not really the normal way to use AsyncTask) - it will be executed on the AsyncTask background thread (and that listener method could use Activity's runOnUiThread method to do something on the UI thead).

[Ted Hopp]

@RedLenses - Good point. I was assuming that tayler's comment was in the context of the ongoing discussion about sending results back from within onPostExecute. But certainly a listener could be used from onPostExecute (or onProgressUpdate) to send results back on the UI thread.

[jt-gilkeson]

This solution works. Unless this is going to be reusable by other fragments, it would be simpler to just make the async task a private inner class (or anonymous) and not pass around the fragment. Also instead of using Void for results your could specify the image array. doInBackground would return the image array, and on post execute would take it in as a parameter, this would eliminate the need for a class variable to pass data around.

[SKT]

I used asynctask with an interface. The interface gets triggered when asynctask is completed (and is successful in my case, successful in the sense upload success). In the success function of interface I called the method from asynctask and I got the value

[Diego]

@jt-gilkeson that's correct but that wouldn´t be reusable either as you would have to include that inner class in every Activity class you have. How can that be achieved? to make a reusable AsyncTask class?

[IgniteCoders]

Good approach, but this only work if you use the AsyncTask as inner class, but in most cases you need to modulate the code and use that AsyncTask in many Activities, Services, BroadcastReceivers... For better modularization, use Delegates & Datasources like apple & android do in their libraries. That will make code reutilization easier.

[jt-gilkeson]

@DIEGOF.G. Correct - hence the "Unless this is going to be reusable" qualification. If you wanted a reusable solution - you could create an custom fragment class with the inner asynctask class embedded - then extend fragments that need this functionality from that class.

[Clocker]

An issue with this approach is that the AsyncTask will be triggered (repeatedly) if there is a configuration change in the activity and the task is started from one of the lifecycle methods... learned this the hard way had multiple tasks doing the same thing upon changing the screen orientation

[Utopia]

To access myMethod : myTask task = new myTask(); myTask.execute(); myTask.myMethod();

[Antroid]

thats true , the progress dialogue just wont work with get() method

[Nikita Bosik]

Performing heavy tasks in the UI thread is discouraged and may lead to ANR. Moreover, performing a networking operation on main thread causes NetworkOnMainThreadException and immediate crash by design. Check that nice article: developer.android.com/training/articles/perf-anr#java

[Jeffrey]

So in other words, just use an interface and who ever needs to be informed would just register as a listener.

[IgniteCoders]

Yes, in few words that’s the idea.

[jt-gilkeson]

Or you could make the AsyncGetUserImagesTask constructor take in an interface instead of a concrete fragment - then anything that implements the interface could use the class (i.e. dependency injection).

[Gabrielkdc]

I find this the cleanest answer. Task Class shouldn't know the implementation details of the Activity. Another important benefit is the Code Reuse, you can call this class for any other Activity/Fragments