Comment renvoyer la valeur d'une tâche asynchrone dans android

Question

J'ai créé une tâche asynchrone pour appeler mon serveur afin d'obtenir des données de la base de données.
Je dois traiter le résultat renvoyé par l'appel du serveur http. De mon activité j'appelle la tâche asynchrone dans beaucoup d'endroits. donc je ne peux pas utiliser la variable membre pour accéder au résultat. y a-t-il un moyen 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? 
     } 

Answer 1

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

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

AsyncTask est une tâche asynchrone de sorte qu'il n'a pas de sens pour retourner le résultat à l'appelant. Plutôt gérer le résultat dans onPostExecute() comme définir la valeur à TextView etc. Ou envoyer une diffusion afin que d'autres écouteurs puissent gérer le résultat.

Answer 2

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

1. OnPreExecute(), invoqué sur le thread d'interface utilisateur avant que la tâche est exécutée. Cette étape est normalement utilisée pour configurer la tâche, par exemple en affichant une barre de progression dans l'interface utilisateur. DoInBackground (Params ...), invoqué sur le thread d'arrière-plan immédiatement après la fin de l'exécution de onPreExecuteQ. Cette étape est utilisée pour effectuer un calcul en arrière-plan qui peut prendre beaucoup de temps. Les paramètres de la tâche asynchrone sont transmis à 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 (Progress ...) pour publier une ou plusieurs unités de progression. Ces valeurs sont publiées sur le thread de l'interface utilisateur dans l'étape onProgressUpdate (Progress ...).

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

3. onPostExecute (résultat), invoqué sur le thread d'interface utilisateur après la fin du calcul de l'arrière-plan. Le résultat du calcul de l'arrière-plan est passé à cette étape en tant que paramètre.

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

Answer 3

Voilà comment je suis arrivé dans ce:

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

public interface AsyncIfc { 
    public void onComplete(); 
} 

2) Définir une propriété sur votre classe AsyncTask pour maintenir la méthode déléguée:

public AsyncIfc completionCode; 

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

completionCode.onComplete(); 

4) A partir de votre appel logique, définissez la propriété de délégué à une méthode anonyme: méthode de AsyncTask après avoir appelé la méthode d'exécution()

task.completionCode = new AsyncIfc() { 

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

Answer 4

Essayez d'appeler le get(). 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 

} 
... 
...