Comment fonctionne le thread principal dans Android?

Le thread principal (Main Thread) en Android, également appelé UI Thread, est le seul thread qui :

• Traite tous les événements de l'interface utilisateur (clics, défilements).
• Dessine les éléments à l'écran.
• Exécute le code du cycle de vie des composants (Activity, Fragment).

Lors du lancement de l'application, Android crée le thread principal. Tous les composants de l'interface utilisateur sont créés et mis à jour uniquement dans ce thread.

Concepts clés :

• Event Loop : Le thread principal fonctionne en boucle, extrayant constamment des messages (événements UI, tâches de rendu) de la file de messages (MessageQueue) et les envoyant aux gestionnaires appropriés (Handler).
• Looper : L'objet Looper est associé au thread et gère ce cycle de traitement des messages.
• Handler : L'objet Handler permet d'envoyer et de traiter des objets Message et Runnable dans le thread associé à sa MessageQueue, où il a été créé. Normalement, Handler est créé dans le thread principal pour interagir avec l'UI depuis d'autres threads.

Problèmes :

• ANR (Application Not Responding) : Si une opération longue est effectuée dans le thread principal, celui-ci se bloque, ne traite pas les événements UI et ne dessine pas l'écran. Cela entraîne le gel de l'application et l'affichage du dialogue ANR. La durée typique provoquant un ANR dans le thread principal lors de l'utilisation de l'UI est de 5 secondes.

Solution :

• Effectuer des opérations longues (requêtes réseau, travail avec la base de données, calculs complexes) dans des fils en arrière-plan.
• Utiliser des mécanismes d'interaction entre threads pour mettre à jour l'UI depuis des threads en arrière-plan (par exemple, Handler, AsyncTask, Coroutines).

// Exemple d'utilisation de Handler pour mettre à jour l'UI depuis un thread en arrière-plan
Handler mainHandler = new Handler(Looper.getMainLooper());

new Thread(new Runnable() {
    @Override
    public void run() {
        // Effectuer une opération longue dans un thread en arrière-plan
        // ...

        // Envoyer une tâche pour mettre à jour l'UI dans le thread principal
        mainHandler.post(new Runnable() {
            @Override
            public void run() {
                // Mettre à jour l'UI dans le thread principal
                // ...
            }
        });
    }
}).start();

// Exemple d'utilisation de coroutines pour mettre à jour l'UI depuis un thread en arrière-plan
import kotlinx.coroutines.*

fun fetchDataAndUpdateUI() {
    CoroutineScope(Dispatchers.IO).launch {
        // Effectuer une opération longue dans un thread en arrière-plan
        val data = fetchDataFromServer()

        // Changer le contexte vers le thread principal pour mettre à jour l'UI
        withContext(Dispatchers.Main) {
            updateUI(data)
        }
    }
}