Android: Comment passer des paramètres à Onpreexecute () D'AsyncTask?

1) pour moi, c'est la façon la plus simple de passer les paramètres à la tâche async est comme ceci

// To call the async task do it like this
Boolean[] myTaskParams = { true, true, true };
myAsyncTask = new myAsyncTask ().execute(myTaskParams);

déclarer et utiliser la tâche async comme ici

private class myAsyncTask extends AsyncTask<Boolean, Void, Void> {

    @Override
    protected Void doInBackground(Boolean...pParams) 
    {
        Boolean param1, param2, param3;

        //

          param1=pParams[0];    
          param2=pParams[1];
          param3=pParams[2];    
      ....
}                           

2) Passer des méthodes à async-tâche Afin d'éviter de coder l'infrastructure Async-Task (thread, messagenhandler, ... plusieurs fois, vous pourriez envisager de passer les méthodes qui devraient être exécutées dans async-tâche comme un paramètre. L'exemple suivant décrit cette approche. En outre, vous pourriez avoir besoin de sous-classe async-tâche pour passer des paramètres d'initialisation dans le constructeur.

 /* Generic Async Task    */
interface MyGenericMethod {
    int execute(String param);
}

protected class testtask extends AsyncTask<MyGenericMethod, Void, Void>
{
    public String mParam;                           // member variable to parameterize the function
    @Override
    protected Void doInBackground(MyGenericMethod... params) {
        //  do something here
        params[0].execute("Myparameter");
        return null;
    }       
}

// to start the asynctask do something like that
public void startAsyncTask()
{
    // 
    AsyncTask<MyGenericMethod, Void, Void>  mytest = new testtask().execute(new MyGenericMethod() {
        public int execute(String param) {
            //body
            return 1;
        }
    });     
}

pourquoi, comment et quels paramètres sont passés à Asynctask<>, voir détail ici . Je pense que c'est la meilleure explication.

la Documentation Android de Google dit que:

une tâche asynchrone est définie par 3 types génériques, appelés Params, Progress and Result, et 4 étapes, appelées PreExecute, doInBackground, onProgressUpdate et onPostExecute.

types génériques de AsyncTask:

les trois types utilisés par une tâche asynchrone sont les suivants:

Params, le type des paramètres envoyés à la tâche lors de l'exécution. Progress, le type d'unités de progrès publiées pendant le calcul de base. Résultat, le type du résultat du calcul de fond. Tous les types ne sont pas toujours utilisés par une tâche asynchrone. Pour marquer un type comme non utilisé, il suffit d'utiliser le type Void:

 private class MyTask extends AsyncTask<Void, Void, Void> { ... }

vous pouvez consulter : http://developer.android.com/reference/android/os/AsyncTask.html

ou vous pouvez clarifier Quel est le rôle D'AsyncTask en se référant au Blog de Sankar-Ganesh

la structure d'une classe D'AsyncTask typique ressemble à:

private class MyTask extends AsyncTask<X, Y, Z>

    protected void onPreExecute(){ 

    } 

cette méthode est exécutée avant le démarrage du nouveau Thread. Il n'y a pas de valeurs d'entrée/sortie, Donc initialisez simplement les variables ou ce que vous pensez avoir besoin de faire.

protected Z doInBackground(X...x){

}

la méthode la plus importante de la classe AsyncTask. Vous devez placer ici toutes les choses que vous voulez faire dans le fond, dans un fil différent de celui principal. Nous avons ici comme une valeur d'entrée un tableau d'objets de type "X" (voyez-vous dans l'en-tête? Nous avons "...étend AsyncTask " ce sont les TYPES des paramètres d'entrée) et renvoie un objet du type "Z".

protected void onProgressUpdate (Y y) {

} Cette méthode est appelée en utilisant la méthode publiprogress (y) et elle est habituellement utilisée lorsque vous voulez montrer n'importe quel progrès ou information dans l'écran principal, comme une barre de progrès montrant le progrès de l'opération que vous faites dans l'arrière-plan.

protected void onPostExecute (Z z) {

} Cette méthode est appelée après l'opération en arrière-plan est fait. Comme un paramètre d'entrée, vous recevrez le paramètre de sortie de la méthode doInBackground.

et les types X, Y et Z?

comme vous pouvez le déduire de la structure ci-dessus:

X – The type of the input variables value you want to set to the background process. This can be an array of objects.

 Y – The type of the objects you are going to enter in the onProgressUpdate method.

 Z – The type of the result from the operations you have done in the background process.

comment appelons-nous cette tâche d'une classe extérieure? Juste avec les deux lignes suivantes:

MyTask myTask = new MyTask();

myTask.execute(x);

où x est le paramètre d'entrée du type X.

une fois que nous avons notre tâche en cours, nous pouvons connaître son statut de "l'extérieur". En utilisant la méthode" getStatus ()".

myTask.getStatus(); et nous pouvons recevoir le statut suivant:

exécution-indique que la tâche est en cours d'exécution.

en attente-indique que la tâche n'a pas encore été exécutée.

terminé-indique que onPostExecute (Z) est terminé.

conseils sur L'utilisation D'AsyncTask

ne pas appeler manuellement les méthodes onPreExecute, doInBackground et onPostExecute. C'est fait automatiquement par le système.

vous ne pouvez pas appeler un AsyncTask à l'intérieur d'un autre AsyncTask ou Thread. L'appel de la méthode execute doit être fait dans le Thread de l'INTERFACE utilisateur.

la méthode onPostExecute est exécutée dans le Thread UI (ici vous pouvez appeler un autre AsyncTask!).

les paramètres d'entrée de la tâche peuvent être un tableau D'objets, de cette façon vous pouvez mettre tous les objets et les types que vous voulez.

vous pouvez passer le paramètre dans le constructeur de tâche ou quand vous appelez exécuter:

AsyncTask<Object, Void, MyTaskResult>

le premier paramètre (objet) est passé dans doInBackground. Le troisième paramètre (MyTaskResult) est retourné par doInBackground. Vous pouvez modifier les types que vous voulez. Les trois points que zéro ou plusieurs objets (ou un tableau) peut être passé comme argument(s).

public class MyActivity extends AppCompatActivity {

    TextView textView1;
    TextView textView2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);    
        textView1 = (TextView) findViewById(R.id.textView1);
        textView2 = (TextView) findViewById(R.id.textView2);

        String input1 = "test";
        boolean input2 = true;
        int input3 = 100;
        long input4 = 100000000;

        new MyTask(input3, input4).execute(input1, input2);
    }

    private class MyTaskResult {
        String text1;
        String text2;
    }

    private class MyTask extends AsyncTask<Object, Void, MyTaskResult> {
        private String val1;
        private boolean val2;
        private int val3;
        private long val4;


        public MyTask(int in3, long in4) {
            this.val3 = in3;
            this.val4 = in4;

            // Do something ...
        }

        protected void onPreExecute() {
            // Do something ...
        }

        @Override
        protected MyTaskResult doInBackground(Object... params) {
            MyTaskResult res = new MyTaskResult();
            val1 = (String) params[0];
            val2 = (boolean) params[1];

            //Do some lengthy operation    
            res.text1 = RunProc1(val1);
            res.text2 = RunProc2(val2);

            return res;
        }

        @Override
        protected void onPostExecute(MyTaskResult res) {
            textView1.setText(res.text1);
            textView2.setText(res.text2);

        }
    }

}