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?
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?
Réponses:
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
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
N'appelez pas les méthodes onPreExecute, doInBackground et onPostExecute manuellement. Ceci est fait automatiquement par le système.
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.
La méthode onPostExecute est exécutée dans le thread d'interface utilisateur (ici, vous pouvez appeler une autre AsyncTask!).
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.
WeakAsyncTask
aussi
Une AsyncTask
tâ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 AsyncTask
avec 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.
doInBackgound()
est la méthode la plus importante dans un AsyncTask
car
AsyncTask
paramètres.Alors voyons la relation
doInBackground()
etonPostExecute()
,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");
// show in spinner, access UI elements
était de loin l'explication la plus simple pour le onProgressUpdate(...)
:)
Reportez-vous aux liens suivants:
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
paramètres pour une utilisation d'entrée dans DoInBackground (String ... params)
paramètres pour afficher l'état de l'utilisation de la progression dans OnProgressUpdate (String ... status)
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]