Bagaimana cara mengganti AsyncTask dengan Coroutine Kotlin

Untuk waktu yang sangat lama di Android, jika Anda perlu melakukan sesuatu secara asinkron saat membuat aplikasi, Anda mungkin menggunakan AsyncTask. AsyncTask adalah API dalam kerangka Android yang memudahkan menjalankan operasi di latar belakang dan mengembalikan nilai setelah selesai. Dan itu masuk akal. Berbeda dengan Coroutine Kotlin, AsyncTask sudah ada sejak lama, dan sudah terpasang di dalamnya.

Namun, filosofi desain dan implementasi AsyncTask sudah ketinggalan zaman selama bertahun-tahun. Karena itu, Google punya menghentikan penggunaan API AsyncTask. Anda masih dapat menggunakannya jika Anda mau, tetapi Google tidak menyarankan melakukannya. Untungnya, ada banyak alternatif selain AsyncTask, termasuk fitur bahasa Kotlin — coroutine.

API coroutine Kotlin adalah kerangka kerja yang sangat kuat yang memungkinkan Anda melakukan banyak hal. Artikel ini hanya akan menggores permukaan dari apa yang mungkin terjadi. Kami akan membahas dasar-dasar yang diperlukan untuk bermigrasi dari AsyncTask ke coroutine.

Menambahkan Dukungan Coroutine

Sebelum Anda dapat mulai menggunakan coroutine, Anda harus menambahkannya ke proyek Anda.

Menambahkan Dukungan Kotlin

Jika Anda sudah mengimplementasikan Kotlin, lanjutkan ke bagian berikutnya. Jika tidak, Anda harus menambahkan dukungan Kotlin ke proyek Anda. Lihat tutorial saya tentang menambahkan Kotlin ke proyek yang sudah ada untuk lebih jelasnya.

Menambahkan Perpustakaan Coroutine

Di tingkat modul Anda build.gradle, sertakan dependensi berikut.

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

Sinkronkan proyek Anda, dan coroutine Kotlin kini akan tersedia untuk digunakan.

Menggunakan Coroutine

Menerapkan CoroutineScope

Untuk menggunakan coroutine, Anda harus menyediakan instance CoroutineScope. Cara mudah untuk melakukan ini adalah dengan mengimplementasikannya di kelas penampung Anda.

Misalnya, untuk mengimplementasikan CoroutineScope dalam suatu Aktivitas:

classSomeActivity : AppCompatActivity, CoroutineScope by MainScope() {
 ...
override fun onDestroy(){
super.onDestroy()

 cancel()
 }
}

Ini akan membuat SomeActivity mengimplementasikan antarmuka CoroutineScope melalui kelas MainScope. MainScope akan menangani semua logika implementasi untuk CoroutineScope, sekaligus mengizinkan Anda menggunakan metode CoroutineScope. Panggilan cancel() di dalam onDestroy() memastikan tidak ada logika asinkron yang terus berjalan setelah Aktivitas keluar.

Mengganti AsyncTask dengan Coroutine

Katakanlah Anda memiliki AsyncTask di dalam Aktivitas yang melakukan operasi yang berjalan lama di latar belakang dan akhirnya mengembalikan sebuah String. Sesuatu seperti berikut ini.

private inner classSomeTask : AsyncTask() {
 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
 }
}

Menggantinya dengan coroutine itu mudah. Gunakan saja async() metode. milik Kotlin async() berjalan di Thread mana pun tempat peluncurannya, tetapi melakukannya secara asinkron. Ini berarti Anda dapat memperbarui Tampilan dan semacamnya tanpa harus khawatir menggunakan Thread yang tepat.

classSomeActivity : 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"
 }
 }
}

Seperti yang Anda lihat, penggunaan coroutine jauh lebih sederhana dibandingkan menggunakan AsyncTask. Anda tidak perlu hanya menelepon async() dan biarkan ia melakukan tugasnya. Anda dapat menyimpan referensinya dan bahkan menunggu sampai selesai.

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()

Mengembalikan nilai dengan async

Anda bahkan dapat mengembalikan nilai dari async() jika kamu mau. Jadi contoh aslinya bisa menjadi seperti ini.

classSomeActivity : 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
 }
}

Menggunakan denganContext

Untuk kenyamanan, Kotlin menyediakan withContext(). Ini sejalan dengan keseluruhannya await() sesuatu dan hanya mengembalikan nilainya kepada Anda.

classSomeActivity : 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
 }
}

Kesimpulan

Contoh di atas hanyalah beberapa penggunaan dasar coroutine Kotlin untuk membantu Anda memulai. Anda tidak perlu membatasi coroutine pada Aktivitas atau bahkan apa pun dengan siklus hidup yang tepat. Pada dasarnya Anda dapat menjalankannya di mana saja. Ada juga operasi yang lebih maju, seperti memilih Thread mana yang harus menjalankan logika asynchronous. Panduan ini terutama untuk menunjukkan cara mengganti AsyncTask sederhana dengan coroutine sederhana.

Untuk detail selengkapnya tentang cara kerja coroutine, dan cara memanfaatkan fitur lanjutannya, lihat dokumentasi resmi Kotlin.