Passage d'arguments à AsyncTask, et le retour des résultats

J'ai une application qui fait de longs calculs, et je voudrais afficher une boîte de dialogue de progression alors que cela est fait. Pour l'instant j'ai trouvé que je pouvais le faire avec threads/gestionnaires, mais n'a pas fonctionné, puis j'ai découvert le AsyncTask.

Dans mon application j'utilise des cartes avec des marqueurs sur elle, et j'ai mis en œuvre la onTap la fonction à appeler une méthode que j'ai défini. La méthode crée une boîte de dialogue Oui/Non les boutons, et je voudrais appeler un AsyncTask si Oui est cliqué. Ma question est de savoir comment passer un ArrayList<String> à la AsyncTask (et de travailler avec elle là-bas), et comment l'obtenir en retour une nouvelle ArrayList<String> comme un résultat de la AsyncTask?

Le code de la méthode ressemble à ceci:

String curloc = current.toString();
String itemdesc = item.mDescription;

ArrayList<String> passing = new ArrayList<String>();
passing.add(itemdesc);
passing.add(curloc);

ArrayList<String> result = new ArrayList<String>();

new calc_stanica().execute(passing,result);

String minim = result.get(0);
int min = Integer.parseInt(minim);

String glons = result.get(1);
String glats = result.get(2);

double glon = Double.parseDouble(glons);
double glat = Double.parseDouble(glats);

GeoPoint g = new GeoPoint(glon, glat);
String korisni_linii = result.get(3);

Donc, comme vous le voyez, je voudrais vous envoyer le tableau de chaîne de la liste de "passer" à la AsyncTask, et pour obtenir le "résultat" de la chaîne de la liste des ensembles de recul. Et le calc_stanica AssycTask classe ressemble à ceci:

public class calc_stanica extends AsyncTask<ArrayList<String>, Void, ArrayList<String>> {
    ProgressDialog dialog;

    @Override
    protected void onPreExecute() {
        dialog = new ProgressDialog(baraj_mapa.this);
        dialog.setTitle("Calculating...");
        dialog.setMessage("Please wait...");
        dialog.setIndeterminate(true);
        dialog.show();
    }

    protected ArrayList<String> doInBackground(ArrayList<String>... passing) {

        //Some calculations...

        return something; //???
    }

    protected void onPostExecute(Void unused) {
        dialog.dismiss();
    }

Donc ma question est de savoir comment obtenir les éléments de la "passant" liste de tableau dans la AsyncTask doInBackground méthode (et de les utiliser là-bas), et comment retourner une liste de tableau à utiliser dans la méthode main (le "résultat" tableau liste)?

InformationsquelleAutor Bojan Ilievski | 2010-11-16

64

Changer votre méthode pour ressembler à ceci:
```
String curloc = current.toString();
String itemdesc = item.mDescription;
ArrayList<String> passing = new ArrayList<String>();
passing.add(itemdesc);
passing.add(curloc);
new calc_stanica().execute(passing); //no need to pass in result list
```
Et de changer votre async mise en œuvre opérationnelle de
```
public class calc_stanica extends AsyncTask<ArrayList<String>, Void, ArrayList<String>> {
ProgressDialog dialog;

    @Override
    protected void onPreExecute() {
        dialog = new ProgressDialog(baraj_mapa.this);
        dialog.setTitle("Calculating...");
        dialog.setMessage("Please wait...");
        dialog.setIndeterminate(true);
        dialog.show();
    }

    protected ArrayList<String> doInBackground(ArrayList<String>... passing) {
        ArrayList<String> result = new ArrayList<String>();
        ArrayList<String> passed = passing[0]; //get passed arraylist

        //Some calculations...

        return result; //return result
    }

    protected void onPostExecute(ArrayList<String> result) {
        dialog.dismiss();
        String minim = result.get(0);
        int min = Integer.parseInt(minim);
        String glons = result.get(1);
        String glats = result.get(2);
        double glon = Double.parseDouble(glons);
        double glat = Double.parseDouble(glats);
        GeoPoint g = new GeoPoint(glon, glat);
        String korisni_linii = result.get(3);
    }
```
UPD:

Si vous souhaitez avoir accès à la tâche contexte de départ, le plus simple serait de remplacer onPostExecute en place:
```
new calc_stanica() {
    protected void onPostExecute(ArrayList<String> result) {
      //here you have access to the context in which execute was called in first place. 
      //You'll have to mark all the local variables final though..
     }
}.execute(passing);
```
- Merci pour votre réponse, mais je n'ai plus qu'une chose à demander. Si je définir int min = Integer.parseInt(minim); par exemple, dans la classe AsyncTask onPostExecute(), comment puis-je accéder à partir de ma classe principale méthode? Quand je le modifier comme ceci, j'obtiens "min ne peut pas être résolu" erreur dans la classe principale de la méthode.
- Ilievski: il suffit de faire votre min variable globale.
- Merci à Vous deux pour vos réponses encore une fois, j'ai résolu mon problème...
- J'obtiens l'erreur suivante lorsque je passe un ArrayList sur AsyncTask.execute: Type de sécurité: Un générique gamme de ArrayList<String> est créée pour une varargs paramètre.
- Merci beaucoup pour l'affichage de cette!
- J'ai une question similaire, mais pour moi le résultat est important. Je ne vois pas dans votre exemple, comment result revient à la méthode main. Je n'ai tout simplement pas l'obtenir. Pourriez-vous expliquer?
- en essence, le résultat ne jamais obtenir à la méthode originale.. il est disponible uniquement lorsque onPostExecute méthode fonctionne, généralement, lorsque la première méthode renvoie déjà. C'est pourquoi il est appelé async tâche.
- merci pour votre réponse! Juste pour être clair: par la "méthode main", je veux dire le module/méthode qui a initié doInBackground, dans votre exemple, le premier bloc de code, plus précisément la ligne new calc_stanica().execute(passing);. Si vous passez dans les données, par l'intermédiaire passing; comment voulez-vous récupérer des données? Si je voulais obtenir un résultat, il semble que j'aurais de le stocker dans un champ (ou une sorte de variable globale si la méthode est statique)... est-ce que le droit?
- voir mise à jour exemple..
InformationsquelleAutor Konstantin Burov
12

Pourquoi voudriez-vous passer un ArrayList??
Il devrait être possible de simplement appeler exécuter avec les paramètres directement:
```
String curloc = current.toString();
String itemdesc = item.mDescription;
new calc_stanica().execute(itemdesc, curloc)
```
Que comment varrargs de travail, droit?
Faire une liste de tableaux pour passer la variable est le double de travail.
- Je suis fortement d'accord avec Leander ici. De toute façon pour changer la réponse correcte coche?
InformationsquelleAutor Leander

J'ai en quelque sorte d'accord avec leander sur celui-ci.

appel:

new calc_stanica().execute(stringList.toArray(new String[stringList.size()]));

tâche:

public class calc_stanica extends AsyncTask<String, Void, ArrayList<String>> {
        @Override
        protected ArrayList<String> doInBackground(String... args) {
           ...
        }

        @Override
        protected void onPostExecute(ArrayList<String> result) {
           ... //do something with the result list here
        }
}

Ou vous pourriez juste faire la liste des résultats d'une classe de paramètre et de remplacer la liste de tableaux avec un booléen (succès/échec);

public class calc_stanica extends AsyncTask<String, Void, Boolean> {
        private List<String> resultList;

        @Override
        protected boolean doInBackground(String... args) {
           ...
        }

        @Override
        protected void onPostExecute(boolean success) {
           ... //if successfull, do something with the result list here
        }
}

InformationsquelleAutor Stijn Bollen

Je n'ai pas le faire comme cela. Je trouve plus facile de surcharger le constructeur de la asychtask classe ..

public class calc_stanica extends AsyncTask>

String String mWhateveryouwantToPass;

 public calc_stanica( String whateveryouwantToPass)
{

    this.String mWhateveryouwantToPass = String whateveryouwantToPass;
}
/*Now you can use  whateveryouwantToPass in the entire asynchTask ... you could pass in a context to your activity and try that too.*/   ...  ...

InformationsquelleAutor j2emanue

Vous pouvez recevoir le renvoi de résultats comme ça:
AsyncTask classe

@Override
protected Boolean doInBackground(Void... params) {
    if (host.isEmpty() || dbName.isEmpty() || user.isEmpty() || pass.isEmpty() || port.isEmpty()) {
        try {
            throw new SQLException("Database credentials missing");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    try {
        Class.forName("org.postgresql.Driver");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

    try {
        this.conn = DriverManager.getConnection(this.host + ':' + this.port + '/' + this.dbName, this.user, this.pass);
    } catch (SQLException e) {
        e.printStackTrace();
    }

    return true;
}

la réception de classe:

_store.execute();
boolean result =_store.get();

En espérant que cela en aide.

InformationsquelleAutor Michael

Vous devez vous connecter pour publier un commentaire.