android asynctask sending callbacks to ui [duplicate]

You can create an interface, pass it to AsyncTask (in constructor), and then call method in onPostExecute()

For example:

Your interface:

public interface OnTaskCompleted{    void onTaskCompleted();}

Your Activity:

public class YourActivity implements OnTaskCompleted{    // your Activity}

And your AsyncTask:

public class YourTask extends AsyncTask<Object,Object,Object>{ //change Object to required type    private OnTaskCompleted listener;    public YourTask(OnTaskCompleted listener){        this.listener=listener;    }    // required methods    protected void onPostExecute(Object o){        // your stuff        listener.onTaskCompleted();    }}

EDIT

Since this answer got quite popular, I want to add some things.

If you're a new to Android development, AsyncTask is a fast way to make things work without blocking UI thread. It does solves some problems indeed, there is nothing wrong with how the class works itself. However, it brings some implications, such as:

• Possibility of memory leaks. If you keep reference to your Activity, it will stay in memory even after user left the screen (or rotated the device).
• AsyncTask is not delivering result to Activity if Activity was already destroyed. You have to add extra code to manage all this stuff or do you operations twice.
• Convoluted code which does everything in Activity

When you feel that you matured enough to move on with Android, take a look at this article which, I think, is a better way to go for developing your Android apps with asynchronous operations.

I felt the below approach is very easy.

I have declared an interface for callback

public interface AsyncResponse {    void processFinish(Object output);}

Then created asynchronous Task for responding all type of parallel requests

 public class MyAsyncTask extends AsyncTask<Object, Object, Object> {    public AsyncResponse delegate = null;//Call back interface    public MyAsyncTask(AsyncResponse asyncResponse) {        delegate = asyncResponse;//Assigning call back interfacethrough constructor    }    @Override    protected Object doInBackground(Object... params) {    //My Background tasks are written here      return {resutl Object}    }    @Override    protected void onPostExecute(Object result) {        delegate.processFinish(result);    }}

Then Called the asynchronous task when clicking a button in activity Class.

public class MainActivity extends Activity {    @Override    public void onCreate(Bundle savedInstanceState) {        Button mbtnPress = (Button) findViewById(R.id.btnPress);        mbtnPress.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v) {                MyAsyncTask asyncTask =new MyAsyncTask(new AsyncResponse() {                    @Override                    public void processFinish(Object output) {                        Log.d("Response From Asynchronous task:", (String) output);                                  mbtnPress.setText((String) output);                    }                });                asyncTask.execute(new Object[] { "Youe request to aynchronous task class is giving here.." });            }        });    }}

Thanks

IN completion to above answers, you can also customize your fallbacks for each async call you do, so that each call to the generic ASYNC method will populate different data, depending on the onTaskDone stuff you put there.

  Main.FragmentCallback FC= new  Main.FragmentCallback(){            @Override            public void onTaskDone(String results) {                localText.setText(results); //example TextView            }        };new API_CALL(this.getApplicationContext(), "GET",FC).execute("&Books=" + Main.Books + "&args=" + profile_id);

Remind: I used interface on the main activity thats where "Main" comes, like this:

public interface FragmentCallback {    public void onTaskDone(String results);}

My API post execute looks like this:

  @Override    protected void onPostExecute(String results) {        Log.i("TASK Result", results);        mFragmentCallback.onTaskDone(results);    }

The API constructor looks like this:

 class  API_CALL extends AsyncTask<String,Void,String>  {    private Main.FragmentCallback mFragmentCallback;    private Context act;    private String method;    public API_CALL(Context ctx, String api_method,Main.FragmentCallback fragmentCallback) {        act=ctx;        method=api_method;        mFragmentCallback = fragmentCallback;    }