Attention, le contenu cet article est peut-être obsolète !
Quelques explications pour l'utilisation de tâches asynchrones avec AndroidDans une application mobile l'utilisation de tâches asynchrones est vite obligatoire si vous voulez que l'application ne gèle pas à l'écran du terminal. Voici comment procéder sous Android.
Il y a quelques éléments à connaître. Tout d'abord la tâche doit être lancée par le thread qui gère l'interface utilisateur pour fonctionner convenablement.
Pour lancer la tâche, utilisez la méthode execute().
De plus, voici les 4 méthodes importantes de votre tâche :
Ces méthodes ne doivent jamais être appelées manuellement!
Dernière info importante : une tâche ne peut être lancée qu'une seule fois. Si vous devez la rappeler une deuxième fois, ré-instancier la classe qui la gère.
C'est le plus simple cas de figure. Il vous suffit de créer votre activité tout en y ajoutant :
extends AsyncTask
Elle hérite donc des éléments des tâches asynchrones. Cependant, des 4 méthodes mentionnées plus haut, vous devez obligatoirement implémenter celle-ci :
doInBackground
Pas la peine de vous expliquer pourquoi. Les autres ne sont à implémenter que si vous en avez besoin, mais si vous souhaitez faire une application de bonne qualité, c'est recommandé.
Là c'est un peu plus long. Il vous faut tout d'abord créer une interface, que nous appellerons TaskCallbacks :
interface TaskCallbacks {
void onPreExecute();
void onProgressUpdate(int percent);
void onCancelled();
void onPostExecute();
}
Ensuite, dans votre fragment qui aura besoin de la tâche asynchrone, créez un attribut privé :
private TaskCallbacks mCallbacks;
et implémentez la méthode onAttach (si ce n'est pas déja fait) :
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
mCallbacks = (TaskCallbacks) activity;
}
et onCreate :
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}
et enfin onDetach :
@Override
public void onDetach() {
super.onDetach();
mCallbacks = null;
}
Enfin, dans votre fragment, créez une classe interne qui contiendra le code de votre tâche asynchrone. Par exemple :
class envoiEmail extends AsyncTask {
private String Url = null;
private List pairs;
postRequest laRequete;
public void envoiMonEmail(String Url, List pairs){
laRequete = new postRequest();
this.Url = Url;
this.pairs = pairs;
this.execute(); // On lance la tâche après avoir préparé les données
}
@Override
protected Void doInBackground(Void... arg0) {
laRequete.sendRequest(Url, pairs); // C'est le contenu de la tâche asynchrone
return null;
}
@Override
protected void onPostExecute(Void ignore) {
// Code exécuté après la fin de la tâche
Resultat = laRequete.getResultat();
Toast.makeText(getActivity().getApplicationContext(), "Message envoyé", Toast.LENGTH_LONG).show();
}else{
Toast.makeText(getActivity().getApplicationContext(), "Erreur : le message n'a pu être envoyé", Toast.LENGTH_LONG).show();
}
if (mCallbacks != null) {
mCallbacks.onPostExecute();
}
}
@Override
protected void onPreExecute() {
Toast.makeText(getActivity().getApplicationContext(), "Envoi en cours, veuillez patienter", Toast.LENGTH_LONG).show();
if (mCallbacks != null) {
mCallbacks.onPreExecute();
}
}
}
Vous n'avez plus qu'à instancier votre classe et appeler la méthode envoiMonEmail();