Comment obtenir le résultat de OnPostExecute () sur l'activité principale car AsyncTask est une classe distincte?

J'ai ces deux cours. Ma principale activité et celui qui prolonge la AsyncTask, maintenant dans mon activité principale je dois obtenir le résultat de l' OnPostExecute()en AsyncTask. Comment passer ou obtenir le résultat de mon activité principale?

Voici les exemples de codes.

Mon activité principale.

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); 
    }

}

Ceci est la classe AsyncTask

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

TextView dataDisplay; //store the data  
String soapAction = "http://sample.com"; //SOAPAction header line. 
String targetServer = "https://sampletargeturl.com"; //Target Server.

//SOAP Request.
String soapRequest = "<sample XML request>";    



@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);

}       

}   

Facile:

1. Créez une interfaceclasse, où String outputest facultative, ou peut être n'importe quelle variable que vous souhaitez renvoyer.

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

2. Accédez à votre AsyncTaskclasse et déclarez l'interface en AsyncResponsetant que champ:

   public class MyAsyncTask extends AsyncTask<Void, Void, String> {
     public AsyncResponse delegate = null;
   
       @Override
       protected void onPostExecute(String result) {
         delegate.processFinish(result);
       }
    }

3. Dans votre activité principale, vous devez vous implementsconnecter 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.
      }
    }

MISE À JOUR

Je ne savais pas que c'était un favori pour beaucoup d'entre vous. Voici donc la manière simple et pratique d'utiliser interface.

toujours en utilisant même interface. Pour info, vous pouvez combiner cela en AsyncTaskclasse.

en AsyncTaskclasse:

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

  // 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);
    }
}

faites cela dans votre Activityclasse

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();

 }

Ou, implémentant à nouveau l'interface sur l'activité

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.
    }
}

Comme vous pouvez voir 2 solutions ci-dessus, la première et la troisième, il faut créer une méthode processFinish, l'autre, la méthode est à l'intérieur du paramètre de l'appelant. Le troisième est plus soigné car il n'y a pas de classe anonyme imbriquée. J'espère que cela t'aides

Astuce : le changement String output, String responseet String resultà différents types de correspondance afin d'obtenir différents objets.

Il y a quelques options:

• Incorporez la AsyncTaskclasse dans votre Activityclasse. En supposant que vous n'utilisez pas la même tâche dans plusieurs activités, c'est le moyen le plus simple. Tout votre code reste le même, vous déplacez simplement la classe de tâches existante pour qu'elle soit imbriquée dans la classe de votre activité.

  public class MyActivity extends Activity {
      // existing Activity code
      ...
  
      private class MyAsyncTask extends AsyncTask<String, Void, String> {
          // existing AsyncTask code
          ...
      }
  }

• Créez un constructeur personnalisé pour votre AsyncTaskqui prend une référence à votre Activity. Vous instancieriez la tâche avec quelque chose comme new MyAsyncTask(this).execute(param1, param2).

  public class MyAsyncTask extends AsyncTask<String, Void, String> {
      private Activity activity;
  
      public MyAsyncTask(Activity activity) {
          this.activity = activity;
      }
  
      // existing AsyncTask code
      ...
  }

J'ai senti que l'approche ci-dessous est très facile.

J'ai déclaré une interface pour le rappel

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

Puis créé une tâche asynchrone pour répondre à tout type de requêtes parallèles

 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);
    }

}

Appelé ensuite la tâche asynchrone en cliquant sur un bouton dans la classe d'activité.

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.." });


            }
        });

    }



}

Merci

Vous pouvez essayer ce code dans votre classe principale. Cela a fonctionné pour moi, mais j'ai mis en œuvre des méthodes d'une autre manière

try {
    String receivedData = new AsyncTask().execute("http://yourdomain.com/yourscript.php").get();
} 
catch (ExecutionException | InterruptedException ei) {
    ei.printStackTrace();
}

Cette réponse est peut-être en retard, mais je voudrais mentionner peu de choses lorsque vous Activitydépendez AsyncTask. Cela vous aiderait à éviter les plantages et la gestion de la mémoire. Comme déjà mentionné dans les réponses ci-dessus interface, nous les appelons également des rappels. Ils travailleront en tant qu'informateur, mais n'enverront jamais de référence forteActivity ou interfaceutiliseront toujours une référence faible dans ces cas.

Veuillez vous référer à la capture d'écran ci-dessous pour savoir comment cela peut causer des problèmes.

Comme vous pouvez le voir si nous avons commencé AsyncTaskavec une référence forte, il n'y a aucune garantie que notre Activity/ Fragmentsera vivant jusqu'à ce que nous obtenions des données, il serait donc préférable d'utiliser WeakReferencedans ces cas et cela aidera également à la gestion de la mémoire car nous ne tiendrons jamais la référence forte de notre Activityalors il sera éligible au ramassage des ordures après sa déformation.

Consultez l'extrait de code ci-dessous pour savoir comment utiliser WeakReference génial -

MyTaskInformer.java Interface qui fonctionnera comme un informateur.

public interface MyTaskInformer {

    void onTaskDone(String output);

}

MySmallAsyncTask.javaAsyncTask pour effectuer une tâche de longue durée, qui utilisera 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.javaCette classe est utilisée pour démarrer mon AsyncTaskimplémentation interfacesur cette classe et overridecette méthode obligatoire.

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);
    }
}

dans votre 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();

} `

Vous pouvez le faire en quelques lignes, remplacez simplement onPostExecute lorsque vous appelez votre AsyncTask. Voici un exemple pour vous:

new AasyncTask()
{
    @Override public void onPostExecute(String result)
    {
       // do whatever you want with result 
    }
}.execute(a.targetServer);

J'espère que cela vous a aidé, codage heureux :)

Pourquoi les gens compliquent-ils la tâche?

Cela devrait être suffisant.

N'implémentez pas onPostExecute sur la tâche asynchrone, implémentez-le plutôt sur l'activité:

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");

}


}

Vous pouvez appeler la get()méthode de AsyncTask(ou la surcharge get(long, TimeUnit)). Cette méthode se bloquera jusqu'à ce que le AsyncTaskait terminé son travail, auquel cas il vous renverra le Result.

Il serait sage de faire un autre travail entre la création / démarrage de votre tâche asynchrone et l'appel de la getméthode, sinon vous n'utilisez pas la tâche asynchrone très efficacement.

Vous pouvez écrire votre propre auditeur. C'est la même réponse que HelmiB mais semble plus naturel:

Créer une interface d'écoute:

public interface myAsyncTaskCompletedListener {
    void onMyAsynTaskCompleted(int responseCode, String result);
}

Écrivez ensuite votre tâche asynchrone:

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

    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);
            }
        }
    }
}

Enfin implémentez l'écouteur en activité:

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
        }        
    }

Et voici comment vous pouvez appeler 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...
}

Salut, vous pouvez faire quelque chose comme ça:

1. Créer une classe qui implémente AsyncTask

   // TASK 
   public class SomeClass extends AsyncTask<Void, Void, String>>
   {
   
       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");
           }
       }
   }

2. Ajouter dans l'activité principale

   // 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();
      ...
    }

Créez un membre statique dans votre classe d'activité. Attribuez ensuite la valeur pendant laonPostExecute

Par exemple, si le résultat de votre AsyncTask est une chaîne, créez une chaîne statique publique dans votre activité

public static String dataFromAsyncTask;

Ensuite, dans le onPostExecuteAsyncTask, faites simplement un appel statique à votre classe principale et définissez la valeur.

MainActivity.dataFromAsyncTask = "result blah";

Je le fais fonctionner en utilisant le filetage et le gestionnaire / message. Étapes comme suit: Déclarez une boîte de dialogue de progression

ProgressDialog loadingdialog;

Créez une fonction pour fermer la boîte de dialogue lorsque l'opération est terminée.

   private Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        loadingdialog.dismiss();

    }
    };

Codez vos détails d'exécution:

 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();
}

Vous devez utiliser des «protocoles» pour déléguer ou fournir des données au AsynTask.

Délégués et sources de données

Un délégué est un objet qui agit au nom ou en coordination avec un autre objet lorsque cet objet rencontre un événement dans un programme. ( Définition Apple )

les protocoles sont des interfaces qui définissent certaines méthodes pour déléguer certains comportements.

Voici un exemple complet !!!

essaye ça:

public class SomAsyncTask extends AsyncTask<String, Integer, JSONObject> {

    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();

    }
}

Et exemple d'utilisation:

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");

    }

Je vais probablement un peu trop loin mais j'ai fourni des rappels pour le code d'exécution et les résultats. évidemment, pour la sécurité des threads, vous voulez faire attention à ce à quoi vous accédez dans votre rappel d'exécution.

L'implémentation AsyncTask:

public class AsyncDbCall<ExecuteType,ResultType> extends AsyncTask<ExecuteType, Void,  
ResultType>
{
    public interface ExecuteCallback<E, R>
    {
        public R execute(E executeInput);
    }
    public interface PostExecuteCallback<R>
    {
        public void finish(R result);
    }

    private PostExecuteCallback<ResultType> _resultCallback = null;
    private ExecuteCallback<ExecuteType,ResultType> _executeCallback = null;


    AsyncDbCall(ExecuteCallback<ExecuteType,ResultType> executeCallback, PostExecuteCallback<ResultType> postExecuteCallback)
    {
        _resultCallback = postExecuteCallback;
        _executeCallback = executeCallback;
    }

    AsyncDbCall(ExecuteCallback<ExecuteType,ResultType> 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);
    }
}

Un rappel:

 AsyncDbCall.ExecuteCallback<Device, Device> updateDeviceCallback = new 
 AsyncDbCall.ExecuteCallback<Device, Device>()
    {
        @Override
        public Device execute(Device device)
        {
            deviceDao.updateDevice(device);
            return device;
        }
    };

Et enfin exécution de la tâche asynchrone:

 new AsyncDbCall<>(addDeviceCallback, resultCallback).execute(device);

J'espère que vous avez vécu cela , sinon veuillez lire.

https://developer.android.com/reference/android/os/AsyncTask

Selon la nature des données de résultat, vous devez choisir la meilleure option possible à laquelle vous pouvez penser.

C'est un excellent choix pour utiliser une interface

d'autres options seraient ..

• Si la classe AsyncTask est définie dans la classe même dans laquelle vous souhaitez utiliser le résultat. Utilisez une variable globale statique ou get () , utilisez-la à partir de la classe externe ( variable volatile si nécessaire). mais doit être conscient de la progression de AsyncTask ou doit au moins s'assurer qu'il a terminé la tâche et que le résultat est disponible via la méthode variable / get () globale. vous pouvez utiliser l' interrogation, onProgressUpdate (Progress ...) , la synchronisation ou les interfaces (qui vous conviennent le mieux)

• Si le résultat est compatible pour être une entrée sharedPreference ou s'il est correct d'être enregistré en tant que fichier dans la mémoire, vous pouvez l' enregistrer même à partir de la tâche d'arrière-plan elle-même et utiliser la méthode onPostExecute ()
  pour être averti lorsque le résultat est disponible dans la mémoire.

• Si la chaîne est suffisamment petite et doit être utilisée au début d'une activité. il est possible d'utiliser des intentions ( putExtra () ) dans onPostExecute () , mais n'oubliez pas que les contextes statiques ne sont pas aussi sûrs à gérer.

• Si possible, vous pouvez appeler une méthode statique à partir de la méthode onPostExecute (), le résultat étant votre paramètre