Cos'è Looper in Android?

Looper è una classe in Android utilizzata per gestire il flusso (Thread), rendendolo "Looping" (ciclico). Prepara il thread per elaborare i messaggi dalla coda di messaggi (MessageQueue) fino a quando non viene esplicitamente terminato.

Componenti principali di Looper:

• MessageQueue: Coda che memorizza messaggi (Message) e compiti (Runnable) da eseguire nel thread del Looper. È una struttura sicura per i thread.
• Looper: Collega il thread a MessageQueue e estrae ciclicamente i messaggi dalla coda per la loro elaborazione.
• Handler: Oggetto che inserisce messaggi e compiti nella MessageQueue del Looper e li elabora al loro estrarsi dalla coda. Handler si collega a un Looper specifico.

Come funziona Looper:

1. Preparazione: Nel thread si chiama Looper.prepare(). Questo crea una nuova istanza di Looper e la collega al thread corrente. Viene creata anche una MessageQueue per questo Looper.
2. Avvio del ciclo: Si chiama Looper.loop(). Questo metodo entra in un ciclo infinito (fino a quando il Looper non viene terminato). Nel ciclo, Looper verifica costantemente la MessageQueue alla ricerca di nuovi messaggi.
3. Elaborazione dei messaggi: Quando trova un messaggio, Looper lo estrae e lo invia a un Handler che lo ha aggiunto alla coda. Il Handler esegue il compito corrispondente (ad esempio, chiamare handleMessage() o run() per un Runnable).
4. Terminazione: Per uscire dal ciclo e terminare il Looper, bisogna chiamare Looper.quit() o Looper.quitSafely().

Uso tipico di Looper:

• Creazione di thread di background che devono eseguire compiti asincroni e ricevere messaggi dal thread UI o da altri thread.
• Uso nei servizi (IntentService utilizza un Looper incorporato).
• Lavorare con HandlerThread (una classe di thread che crea il proprio Looper e MessageQueue).

Esempio di creazione di un thread con Looper e Handler:

// Creare e avviare il thread
HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();

// Ottenere il Looper dal thread
Looper looper = handlerThread.getLooper();

// Creare un Handler collegato al Looper
Handler handler = new Handler(looper) {
    @Override
    public void handleMessage(Message msg) {
        // Elaborare i messaggi nel thread di lavoro
        // msg.what contiene l'identificatore del messaggio
        // msg.obj o msg.data possono contenere dati
        switch (msg.what) {
            case 1:
                // Elaborare il messaggio di tipo 1
                break;
            case 2:
                // Elaborare il messaggio di tipo 2
                break;
        }
    }
};

// Inviare un messaggio al thread di lavoro
handler.sendEmptyMessage(1);

// Oppure eseguire un Runnable
handler.post(new Runnable() {
    @Override
    public void run() {
        // Codice eseguito nel thread di lavoro
    }
});

// Quando il thread non è più necessario, terminare il Looper e il thread
handlerThread.quitSafely();