Comment faire pour retourner la valeur de async task android

J'ai créé une tâche asynchrone à appeler mon serveur pour obtenir des données de la base de données.
J'ai besoin de traiter le résultat retourné depuis le serveur http appel.
À partir de mon activité que j'appelle la async tâche dans de nombreux endroits. donc je ne peux pas utiliser la variable de membre pour accéder au résultat. est-il possible de faire?

public Result CallServer(String params)
{

    try
    {
    new MainAynscTask().execute(params);
    }
    catch(Exception ex)
    {
        ex.printStackTrace();
    }
    return aResultM;//Need to get back the result

}  

    private class MainAynscTask extends AsyncTask<String, Void, Result> {


    @Override
    protected Result doInBackground(String... ParamsP) {    
        //calling server codes
        return aResultL;
    }       
    @Override
       protected void onPostExecute(Result result) {
          super.onPostExecute(result);
          //how i will pass this result where i called this task?
       }
Pourquoi ne pas appeler une méthode qui traite de la valeur, comme indiqué dans le stackoverflow.com/a/9458274/1021640?
éventuellement en double Async et Async
La bonne façon est d'utiliser les protocoles

OriginalL'auteur Vignesh | 2013-04-01

  1. 14

    Essayer d'appeler la méthode get() de AsyncTask après l'appel de la méthode execute (). Cela fonctionne pour moi

    http://developer.android.com/reference/android/os/AsyncTask.html#get()

    public Result CallServer(String params)
{
   try
   {
       MainAynscTask task = new MainAynscTask();
       task.execute(params);
       Result aResultM = task.get();  //Add this
   }
   catch(Exception ex)
   {
       ex.printStackTrace();
   }
   return aResultM;//Need to get back the result

} 
...
...
    AsyncTask il est exécuté dans l'autre thread, si vous essayez de le faire, votre thread principal sera d'aller frisés alors que la tâche ne s'arrêtent pas obtenir les données à partir du serveur, et l'activité ne peut pas gérer les événements de l'utilisateur lorsque l'écran tactile.
    Je ne recommande pas l'utilisation de get comme ci-dessus, parce que la cession est synchrone.
    cela fonctionne, mais sûrement pas un moyen de les adopter. tis est bon pour des projets éducatifs, mais pas en temps réel des applications de la Raison : il fait de l'application de lag mais la tenue sur le thread principal qui défie tout le but de l'utilisation de la tâche Asynchrone

    OriginalL'auteur klanm

  2. 3

    Il y a deux façons que je peux suggérer -

    1. onPostExecute(Result) dans AsyncTask. Voir http://developer.android.com/reference/android/os/AsyncTask.html#onPostExecute(Suite)

    2. Envoyer une diffusion avec le résultat comme un supplément.

    AsyncTask est une tâche asynchrone, donc il ne fait PAS de sens pour retourner le résultat de l'appelant. Plutôt gérer le résultat dans onPostExecute() comme le réglage de la valeur de TextView etc. Ou envoyer une diffusion alors que certains autres auditeur peut gérer le résultat.

    Un petit point: Si vous accédez à V̶i̶e̶w̶s de o̶n̶P̶o̶s̶t̶E̶x̶e̶c̶u̶t̶e̶(̶)̶ (par exemple à partir d'un autre thread), le faire à l'intérieur de A̶c̶t̶i̶v̶i̶t̶y̶.̶r̶u̶n̶O̶n̶U̶i̶T̶h̶r̶e̶a̶d̶(̶.̶.̶.̶)̶; - oubliez ça, onPostExecute() est appelée sur le thread de l'INTERFACE utilisateur.

    OriginalL'auteur user2230793

  3. 1

    Voici comment je suis arrivé à ceci:

    1) Créer une classe d'interface qui définit une signature pour un méthode à exécuter à la fin:

    public interface AsyncIfc {
    public void onComplete();
}

    2) Définir une propriété sur votre AsyncTask classe afin de conserver la méthode du délégué:

        public AsyncIfc completionCode;

    3) Déclencher le délégué de onPostExecute() dans l'AsyncTask:

    completionCode.onComplete();

    4) à Partir de votre appel la logique, définissez le délégué de la propriété à une méthode anonyme:

    task.completionCode = new AsyncIfc() {

    @Override
    public void onComplete() {
    //Any logic you want to happen after execution
    }
};

    OriginalL'auteur iDurocher

  4. 0

    Lors d'une tâche asynchrone est exécutée, la tâche passe par 4 étapes:

    1. onPreExecute(), appelée par le thread de l'INTERFACE utilisateur avant l'exécution de la tâche. Cette étape est normalement utilisé pour la configuration de la tâche, par exemple en affichant une barre de progression dans l'interface utilisateur.

    2. doInBackground(Params...), invoquée sur le thread d'arrière-plan immédiatement après onPreExecute() termine son exécution. Cette étape est utilisée pour effectuer le calcul de fond, qui peut prendre beaucoup de temps. Les paramètres de la tâche asynchrone sont passés à cette étape. Le résultat du calcul doit être retourné par cette étape et sera renvoyé à la dernière étape. Cette étape peut également utiliser publishProgress(le Progrès...) de publier une ou plusieurs unités de progrès. Ces valeurs sont publiées sur le thread de l'INTERFACE utilisateur, le onProgressUpdate(le Progrès...).

    3. onProgressUpdate(le Progrès...), invoquée sur le thread de l'INTERFACE utilisateur après un appel à publishProgress(le Progrès...). Le moment de l'exécution n'est pas défini. Cette méthode est utilisée pour afficher toute forme de progrès dans l'interface utilisateur, tandis que le calcul d'arrière-plan est toujours en cours d'exécution. Par exemple, il peut être utilisé pour animer une barre de progression ou afficher les journaux dans un champ de texte.

    4. onPostExecute(Suite), invoquée sur le thread de l'INTERFACE utilisateur après le calcul de fond de finitions. Le résultat du calcul d'arrière-plan est transmis à cette étape en tant que paramètre.

    Utiliser un gestionnaire

    Dans votre activité

        Handler mHandler = new Handler() { 
    @Override public void handleMessage(Message msg) { 
        String s=(String)msg.obj;
        tv.setText(s);
    }
};

//result is soap object in this case.
protected void onPostExecute(SoapObject result) {
    pd.dismiss();
    if(result != null) {
        Message msg=new Message();
        msg.obj=result.getProperty(0).toString();
        mHandler.sendMessage(msg);
    }

    OriginalL'auteur Raghunandan