Wat is Looper in Android?

Looper is een klasse in Android die wordt gebruikt om de stroom (Thread) te beheren en deze "Looping" (cyclisch) te maken. Het bereidt de thread voor om berichten uit de MessageQueue te verwerken totdat deze expliciet wordt beëindigd.

Belangrijkste componenten van Looper:

• MessageQueue: Een wachtrij die berichten (Message) en taken (Runnable) opslaat voor uitvoering in de Looper-thread. Het is een thread-veilige structuur.
• Looper: Verbindt de thread met de MessageQueue en haalt cyclisch berichten uit de wachtrij voor verdere verwerking.
• Handler: Een object dat berichten en taken in de MessageQueue van de Looper plaatst en deze verwerkt bij het uit de wachtrij halen. Handler is gekoppeld aan een specifieke Looper.

Hoe werkt Looper:

1. Voorbereiding: In de thread wordt Looper.prepare() aangeroepen. Dit creëert een nieuwe instantie van Looper en koppelt deze aan de huidige thread. Er wordt ook een MessageQueue voor deze Looper gemaakt.
2. Start van de lus: Looper.loop() wordt aangeroepen. Deze methode gaat in een oneindige lus (totdat de Looper wordt beëindigd). In de lus controleert de Looper voortdurend de MessageQueue op nieuwe berichten.
3. Verwerking van berichten: Bij het vinden van een bericht, haalt Looper het eruit en stuurt het naar een Handler die het heeft toegevoegd aan de wachtrij. De Handler voert de bijbehorende taak uit (bijvoorbeeld handleMessage() of run() voor Runnable).
4. Beëindiging: Om uit de lus te stappen en de Looper te beëindigen, moet Looper.quit() of Looper.quitSafely() worden aangeroepen.

Typisch gebruik van Looper:

• Aanmaken van achtergrondthreads die taken asynchroon moeten uitvoeren en berichten ontvangen van de UI-thread of andere threads.
• Gebruik in services (IntentService gebruikt een ingebouwde Looper).
• Werken met HandlerThread (een speciale threadklasse die zijn eigen Looper en MessageQueue aanmaakt).

Voorbeeld van het maken van een thread met Looper en Handler:

// Maak en start de thread
HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();

// Verkrijg de Looper van de thread
Looper looper = handlerThread.getLooper();

// Maak een Handler gekoppeld aan de Looper
Handler handler = new Handler(looper) {
    @Override
    public void handleMessage(Message msg) {
        // Verwerk berichten in de worker-thread
        // msg.what bevat de identificatie van het bericht
        // msg.obj of msg.data kunnen gegevens bevatten
        switch (msg.what) {
            case 1:
                // Verwerk bericht van type 1
                break;
            case 2:
                // Verwerk bericht van type 2
                break;
        }
    }
};

// Stuur een bericht naar de worker-thread
handler.sendEmptyMessage(1);

// Of voer een Runnable uit
handler.post(new Runnable() {
    @Override
    public void run() {
        // Code die in de worker-thread wordt uitgevoerd
    }
});

// Wanneer de thread niet meer nodig is, beëindig dan de Looper en de thread
handlerThread.quitSafely();