O que é o Looper no Android?

Looper é uma classe no Android que é usada para gerir o fluxo (Thread), tornando-o "Looping" (cíclico). Prepara o thread para processar mensagens da fila de mensagens (MessageQueue) até que seja explicitamente terminado.

Componentes principais do Looper:

• MessageQueue: Fila que armazena mensagens (Message) e tarefas (Runnable) para execução no thread do Looper. É uma estrutura segura para threads.
• Looper: Liga o thread à MessageQueue e extrai mensagens da fila de forma cíclica para processamento posterior.
• Handler: Objeto que coloca mensagens e tarefas na MessageQueue do Looper e as processa ao serem extraídas da fila. O Handler está ligado a um Looper específico.

Como funciona o Looper:

1. Preparação: No thread, chama-se Looper.prepare(). Isto cria uma nova instância de Looper e liga-a ao thread atual. Também é criada uma MessageQueue para este Looper.
2. Início do ciclo: Chama-se Looper.loop(). Este método entra num ciclo infinito (até que o Looper seja terminado). No ciclo, o Looper verifica constantemente a MessageQueue em busca de novas mensagens.
3. Processamento de mensagens: Ao encontrar uma mensagem, o Looper a extrai e envia a um Handler que a adicionou à fila. O Handler executa a tarefa correspondente (por exemplo, chamar handleMessage() ou run() para um Runnable).
4. Finalização: Para sair do ciclo e terminar o Looper, deve-se chamar Looper.quit() ou Looper.quitSafely().

Uso típico do Looper:

• Criar threads de fundo que devem realizar tarefas assíncronas e receber mensagens do thread UI ou de outros threads.
• Uso em serviços (IntentService usa um Looper embutido).
• Trabalhar com HandlerThread (uma classe de thread que cria seu próprio Looper e MessageQueue).

Exemplo de criação de um thread com Looper e Handler:

// Criar e iniciar o thread
HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();

// Obter o Looper do thread
Looper looper = handlerThread.getLooper();

// Criar um Handler ligado ao Looper
Handler handler = new Handler(looper) {
    @Override
    public void handleMessage(Message msg) {
        // Processar mensagens no thread de trabalho
        // msg.what contém o identificador da mensagem
        // msg.obj ou msg.data podem conter dados
        switch (msg.what) {
            case 1:
                // Processar mensagem do tipo 1
                break;
            case 2:
                // Processar mensagem do tipo 2
                break;
        }
    }
};

// Enviar mensagem ao thread de trabalho
handler.sendEmptyMessage(1);

// Ou executar um Runnable
handler.post(new Runnable() {
    @Override
    public void run() {
        // Código a ser executado no thread de trabalho
    }
});

// Quando o thread não for mais necessário, terminar o Looper e o thread
handlerThread.quitSafely();