How to get the result of OnPostExecute to main activity because AsyncTask is a separate class

Question

I have this two classes  My main Activity and the one that extends the AsyncTask  Now in my main Activity I need to get the result from the OnPostExecute   in the AsyncTask  How can I pass or get the result to my main Activity   Here is the sample codes   My main Activity   public class MainActivity extends Activity       AasyncTask asyncTask   new AasyncTask          Override     public void onCreate Bundle aBundle            super onCreate aBundle                          Calling the AsyncTask class to start to execute            asyncTask execute a targetServer               Creating a TextView          TextView displayUI   asyncTask dataDisplay          displayUI   new TextView this           this setContentView tTextView               This is the AsyncTask class  public class AasyncTask extends AsyncTask lt String  Void  String gt     TextView dataDisplay    store the data   String soapAction    http   sample com     SOAPAction header line   String targetServer    https   sampletargeturl com     Target Server     SOAP Request  String soapRequest     lt sample XML request gt            Override protected String doInBackground String    string     String responseStorage   null    storage of the response  try           Uses URL and HttpURLConnection for server connection       URL targetURL   new URL targetServer       HttpURLConnection httpCon    HttpURLConnection  targetURL openConnection        httpCon setDoOutput true       httpCon setDoInput true       httpCon setUseCaches false        httpCon setChunkedStreamingMode 0          properties of SOAPAction header     httpCon addRequestProperty  SOAPAction   soapAction       httpCon addRequestProperty  Content-Type    text xml  charset utf-8         httpCon addRequestProperty  Content-Length        soapRequest length         httpCon setRequestMethod HttpPost METHOD NAME           sending request to the server      OutputStream outputStream   httpCon getOutputStream         Writer writer   new OutputStreamWriter outputStream       writer write soapRequest       writer flush        writer close            getting the response from the server     InputStream inputStream   httpCon getInputStream         BufferedReader bufferedReader   new BufferedReader new InputStreamReader inputStream        ByteArrayBuffer byteArrayBuffer   new ByteArrayBuffer 50        int intResponse   httpCon getResponseCode         while   intResponse   bufferedReader read       -1            byteArrayBuffer append intResponse              responseStorage   new String byteArrayBuffer toByteArray             catch  Exception aException        responseStorage   aException getMessage               return responseStorage     protected void onPostExecute String result         aTextView setText result

User · Answer

This answer might be late but I would like to mention few things when your Activity dependent on AsyncTask. That would help you in prevent crashes and memory management. As already mentioned in above answers go with interface, we also say them callbacks. They will work as an informer, but never ever send strong reference of Activity or interface always use weak reference in those cases.

Please refer to below screenshot to findout how that can cause issues.

As you can see if we started AsyncTask with a strong reference then there is no guarantee that our Activity/Fragment will be alive till we get data, so it would be better to use WeakReference in those cases and that will also help in memory management as we will never hold the strong reference of our Activity then it will be eligible for garbage collection after its distortion.

Check below code snippet to find out how to use awesome WeakReference -

MyTaskInformer.java Interface which will work as an informer.

public interface MyTaskInformer {

    void onTaskDone(String output);

}

MySmallAsyncTask.java AsyncTask to do long running task, which will use WeakReference.

public class MySmallAsyncTask extends AsyncTask<String, Void, String> {

    // ***** Hold weak reference *****
    private WeakReference<MyTaskInformer> mCallBack;

    public MySmallAsyncTask(MyTaskInformer callback) {
        this.mCallBack = new WeakReference<>(callback);
    }

    @Override
    protected String doInBackground(String... params) {

        // Here do whatever your task is like reading/writing file
        // or read data from your server or any other heavy task

        // Let us suppose here you get response, just return it
        final String output = "Any out, mine is just demo output";

        // Return it from here to post execute
        return output;
    }

    @Override
    protected void onPostExecute(String s) {
        super.onPostExecute(s);

        // Here you can't guarantee that Activity/Fragment is alive who started this AsyncTask

        // Make sure your caller is active

        final MyTaskInformer callBack = mCallBack.get();

        if(callBack != null) {
            callBack.onTaskDone(s);
        }
    }
}

MainActivity.java This class is used to start my AsyncTask implement interface on this class and override this mandatory method.

public class MainActivity extends Activity implements MyTaskInformer {

    private TextView mMyTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mMyTextView = (TextView) findViewById(R.id.tv_text_view);

        // Start your AsyncTask and pass reference of MyTaskInformer in constructor
        new MySmallAsyncTask(this).execute();
    }

    @Override
    public void onTaskDone(String output) {

        // Here you will receive output only if your Activity is alive.
        // no need to add checks like if(!isFinishing())

        mMyTextView.setText(output);
    }
}

User · Answer

Easy    Create interface class  where String output is optional  or can be whatever variables you want to return    public interface AsyncResponse       void processFinish String output      Go to your AsyncTask class  and declare interface AsyncResponse as a field    public class MyAsyncTask extends AsyncTask lt Void  Void  String gt      public AsyncResponse delegate   null        Override     protected void onPostExecute String result          delegate processFinish result             In your main Activity you need to implements interface AsyncResponse   public class MainActivity implements AsyncResponse    MyAsyncTask asyncTask  new MyAsyncTask        Override   public void onCreate Bundle savedInstanceState            this to set delegate listener back to this class      asyncTask delegate   this          execute the async task       asyncTask execute             this override the implemented method from asyncTask    Override   void processFinish String output          Here you will receive the result fired from async class         of onPostExecute result  method               UPDATE  I didn t know this is such a favourite to many of you  So here s the simple and convenience way to use interface   still using same interface  FYI  you may combine this into AsyncTask class   in AsyncTask class    public class MyAsyncTask extends AsyncTask lt Void  Void  String gt          you may separate this or combined to caller class    public interface AsyncResponse           void processFinish String output          public AsyncResponse delegate   null       public MyAsyncTask AsyncResponse delegate           this delegate   delegate              Override     protected void onPostExecute String result          delegate processFinish result             do this in your Activity class  public class MainActivity extends Activity       MyAsyncTask asyncTask   new MyAsyncTask new AsyncResponse           Override      void processFinish String output          Here you will receive the result fired from async class         of onPostExecute result  method              execute          Or  implementing the interface on the Activity again   public class MainActivity extends Activity      implements AsyncResponse        Override     public void onCreate Bundle savedInstanceState               execute the async task          new MyAsyncTask this  execute                 this override the implemented method from AsyncResponse      Override     void processFinish String output             Here you will receive the result fired from async class            of onPostExecute result  method            As you can see 2 solutions above  the first and third one  it needs to create method processFinish  the other one  the method is inside the caller parameter  The third  is more neat because there is no nested anonymous class  Hope this helps  Tip  Change String output  String response  and String result to different matching types in order to get different objects

User · Answer

There are a few options    Nest the AsyncTask class within your Activity class  Assuming you don t use the same task in multiple activities  this is the easiest way  All your code stays the same  you just move the existing task class to be a nested class inside your activity s class   public class MyActivity extends Activity          existing Activity code              private class MyAsyncTask extends AsyncTask lt String  Void  String gt               existing AsyncTask code                      Create a custom constructor for your AsyncTask that takes a reference to your Activity  You would instantiate the task with something like new MyAsyncTask this  execute param1  param2    public class MyAsyncTask extends AsyncTask lt String  Void  String gt        private Activity activity       public MyAsyncTask Activity activity            this activity   activity                existing AsyncTask code

User · Answer

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 lt Object  Object  Object gt         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      Your request to aynchronous task class is giving here                                                  Thanks

User · Answer

You can write your own listener  It s same as HelmiB s answer but looks more natural   Create listener interface   public interface myAsyncTaskCompletedListener       void onMyAsynTaskCompleted int responseCode  String result       Then write your asynchronous task   public class myAsyncTask extends AsyncTask lt String  Void  String gt         private myAsyncTaskCompletedListener listener      private int responseCode   0       public myAsyncTask                public myAsyncTask myAsyncTaskCompletedListener listener  int responseCode            this listener   listener          this responseCode   responseCode              Override     protected void onPreExecute             super onPreExecute                 Override     protected String doInBackground String    params            String result          String param    params length    0    null   params 0           if  param    null                   Do some background jobs  like httprequest                return result                    return null              Override     protected void onPostExecute String finalResult            super onPostExecute finalResult           if   isCancelled                  if  listener    null                    listener onMyAsynTaskCompleted responseCode  finalResult                                     Finally implement listener in activity   public class MainActivity extends AppCompatActivity implements myAsyncTaskCompletedListener         Override     public void onMyAsynTaskCompleted int responseCode  String result             switch  responseCode                case TASK CODE ONE                      Do something for CODE ONE                 break              case TASK CODE TWO                     Do something for CODE TWO                 break              default                      Show some error code                           And this is how you can call asyncTask    protected void onCreate Bundle savedInstanceState            super onCreate savedInstanceState           setContentView R layout activity main              Some other codes            new myAsyncTask this TASK CODE ONE  execute  Data for background job               And some another codes

User · Answer

You can call the get   method of AsyncTask  or the overloaded get long  TimeUnit     This method will block until the AsyncTask has completed its work  at which point it will return you the Result   It would be wise to be doing other work between the creation start of your async task and calling the get method  otherwise you aren t utilizing the async task very efficiently

User · Answer

You can try this code in your Main class   That worked for me  but i have implemented  methods in other way  try       String receivedData   new AsyncTask   execute  http   yourdomain com yourscript php   get       catch  ExecutionException   InterruptedException ei        ei printStackTrace

User · Answer

I make it work by using threading and handler message  Steps as follow  Declare a progress Dialog  ProgressDialog loadingdialog    Create a function to close dialog when operation is finished      private Handler handler   new Handler          Override     public void handleMessage Message msg            loadingdialog dismiss                    Code your Execution details    public void startUpload String filepath        loadingdialog   ProgressDialog show MainActivity this   Uploading    Uploading Please Wait   true       final String  path   filepath      new Thread             public void run                 try                   UploadFile  path  getHostName    getPortNo                     handler sendEmptyMessage 0                  catch  Exception e                    Log e  threadmessage   e getMessage                                   start

User · Answer

You can do it in a few lines  just override onPostExecute when you call your AsyncTask  Here is an example for you   new AasyncTask          Override public void onPostExecute String result                  do whatever you want with result          execute a targetServer     I hope it helped you  happy codding

User · Answer

Probably going overboard a bit but i provided call backs for both the execution code and the results  obviously for thread safety you want to be careful what you access in your execution callback   The AsyncTask implementation   public class AsyncDbCall lt ExecuteType ResultType gt  extends AsyncTask lt ExecuteType  Void    ResultType gt        public interface ExecuteCallback lt E  R gt                public R execute E executeInput             public interface PostExecuteCallback lt R gt                public void finish R result              private PostExecuteCallback lt ResultType gt   resultCallback   null      private ExecuteCallback lt ExecuteType ResultType gt   executeCallback   null        AsyncDbCall ExecuteCallback lt ExecuteType ResultType gt  executeCallback  PostExecuteCallback lt ResultType gt  postExecuteCallback                 resultCallback   postExecuteCallback           executeCallback   executeCallback             AsyncDbCall ExecuteCallback lt ExecuteType ResultType gt  executeCallback                 executeCallback   executeCallback              Override     protected ResultType doInBackground final ExecuteType    params                return   executeCallback execute params 0                Override     protected void onPostExecute ResultType result                if  resultCallback    null               resultCallback finish result             A callback    AsyncDbCall ExecuteCallback lt Device  Device gt  updateDeviceCallback   new   AsyncDbCall ExecuteCallback lt Device  Device gt                   Override         public Device execute Device device                        deviceDao updateDevice device               return device                     And finally execution of the async task    new AsyncDbCall lt  gt  addDeviceCallback  resultCallback  execute device

User · Answer

in your Oncreate        myTask execute  url    String result       try         result   myTask get   toString      catch  InterruptedException e             TODO Auto-generated catch block       e printStackTrace     catch  ExecutionException e             TODO Auto-generated catch block       e printStackTrace

User · Answer

Hope you been through this   if not please read   https   developer android com reference android os AsyncTask  Depending on the nature of result data  you should choose best possible option you can think of   It is a great choice to use an Interface  some other options would be     If the AsyncTask class is defined inside the very class you want to use the result in Use a static global variable or get      use it from outer class  volatile variable if necessary   but should be aware of the AsyncTask progress or should at least make sure that it have finished the task and result is available through global variable   get   method  you may use polling  onProgressUpdate Progress      synchronization or interfaces  Which ever suits best for you  If the Result is compatible to be a sharedPreference entry or it is okay to be saved as a file in the memory you could save it even from  the background task itself and could use the onPostExecute   method to get notified when the result is available in the memory  If the string is small enough  and is to be used with start of an activity  it is possible to use intents  putExtra    within onPostExecute     but remember that static contexts aren t that safe to deal with  If possible  you can call a static method from the onPostExecute   method  with the result being your parameter

User · Answer

try this   public class SomAsyncTask extends AsyncTask lt String  Integer  JSONObject gt         private CallBack callBack       public interface CallBack           void async  JSONObject jsonResult            void sync  JSONObject jsonResult            void progress  Integer    status            void cancel               public SomAsyncTask CallBack callBack            this callBack   callBack              Override     protected JSONObject doInBackground String    strings             JSONObject dataJson   null             TODO query  get some dataJson          if this callBack    null              this callBack async  dataJson      asynchronize with MAIN LOOP THREAD          return dataJson               Override     protected void onProgressUpdate Integer    values            super onProgressUpdate values            if this callBack    null              this callBack progress values     synchronize with MAIN LOOP THREAD              Override     protected void onPostExecute JSONObject jsonObject            super onPostExecute jsonObject            if this callBack    null              this callBack sync jsonObject     synchronize with MAIN LOOP THREAD             Override     protected void onCancelled             super onCancelled             if this callBack    null              this callBack cancel               And usage example   public void onCreate  Nullable Bundle savedInstanceState             super onCreate savedInstanceState             final Context  localContext   getContext             SomeAsyncTask CallBack someCallBack   new SomeAsyncTask CallBack                       Override                 public void async JSONObject jsonResult     async thread                       some async process  e g  send data to server                                        Override                 public void sync JSONObject jsonResult     sync thread                       get result                           get some resource of Activity variable                        Resources resources    localContext getResources                                        Override                 public void progress Integer    status     sync thread                       e g  change status progress bar                                        Override                 public void cancel                                                     new SomeAsyncTask  someCallBack                                    execute  someParams0    someParams1    someParams2

User · Answer

You need to use  protocols  to delegate or provide data to the AsynTask   Delegates and Data Sources   A delegate is an object that acts on behalf of  or in coordination with  another object when that object encounters an event in a program   Apple definition   protocols are interfaces that define some methods to delegate some behaviors   Here is a complete example

User · Answer

Create a static member in your Activity class  Then assign the value during the onPostExecute  For example  if the result of your AsyncTask is a String  create a public static string in your Activity  public static String dataFromAsyncTask   Then  in the onPostExecute of the AsyncTask  simply make a static call to your main class and set the value   MainActivity dataFromAsyncTask    result blah

User · Answer

Hi you can make something like this    Create class which implements AsyncTask      TASK  public class SomeClass extends AsyncTask lt Void  Void  String gt  gt         private OnTaskExecutionFinished  task finished event       public interface OnTaskExecutionFinished               public void OnTaskFihishedEvent String Reslut              public void setOnTaskFinishedEvent OnTaskExecutionFinished  event                if  event    null                        this  task finished event    event                        Override     protected void onPreExecute                 super onPreExecute                 Override     protected String doInBackground Void    params                   do your background task here              return  Done                Override     protected void onPostExecute String result                super onPostExecute result           if this  task finished event    null                        this  task finished event OnTaskFihishedEvent result                     else                       Log d  SomeClass    task finished even is null                       Add in Main Activity     MAIN ACTIVITY public class MyActivity extends ListActivity              SomeClass  some class   new SomeClass         someclass setOnTaskFinishedEvent new  some class OnTaskExecutionFinished              Override     public void OnTaskFihishedEvent String result                Toast makeText getApplicationContext                     Phony thread finished      result                  Toast LENGTH SHORT  show                      some class execute

User · Answer

Why do people make it so hard    This should be sufficient   Do not implement the onPostExecute on the async task  rather implement it on the Activity   public class MainActivity extends Activity      Override public void onCreate Bundle savedInstanceState           execute the async task      MyAsyncTask task   new MyAsyncTask                protected void onPostExecute String result                      Do your thing                                  task execute  Param

[android] How to get the result of OnPostExecute() to main activity because AsyncTask is a separate class?

Examples related to android

Examples related to android-asynctask