Como você trabalha com operações assíncronas no Android?

No Android, para trabalhar com operações assíncronas, utilizo várias abordagens dependendo da complexidade da tarefa e dos requisitos do ciclo de vida:

1. Coroutines (Kotlin): Abordagem preferida para novos projetos e refatoração. São leves, permitem escrever código assíncrono de forma sequencial, gerenciam a cancelamento e estão integradas com ViewModel e componentes ScopeAware.

   // Exemplo de uso de CoroutineScope para lançar uma coroutine
   lifecycleScope.launch { 
       val result = withContext(Dispatchers.IO) { 
           // Executar operações longas no dispatcher IO
           fetchDataFromNetwork() 
       }
       // Atualizar UI no dispatcher Main
       updateUI(result) 
   }
   

2. RxJava/RxKotlin: Utilizado para fluxos de dados complexos, programação reativa e transformação de eventos. Oferece operadores poderosos para trabalhar com fluxos de dados.

   // Exemplo de uso de RxJava para realizar uma operação assíncrona
   Observable.just("dados")
       .subscribeOn(Schedulers.io()) // Execução na thread IO
       .observeOn(AndroidSchedulers.mainThread()) // Resultado na thread principal
       .subscribe(
           result -> {
               // Processar resultado
               updateUI(result);
           },
           error -> {
               // Processar erro
               handleError(error);
           }
       );
   

3. AsyncTask (Obsoleto): Em projetos antigos ou quando se precisa de uma implementação simples de tarefa assíncrona sem bibliotecas externas. Deve ser evitado no código moderno devido a problemas de vazamentos de memória e gestão do ciclo de vida.

   // Exemplo de uso de AsyncTask
   private class MyAsyncTask extends AsyncTask<Void, Void, String> {
   
       @Override
       protected String doInBackground(Void... voids) {
           // Operações em thread de fundo
           return fetchData();
       }
   
       @Override
       protected void onPostExecute(String result) {
           // Atualizar UI na thread principal
           updateUI(result);
       }
   }
   
   // Executar tarefa
   new MyAsyncTask().execute();
   

4. Handler e Looper: Utilizados para enviar tarefas a uma thread específica ou para executar código com atraso.

5. ThreadPoolExecutor: Utilizado para gerenciar um pool de threads ao executar muitas tarefas em paralelo.

A escolha da abordagem depende de:

• Linguagem de programação: Kotlin favorece as Coroutines.
• Complexidade da tarefa: Para tarefas simples, Coroutines ou Handler são suficientes. Para fluxos de dados complexos, RxJava.
• Requisitos de gestão do ciclo de vida: Coroutines e RxJava oferecem mecanismos convenientes para cancelar e para se integrar com componentes Android.
• Base de código existente: Em projetos com RxJava, continuo a usá-lo.

Sempre garanto uma gestão correta dos threads (UI/Main para atualizações de UI, IO/Background para operações longas) e a cancelamento de tarefas ao destruir o componente, para evitar vazamentos de memória e comportamentos incorretos.