Dynamic-Mess.com


"The world is a dynamic mess of jiggling things..."

Tâche asynchrone avec Android

Article posté le 04-08-2014 dans la catégorie Android

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

1- Pré-requis.

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.

2- Tâche asynchrone depuis une activité

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

3- Depuis un fragment

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();


Tweet
comments powered by Disqus