Android: Comment passer des parameters à onPreExecute () d’AsyncTask?

J’utilise un AsyncTask pour les opérations de chargement que j’ai implémentées en tant que classe interne.

Dans onPreExecute() je montre une boîte de dialog de chargement que je cache ensuite dans onPostExecute() . Mais pour certaines des opérations de chargement, je sais à l’avance qu’elles se termineront très rapidement, donc je ne veux pas afficher la boîte de dialog de chargement.

Je voulais indiquer ceci par un paramètre booléen que je pourrais passer à onPreExecute() mais apparemment pour une raison quelconque, onPreExecute() ne prend aucun paramètre.

La solution évidente consisterait probablement à créer un champ membre dans mon AsyncTask ou dans la classe externe que je devrais définir avant chaque opération de chargement, mais cela ne semble pas très élégant. Y a-t-il une meilleure manière de faire cela?

Vous pouvez remplacer le constructeur. Quelque chose comme:

 private class MyAsyncTask extends AsyncTask { public MyAsyncTask(boolean showLoading) { super(); // do stuff } // doInBackground() et al. } 

Ensuite, en appelant la tâche, faites quelque chose comme:

 new MyAsyncTask(true).execute(maybe_other_params); 

Edit: c’est plus utile que de créer des variables membres car cela simplifie l’invocation de la tâche. Comparez le code ci-dessus avec:

 MyAsyncTask task = new MyAsyncTask(); task.showLoading = false; task.execute(); 

1) Pour moi, c’est la façon la plus simple de passer des parameters à la tâche asynchrone

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

Déclarez et utilisez la tâche asynchrone comme ici

 private class myAsyncTask extends AsyncTask { @Override protected Void doInBackground(Boolean...pParams) { Boolean param1, param2, param3; // param1=pParams[0]; param2=pParams[1]; param3=pParams[2]; .... } 

2) Passer des méthodes à une tâche asynchrone Pour éviter de coder plusieurs fois l’infrastructure asynchrone de la tâche (thread, messagenhandler, …), vous pouvez envisager de passer les méthodes à exécuter dans votre tâche asynchrone en tant que paramètre. L’exemple suivant décrit cette approche. En outre, vous pourriez avoir besoin de sous-classer la tâche asynchrone pour transmettre les parameters d’initialisation dans le constructeur.

  /* Generic Async Task */ interface MyGenericMethod { int execute(Ssortingng param); } protected class testtask extends AsyncTask { public Ssortingng 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 mytest = new testtask().execute(new MyGenericMethod() { public int execute(Ssortingng param) { //body return 1; } }); } 

pourquoi, comment et quels parameters sont transmis à Asynctask <>, voir détail ici . Je pense que c’est la meilleure explication.

La documentation Android de Google indique que:

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

Les types génériques d’AsyncTask:

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

Params, le type des parameters envoyés à la tâche lors de l’exécution. Progress, le type des unités de progression publiées lors du calcul en arrière-plan. Résultat, le type du résultat du calcul en arrière-plan. Tous les types ne sont pas toujours utilisés par une tâche asynchrone. Pour marquer un type comme non utilisé, utilisez simplement le type Void:

  private class MyTask extends AsyncTask { ... } 

Vous pouvez également consulter: http://developer.android.com/reference/android/os/AsyncTask.html

Ou vous pouvez effacer le rôle d’AsyncTask en consultant le blog de Sankar-Ganesh

Eh bien, la structure d’une classe AsyncTask typique va comme suit:

 private class MyTask extends AsyncTask protected void onPreExecute(){ } 

Cette méthode est exécutée avant de lancer le nouveau thread. Il n’y a pas de valeurs d’entrée / sortie, donc initialisez simplement les variables ou tout ce que vous pensez devoir faire.

 protected Z doInBackground(X...x){ } 

La méthode la plus importante dans la classe AsyncTask. Vous devez placer ici toutes les choses que vous voulez faire en arrière-plan, dans un fil différent de celui principal. Nous avons ici comme valeur d’entrée un tableau d’objects du type “X” (voyez-vous dans l’en-tête? Nous avons “… extend AsyncTask” Ce sont les TYPES des parameters d’entrée) et retourne un object du type “Z”.

Protégé annulé onProgressUpdate (Y y) {

} Cette méthode est appelée à l’aide de la méthode publishProgress (y) et elle est généralement utilisée lorsque vous souhaitez afficher des progrès ou des informations dans l’écran principal, comme une barre de progression indiquant la progression de l’opération en arrière-plan.

Protégé void onPostExecute (Z z) {

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

Qu’en est-il des types X, Y et Z?

Comme vous pouvez en 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 externe? 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 trouver son statut de «l’extérieur». Utiliser la méthode «getStatus ()».

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

RUNNING – Indique que la tâche est en cours d’exécution.

PENDING – Indique que la tâche n’a pas encore été exécutée.

FINISHED – Indique que onPostExecute (Z) est terminé.

Conseils sur l’utilisation d’AsyncTask

N’appelez pas les méthodes onPreExecute, doInBackground et onPostExecute manuellement. Ceci est automatiquement effectué par le système.

Vous ne pouvez pas appeler un AsyncTask dans un autre AsyncTask ou Thread. L’appel de la méthode execute doit être effectué dans le thread d’interface utilisateur.

La méthode onPostExecute est exécutée dans le thread d’interface utilisateur (ici, vous pouvez appeler une autre asyncTask!).

Les parameters d’entrée de la tâche peuvent être un tableau Object, vous pouvez ainsi placer tous les objects et types souhaités.

Vous pouvez soit passer le paramètre dans le constructeur de la tâche ou lorsque vous appelez execute:

 AsyncTask 

Le premier paramètre (Object) est passé dans doInBackground. Le troisième paramètre (MyTaskResult) est renvoyé par doInBackground. Vous pouvez les changer pour les types que vous voulez. Les trois points signifient que zéro ou plusieurs objects (ou un tableau d’entre eux) peuvent être passés en tant qu’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); Ssortingng input1 = "test"; boolean input2 = true; int input3 = 100; long input4 = 100000000; new MyTask(input3, input4).execute(input1, input2); } private class MyTaskResult { Ssortingng text1; Ssortingng text2; } private class MyTask extends AsyncTask { private Ssortingng 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 = (Ssortingng) 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); } } }