Retourner une valeur depuis AsyncTask dans Android

Question

Une simple question : est-il possible de renvoyer une valeur en AsyncTask ?

//AsyncTask is a member class
private class MyTask extends AsyncTask<Void, Void, Void>{

    protected Void doInBackground(Void... params) {
         //do stuff
         return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        //do stuff
        //how to return a value to the calling method?
    }
}

Et puis dans mon Activity / Fragment :

// The task is started from activity
myTask.execute()
// something like this?
myvalue = myTask.getvalue() 

EDIT : Cette question a été posée il y a longtemps et je n'étais pas familier avec Java. Maintenant que je m'y connais mieux, je vais faire un résumé rapide :

L'intérêt d'une tâche asynchrone est que la tâche est asynchronous ce qui signifie qu'après avoir appelé execute() sur la tâche, la tâche commence à s'exécuter sur un thread qui lui est propre. renvoyer une valeur de asynctask serait inutile parce que le thread appelant original a déjà continué à faire d'autres choses (donc la tâche est asynchrone).

Pensez au temps : À un moment donné, vous avez lancé une tâche qui s'exécutera en parallèle avec le fil principal. Lorsque la tâche parallèle s'est terminée, le temps s'est également écoulé sur le fil principal. La tâche parallèle ne peut pas remonter le temps pour renvoyer une valeur au thread principal.

Je venais du C, donc je n'y connaissais pas grand-chose. Mais il semble que beaucoup de personnes se posent la même question, alors j'ai pensé que je pourrais clarifier un peu les choses.

Answer 1

C'est ce que onPostExecute() est destiné. Il s'exécute sur le thread de l'interface utilisateur et vous pouvez transmettre votre résultat à l'écran (ou à tout autre endroit où vous le souhaitez). Il ne sera pas appelé avant que le résultat final ne soit disponible. Si vous voulez fournir des résultats intermédiaires, jetez un coup d'oeil à onProgressUpdate()

Answer 2

Pourquoi ne pas appeler une méthode qui gère la valeur ?

public class MyClass extends Activity {

    private class myTask extends AsyncTask<Void, Void, Void> {

        //initiate vars
        public myTask() {
            super();
            //my params here
        }

        protected Void doInBackground(Void... params) {
            //do stuff
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            //do stuff
            myMethod(myValue);
        }
    }

    private myHandledValueType myMethod(Value myValue) {
        //handle value 
        return myHandledValueType;
    }
}

Answer 3

Le plus simple est de passer l'objet appelant dans la tâche asynchrone (lors de sa construction si vous le souhaitez) :

public class AsyncGetUserImagesTask extends AsyncTask<Void, Void, Void> {

    private MyImagesPagerFragment mimagesPagerFragment;
    private ArrayList<ImageData> mImages = new ArrayList<ImageData>();

    public AsyncGetUserImagesTask(MyImagesPagerFragment imagesPagerFragment) {
        this.mimagesPagerFragment = imagesPagerFragment;
    }

    @Override
    public Void doInBackground(Void... records) {
        // do work here
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        mimagesPagerFragment.updateAdapter(mImages);
    }
}

Et la classe appelante (votre activité ou fragment) exécute la tâche :

public class MyImagesPagerFragment extends Fragment {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        AsyncGetUserImagesTask mGetImagesTask = new AsyncGetUserImagesTask(this);
        mGetImagesTask.execute();
    }

Et ensuite, le onPostExecuteMethod appellera n'importe quelle méthode de votre classe d'origine, par ex :

    public void updateAdapter(List<ImageData> images) {
        mImageAdapter.setImages(images);
        mImageAdapter.notifyDataSetChanged();
    }
}

Answer 4

Exemple de code : L'activité utilise AsyncTask pour obtenir une valeur dans un thread d'arrière-plan, puis AsyncTask renvoie le résultat à l'activité en appelant processValue :

public class MyClass extends Activity {
  private void getValue() {
      new MyTask().execute();
  }

  void processValue(Value myValue) {
     //handle value 
     //Update GUI, show toast, etc..
  }

  private class MyTask extends AsyncTask<Void, Void, Value> {
    @Override
    protected Value doInBackground(Void... params) {
      //do stuff and return the value you want 
      return Value;
    }

    @Override
    protected void onPostExecute(Value result) {
      // Call activity method with results
      processValue(result);
    }
  }
}

Answer 5

Vous pouvez essayer celui-ci : myvalue = new myTask().execute().get(); L'inconvénient est que le processus sera gelé jusqu'à ce que l'asyncron ne soit pas terminé ;