Tareas asíncronas en Android

AsyncTask es una clase abstracta en Android que nos ofrece la libertad de ejecutar tareas exigentes en segundo plano mientras mantiene el subproceso de la interfaz de usuario liviano y la aplicación receptiva. Cuando se inicia, una aplicación de Android opera en un solo hilo. Debido a este enfoque de subproceso único, las tareas que tardan mucho tiempo en obtener una respuesta pueden hacer que el programa deje de responder. Usamos Android AsyncTask para realizar estas tareas pesadas en segundo plano en un subproceso separado y devolvemos los resultados al subproceso de la interfaz de usuario para evitar esto. Como resultado, el subproceso de la interfaz de usuario siempre responde cuando se usa AsyncTask en una aplicación de Android.

El propósito de AsyncTask era hacer posible el uso correcto y conveniente del subproceso de la interfaz de usuario. Sin embargo, el caso de uso más frecuente fue la integración de la interfaz de usuario, lo que provocó fugas de contexto, devoluciones de llamada perdidas o bloqueos cuando se cambiaba la configuración. Además, se comporta de manera diferente según la versión de la plataforma, acepta excepciones de doInBackground y ofrece pocos beneficios en comparación con el uso directo de Executors. AsyncTask no pretende ser un sistema de subprocesamiento de propósito general; más bien, pretende ser una clase auxiliar para Thread y Handler. AsyncTasks se utiliza mejor para operaciones breves (unos pocos segundos como máximo). Se recomienda encarecidamente que utilice las diversas API que ofrece el paquete java.util.concurrent, como Executor, ThreadPoolExecutor y FutureTask, si necesita mantener subprocesos que se ejecutan durante largos períodos de tiempo.

Las tareas asincrónicas se dividen en tres tipos genéricos: Params, Progress y Result y cuatro pasos: onPreExecute, doInBackground, onProgressUpdate y onPostExecute . A continuación se enumeran los tres tipos genéricos utilizados en una clase AsyncTask de Android:

• Params: Parámetros enviados a la tarea al ejecutarse
• Progreso: Unidades de progreso compartidas durante el cálculo de fondo
• Resultado: Resultado obtenido del cálculo de fondo

Las siguientes definiciones describen los métodos fundamentales utilizados en una clase AsyncTask de Android:

• doInBackground(): El código que debe ejecutarse en segundo plano está contenido en el método doInBackground(). El métodopublishProgress() en este método nos permite entregar resultados repetidamente al subproceso de la interfaz de usuario. Solo necesitamos usar las declaraciones de devolución para indicar que el procesamiento en segundo plano ha finalizado.
• onPreExecute(): el código que se ejecuta antes del comienzo del procesamiento en segundo plano está contenido en esta función.
• onPostExecute(): después de que el método doInBackground haya terminado de procesarse, se llama al método onPostExecute(). Este método recibe la salida del método doInBackground como su entrada.
• onProgressUpdate(): este método puede usar las actualizaciones de progreso que recibe del método publishingProgress, que publica actualizaciones de progreso de la función doInBackground, para actualizar el subproceso de la interfaz de usuario.

Ejemplo de tarea asíncrona

El siguiente fragmento de código debe estar presente en la clase MainActivity para iniciar una AsyncTask.

MyTask myTask = new MyTask();
myTask.execute();

El método de ejecución se usa para iniciar el subproceso en segundo plano en el extracto anterior, donde hemos usado un nombre de clase de muestra que amplía AsyncTask.

class MainActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
  
        val myTask = MyTask()
        myTask.execute(10)
    }
  
    class MyTask {
        
          override fun onPreExecute() {
            super.onPreExecute()
            // ...
        }
        
        override fun doInBackground(vararg params: Void?): String? {
        // ...
        }
  
        override fun onProgressUpdate(values: Int?) {
            super.onProgressUpdate(values);
            // ...
        }
  
        override fun onPostExecute(result: String?) {
            super.onPostExecute(result)
            // ...
        }
    }
}

public class MainActivity extends AppCompatActivity {
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
            
          ExampleAsync task = new ExampleAsync;
          task.execute(10);
    }
  
    private static class ExampleAsync extends AsyncTask<Integer, Integer, String> {
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            // ...
        }
  
        @Override
        protected String doInBackground(Integer... integers) {
            // ...
            return "Finished!";
        }
  
        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            // ...
        }
  
        @Override
        protected void onPostExecute(String string) {
            super.onPostExecute(string);
            // ...
        }
    }
}