Como realizar operações assíncronas no Android puro…

Existem várias formas:

Threads: Criação e gestão de threads próprios.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Executar operação prolongada
        // ...
        // Atualizar UI (requer Handler)
        // handler.post(...)
    }
}).start();

Handler e Looper: Usados para troca de mensagens entre threads, frequentemente para atualizar a UI a partir de uma thread de fundo.

Handler handler = new Handler(Looper.getMainLooper());
// ... na thread de fundo
handler.post(new Runnable() {
    @Override
    public void run() {
        // Atualizar UI
    }
});

AsyncTask (obsoleto, mas útil de saber): Forma simples de executar tarefas assíncronas com atualização de UI. Não recomendado para código novo.

private class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Executar operação prolongada
        return "Resultado";
    }

    @Override
    protected void onPostExecute(String result) {
        // Atualizar UI com o resultado
    }
}
// ...
// new MyAsyncTask().execute();

ExecutorService e Future: Mecanismo mais flexível para gerir pools de threads.

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Executar operação prolongada
        return "Resultado";
    }
});
// Obter resultado (bloqueante)
// String result = future.get();

Corutinas do Kotlin: Abordagem moderna para programação assíncrona em Kotlin, baseada em corutinas. Requer adição de dependências.

import kotlinx.coroutines.*

// ... no escopo de uma coroutine (por exemplo, viewModelScope)
GlobalScope.launch(Dispatchers.IO) { // Executar em thread de fundo IO
    // Executar operação prolongada
    withContext(Dispatchers.Main) { // Alternar para thread principal para atualizar UI
        // Atualizar UI
    }
}

A escolha do método depende da complexidade da tarefa, do nível de controlo necessário sobre os threads e das preferências da linguagem (Java/Kotlin). No desenvolvimento Android moderno, recomenda-se usar Corutinas do Kotlin ou bibliotecas para trabalho assíncrono, como RxJava ou Flow.

Como realizar operações assíncronas no Android puro?