Quels sont les arguments passés dans AsyncTask<arg1, arg2, arg3> ?

Question

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

Answer 1

La documentation de Google sur Android 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é, il suffit d'utiliser le type Void :

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

Vous pouvez également vous référer à : http://developer.Android.com/reference/Android/os/AsyncTask.html

Ou vous pouvez clarifier le rôle de l'AsyncTask en vous référant à Blog de Sankar-Ganesh

La structure d'une classe AsyncTask typique se présente comme suit :

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, il suffit donc d'initialiser 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 toutes les choses que vous voulez faire en arrière-plan, dans un thread différent du thread principal. Ici, nous avons comme valeur d'entrée un tableau d'objets de type "X" (Vous voyez dans l'en-tête ? Nous avons "...extends 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 est généralement utilisée lorsque vous souhaitez afficher une progression ou des informations sur l'écran principal, comme une barre de progression montrant l'avancement de l'opération que vous êtes en train d'effectuer en arrière-plan.

  protected void onPostExecute(Z z){

  }

Cette méthode est appelée une fois que l'opération en arrière-plan est terminée. Le paramètre d'entrée est 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 appeler cette tâche à partir d'une classe extérieure ? Simplement 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 notre tâche est en cours d'exécution, nous pouvons connaître son état de l'extérieur. En utilisant la méthode "getStatus()".

 myTask.getStatus();

et nous pouvons recevoir l'état suivant :

COURSE - 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.

FINI - Indique que la fonction onPostExecute(Z) est terminée.

Conseils sur l'utilisation d'AsyncTask

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

2. Vous ne pouvez pas appeler une AsyncTask à l'intérieur d'une autre AsyncTask ou d'un Thread. L'appel de la méthode execute doit se faire dans le Thread de l'interface utilisateur.

3. La méthode onPostExecute est exécutée dans le Thread de l'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, ce qui permet de placer les objets et les types que l'on souhaite.

Answer 2

J'arrive trop tard, mais j'ai pensé que cela pourrait aider quelqu'un.

Answer 3

Restez simple !

En AsyncTask est une tâche d'arrière-plan qui s'exécute en arrière-plan. Elle prend un Entrée , réalise Progrès et donne Sortie .

ie AsyncTask<Input,Progress,Output> .

À mon avis, la principale source de confusion vient du fait que nous essayons de mémoriser les paramètres dans l'outil AsyncTask .
La clé est Ne pas mémoriser .
Si vous pouvez visualiser ce que votre tâche doit réellement faire, alors la rédaction de la AsyncTask avec la bonne signature serait un jeu d'enfant.
Il suffit de déterminer ce que votre Entrée , Progrès y Sortie et vous serez prêt à partir.

Par exemple :

Le cœur de l'AsyncTask !

doInBackgound() est la méthode la plus importante dans un AsyncTask parce que

• Seule cette méthode s'exécute en arrière-plan et publie les données dans le thread de l'interface utilisateur.
• Sa signature change en fonction de la AsyncTask paramètres.

Voyons donc la relation

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

Montrez-moi le code
Comment vais-je donc écrire le code de 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 gérer cette tâche ?

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

Answer 4

Voir les 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 comme un calcul qui s'exécute en arrière-plan et dont le résultat est publié sur l'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.

Answer 5

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

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

  2. paramètres pour l'affichage de l'état d'avancement à utiliser dans OnProgressUpdate(String... status)

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

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