Cómo reemplazar AsyncTask con corrutinas de Kotlin

Durante mucho tiempo en Android, si tuviera que hacer algo de forma asincrónica mientras creaba una aplicación, probablemente usaría AsyncTask. AsyncTask es una API como parte de Android que facilita la realización de operaciones en segundo plano y devuelve valores cuando se completa. Y eso tiene sentido. A diferencia de las corrutinas de Kotlin, AsyncTask ha existido por un tiempo y está integrado.

Sin embargo, la filosofía de diseño y la implementación de AsyncTask se ha vuelto algo desactualizada a lo largo de los años. Por este motivo, Google dejó de utilizar la API AsyncTask. Aún puede usarlo si lo desea, pero Google no lo recomienda. Afortunadamente, hay un montón de alternativas a AsyncTask, incluida una característica del lenguaje Kotlin: las corrutinas.

La API Coroutines de Kotlin es un marco increíblemente poderoso que le permite hacer muchas cosas. Este artículo solo arañará la superficie de lo que es posible. Repasaremos los conceptos básicos necesarios para migrar de AsyncTask a corrutinas.

Soporte agregado para corrutinas

Antes de que pueda comenzar a usar corrutinas, debe agregarlas a su proyecto.

Soporte agregado para Kotlin

Si ya ha implementado Kotlin, pase a la siguiente sección. De lo contrario, deberá agregar el soporte de Kotlin a su proyecto. Consulte mi tutorial sobre cómo agregar Kotlin a un proyecto existente para obtener más detalles.

Adición de bibliotecas de corrutinas

A su nivel de módulo build.gradle, incluyen las siguientes dependencias.

dependencies {
    ...
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.0'
}

Sincronice su proyecto y las corrutinas de Kotlin ahora estarán disponibles.

Te puede interesar:  Android 13 ayudará a los desarrolladores a probar sus aplicaciones con conexiones a Internet más lentas

Usar corrutinas

Implementación de un CoroutineScope

Para usar corrutinas, debe tener una instancia de CoroutineScope. Una forma fácil de hacer esto es simplemente implementarlo en su clase de contenedor.

Por ejemplo, para implementar un CoroutineScope en una actividad:

class SomeActivity : AppCompatActivity, CoroutineScope by MainScope() {
        ...

        override fun onDestroy() {
            super.onDestroy()
     
           cancel()
        }
}

Esto obligará a SomeActivity a implementar la interfaz CoroutineScope a través de la clase MainScope. MainScope se encargará de toda la lógica de implementación de CoroutineScope, sin dejar de permitirle utilizar los métodos de CoroutineScope. Llamar cancel() dentro onDestroy() garantiza que no se siga ejecutando ninguna lógica asincrónica después de que finalice la actividad.

Reemplazo de AsyncTask con Coroutines

Suponga que tiene una AsyncTask en una actividad que realiza una operación en segundo plano de larga duración y, en última instancia, devuelve una cadena. Algo parecido a lo siguiente.

private inner class SomeTask : AsyncTask<Void, Void, String>() {
    override fun doInBackground(vararg params: Void): String {
        try {
            //Pretend this is an actual operation that takes 10 seconds and not just sleeping.
            Thread.sleep(10000);
        } catch (e: InterruptedException) {}
         
        return "SomeString";
    }

    override fun onPostExecute(result: String) {
        val someTextView = findViewById(R.id.some_text_view)
        someTextView.text = result
    }
}

Reemplazarlo con una corrutina es fácil. Solo usa el async() método. De Kotlin async() se ejecuta en el subproceso en el que se inició, pero lo hace de forma asincrónica. Esto significa que puede actualizar vistas y similares sin tener que preocuparse por usar el hilo correcto.

class SomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    ...

    private fun doOperation() {
        async {
            //Inside coroutine scopes (like inside async here), delay is used instead of Thread.sleep.
            delay(10000)

            val someTextView = findViewById(R.id.some_text_view)
            someTextView.text = "SomeString"
        }
    }
}

Como puede ver, usar corrutinas puede ser mucho más fácil que usar AsyncTask. No tienes que llamar async() y déjelo hacer su trabajo, sin embargo. Puede consultarlo e incluso esperar a que termine.

val asyncJob = async {
    //Some operation
}
//Pause here until the async block is finished.
asyncJob.await()

//This won't run until asyncJob finishes, but other operations started before the job, or started from another method, can still run.
doSomethingElse()

Devolver valores con async

Incluso puedes devolver un valor de async() si quieres. Entonces, el ejemplo original podría convertirse en algo como esto.

class SomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    ...
    private fun doOperation() {
        val asyncJob = async {
            //Inside coroutine scopes (like inside async here), delay is used instead of Thread.sleep.
            delay(10000)

            //Whatever the type is of the last line is what async() eventually returns.
           "SomeString"
        }

        val result = asyncJob.await()

        val someTextView = findViewById(R.id.some_text_view)
        someTextView.text = result
    }
}

Usando withContext

Para mayor comodidad, Kotlin ofrece withContext(). Esta en línea el conjunto await() cosa y simplemente te devuelve el valor.

class SomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    ...
    private fun doOperation() {
        //Run asynchronously on the main Thread.
        val result = withContext(Dispatchers.Main) {
            delay(10000)

            "SomeResult"
        }

        val someTextView = findViewById(R.id.some_text_view)
        someTextView.text = result
    }
}

Conclusión

Los ejemplos anteriores son solo algunos usos básicos de las corrutinas de Kotlin para comenzar. No tiene que limitar las corrutinas a actividades o incluso a cualquier cosa que tenga un ciclo de vida adecuado. Puede realizarlos prácticamente en cualquier lugar. También hay operaciones más avanzadas, como elegir qué hilo debe realizar lógica asincrónica. Esta guía se utiliza principalmente para mostrar cómo reemplazar una AsyncTask simple con una corrutina simple.

Te puede interesar:  Un día con el futuro de las PC conectadas

Para obtener más detalles sobre cómo funcionan las corrutinas y cómo puede utilizar sus funciones más avanzadas, consulte la documentación oficial de Kotlin.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir

Usamos cookies para mejorar la experiencia del usuario. Selecciona aceptar para continuar navegando. Más información

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad