Je ne comprends pas ce que je suis censé mettre ici et où aboutissent ces arguments? Que dois-je mettre exactement et où ira-t-il exactement? Dois-je inclure les 3 ou puis-je inclure 1,2,20?

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.

Types génériques d'AsyncTask:

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

Params, the type of the parameters sent to the task upon execution.
Progress, the type of the progress units published during the background computation.
Result, the type of the result of the background computation.

Tous les types ne sont pas toujours utilisés par une tâche asynchrone. Pour marquer un type comme inutilisé, utilisez simplement le type Void:

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

Vous pouvez en outre vous référer: http://developer.android.com/reference/android/os/AsyncTask.html

Ou vous pouvez clarifier le rôle d'AsyncTask en vous référant au blog de Sankar-Ganesh

Eh bien, la structure d'une classe AsyncTask typique est la suivante:

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

    protected void onPreExecute(){

    }

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

    protected Z doInBackground(X...x){

    }

La méthode la plus importante de la classe AsyncTask. Vous devez placer ici tout ce que vous voulez faire en arrière-plan, dans un fil différent du fil principal. Ici, nous avons comme valeur d'entrée un tableau d'objets du 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 à l'aide de la méthode publishProgress (y) et elle est généralement utilisée lorsque vous souhaitez afficher une progression ou des informations dans l'écran principal, comme une barre de progression montrant la progression de l'opération que vous effectuez en arrière-plan.

  protected void onPostExecute(Z z){

  }

Cette méthode est appelée une fois l'opération effectuée 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 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 appelle-t-on cette tâche à partir 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 de type X.

Une fois que notre tâche est en cours d'exécution, nous pouvons connaître son statut «de l'extérieur». Utilisation de 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

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

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

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

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

Je suis trop tard pour la fête mais j'ai pensé que cela pourrait aider quelqu'un.

Rester simple!

Une AsyncTasktâche est en arrière-plan qui s'exécute dans le thread d'arrière-plan. Il prend une entrée , effectue une progression et donne une sortie .

ie AsyncTask<Input,Progress,Output>.

À mon avis, la principale source de confusion vient lorsque nous essayons de mémoriser les paramètres dans le AsyncTask.
La clé est de ne pas mémoriser .
Si vous pouvez visualiser ce que votre tâche doit vraiment faire, alors écrire le AsyncTaskavec la signature correcte serait un jeu d'enfant.
Déterminez simplement vos entrées , vos progrès et vos résultats et vous serez prêt à partir.

Par exemple:

Au cœur de l'AsyncTask!

doInBackgound()est la méthode la plus importante dans un AsyncTaskcar

• Seule cette méthode s'exécute dans le thread d'arrière-plan et publie les données dans le thread d'interface utilisateur.
• Sa signature change avec les AsyncTaskparamètres.

Alors voyons la relation

doInBackground()et onPostExecute(), onProgressUpdate()sont également liés

Montrez-moi le code
Alors, comment vais-je écrire le code pour DownloadTask?

DownloadTask extends AsyncTask<String,Integer,String>{

      @Override
      public void onPreExecute()
      {}

      @Override
      public String doInbackGround(String... params)
      {
               // Download code
               int downloadPerc = // calculate that
               publish(downloadPerc);

               return "Download Success";
      }

      @Override
      public void onPostExecute(String result)
      {
          super.onPostExecute(result);
      }

      @Override
      public void onProgressUpdate(Integer... params)
      {
             // show in spinner, access UI elements
      }

}

Comment allez-vous exécuter cette tâche

new DownLoadTask().execute("Paradise.mp3");

Reportez-vous aux liens suivants:

1. http://developer.android.com/reference/android/os/AsyncTask.html
2. http://labs.makemachine.net/2010/05/android-asynctask-example/

Vous ne pouvez pas passer plus de trois arguments, si vous ne voulez passer qu'un seul argument, utilisez void pour les deux autres arguments.

1. private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> 


2. protected class InitTask extends AsyncTask<Context, Integer, Integer>

Une tâche asynchrone est définie par un calcul qui s'exécute sur un thread d'arrière-plan et dont le résultat est publié sur le thread d'interface utilisateur. 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.

KPBird

• en bref, il y a 3 paramètres dans AsyncTask

  1. paramètres pour une utilisation d'entrée dans DoInBackground (String ... params)

  2. paramètres pour afficher l'état de l'utilisation de la progression dans OnProgressUpdate (String ... status)

  3. paramètres pour l'utilisation des résultats dans OnPostExcute (String ... result)

  Remarque: - [Le ​​type de paramètres peut varier en fonction de vos besoins]