Qu'est-ce que Looper dans Android?

Looper est une classe dans Android utilisée pour gérer le flux (Thread), en le rendant "Looping" (cyclique). Elle prépare le thread pour traiter les messages de la file de messages (MessageQueue) jusqu'à ce qu'il soit explicitement terminé.

Composants principaux de Looper :

• MessageQueue : File qui stocke les messages (Message) et les tâches (Runnable) à exécuter dans le thread Looper. C'est une structure thread-safe.
• Looper : Relie le thread à MessageQueue et extrait cycliquement les messages pour leur traitement ultérieur.
• Handler : Objet qui place des messages et des tâches dans la MessageQueue du Looper et les traite lors de leur extraction. Handler est lié à un Looper spécifique.

Comment fonctionne Looper :

1. Préparation : Dans le thread, on appelle Looper.prepare(). Cela crée une nouvelle instance de Looper et la lie au thread actuel. Une MessageQueue est également créée pour ce Looper.
2. Démarrage de la boucle : On appelle Looper.loop(). Cette méthode entre dans une boucle infinie (jusqu'à ce que le Looper soit terminé). La boucle vérifie constamment la MessageQueue pour de nouveaux messages.
3. Traitement des messages : Lorsqu'un message est trouvé, Looper l'extrait et l'envoie à un Handler qui l'a ajouté à la file. Le Handler exécute la tâche correspondante (par exemple, appeler handleMessage() ou run() pour un Runnable).
4. Fin : Pour sortir de la boucle et terminer le Looper, il faut appeler Looper.quit() ou Looper.quitSafely().

Utilisation typique de Looper :

• Création de threads en arrière-plan pour effectuer des tâches asynchrones et recevoir des messages du thread UI ou d'autres threads.
• Utilisation dans les services (IntentService utilise un Looper intégré).
• Travailler avec HandlerThread (une classe de thread qui crée son propre Looper et MessageQueue).

Exemple de création d'un thread avec Looper et Handler :

// Créer et démarrer le thread
HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();

// Obtenir le Looper du thread
Looper looper = handlerThread.getLooper();

// Créer un Handler lié au Looper
Handler handler = new Handler(looper) {
    @Override
    public void handleMessage(Message msg) {
        // Traiter les messages dans le thread de travail
        // msg.what contient l'identifiant du message
        // msg.obj ou msg.data peuvent contenir des données
        switch (msg.what) {
            case 1:
                // Traiter le message de type 1
                break;
            case 2:
                // Traiter le message de type 2
                break;
        }
    }
};

// Envoyer un message au thread de travail
handler.sendEmptyMessage(1);

// Ou exécuter un Runnable
handler.post(new Runnable() {
    @Override
    public void run() {
        // Code exécuté dans le thread de travail
    }
});

// Lorsque le thread n'est plus nécessaire, arrêter le Looper et le thread
handlerThread.quitSafely();