Kotlin Coroutines Solusi Asynchronous di Android

Kotlin yang menjadi salah satu bahasa pemrograman yang dapat digunakan untuk membuat aplikasi android (selain java tentunya). Kotlin mulai disupport oleh Android Studio sejak versi 3.0. Membuat Aplikasi Android tentu nya membutuhkan Asynchronous programming atau Non-block terhadap Main-Thread (dalam android disebut UI-Thread). Sebenarnya Android sendiri sudah menyediakan fungsi tersebut yaitu AsycnTask akan tetapi dalam hal performa dan keprakstisan agak kurang diminati.

Salah satu contoh hal yang dapat memblok Main-Thread saat kita melakukan fetch data dari API atau ketika melakukan parsing data dalam jumlah besar. Walaupun dari segi kecepatan hanya butuh 0,1 detik jika itu dilakukan pada android (UI-Thread) maka tampilan diandroid akan freeze atau beku untuk 0,1 detik hal itu tentu akan mengganggu user saat berselancar didalam aplikasi yang kita. Disaat itulah asynchronous programming dibutuhkan, untuk menghindari freeze ketika menjalankan proses yang dapat memblok Main-thread.

Dalam android AsyncTask tentunya dapat menghandle hal tersebut, akan tetapi dalam hal kepraktisan sangatlah kurang. Dimulai dari membuat Class yang meng-extend AsyncTask lalu meng-Override function doInbackground untuk memproses untuk mendapatkan hasilnya lalu hasil tersebut akan dikirim ke function postExecute dari sini akan memproses hasil tersebut untuk di tampilkan di dalam UI (misalkan).

Semua proses menggunakan AsyncTask tadi bisa digantikan dengan Coroutines. Walaupun pada kenyataannya sangat berbeda AsyncTask lebih ke callback function dan Async-Await dengan promise yang belum tentu ditepati(becanda bang). Sedangkan Coroutines menggunakan suspend function tidak seperti callback atau promise.

Untuk lebih lengkapnya tentang suspend function video berikut bisa jadi referensi klik disini

Lanjut penerapan Coroutines, saat me-suspend function bukan berarti menjalankan di-background dan menjalankan coroutines tidak serta merta pada Main-thread, bisa juga di sesuaikan sesuai kebutuhan dengan memilih dispatchers,

1. Dispatchers.Main baik digunakan untuk menjalankan function yang berhubungan langsung dengan UI, misalkan melakukan update data ke UI Android.
2. Dispatchers.IO bisa digunakan menjalankan function yang tidak behubungan langsung dengan UI, misal read-write di SQLite atau Networking (fetch API)
3. Dispatchers.Default yang menjalankan function menggunakan kinerja CPU, misalkan sorting data atau parsing data

Contoh implementasi dari kotlin coroutines pada android, bisa diimplemtasikan saat mengambil data dari API lalu menampilkan data tersebut. Sebagai contoh kita gunakan jsonplaceholder sebagai API dan untuk Rest Client menggunakan Retrofit.

pertama implementasi library app/build.gradle

// kotlinx-coroutines
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"
// retrofit2 & okhttp3
implementation "com.squareup.retrofit2:retrofit:2.5.0"
implementation "com.squareup.okhttp3:okhttp:3.12.0"
implementation 'com.squareup.okhttp3:logging-interceptor:3.11.0'
// converter-gson
implementation "com.squareup.retrofit2:converter-gson:2.5.0"
implementation "com.google.code.gson:gson:2.8.5"
// retrofit2-kotlin-coroutines-adapter
implementation "com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2"

Buat file untuk menjadi model “posts.kt” sesuaikan dengan response dari jsonplaceholder

class PlaceholderPosts (
    @SerializedName("id") val id: Int = 0,
    @SerializedName("userId") val userId : Int = 0,
    @SerializedName("title") val title: String = "",
    @SerializedName("body") val body: String = ""
)

lalu inisiasikan Retrofit lalu buat interface gunakan Deferred yang akan digunakan untuk mendapatkan nilai gagal atau berhasilnya request. Deferred bukan hanya untuk mendapat nilai nya saja, Deferred ju

interface NetworkService {
    @GET("posts")
    fun getPosts() : Deferred<Response<List<Posts>>>
}

Inisiasikan service retrofit sebagai berikut,

var service: NetworkService = retrofit.create(NetworkService::class.java)

Disini service sudah diinisiasikan, sebagai catatan karena menggunakan Retrofit sebagai Rest Client maka untuk thread networking akan dihandle oleh Retrofit, jadi untuk Dispatchers yang digunakan Dispatchers.Main, karena thread networking dan parsing sudah dihandle Retrofit dan partnernya (Gson Converter) jadi hanya membuat suspend function untuk melakukan fetch API dengan Retrofit dan responsenya bisa langsung diproses atau ditampilkan ke UI Android.

GlobalScope.launch(Dispatchers.Main) {
    val postRequest = service.getPosts()
    val response = postRequest.await()
    mainView.onGetPost(response.body()?: arrayListOf())
}

Contoh diatas merupakan contok Coroutines yang diimplementasikan dengan Retrofit. response tersebut merupakan dari object dari deferred yang memanggil function await(). function await() dari Deferred merupakan function yang harus dipanggil didalam blok launch agar tidak memblok Main-Thread. Object response sendiri merupakan object dari Retrofit jadi untuk mendapatkan result berada di body.

Setelah mendapatkan hasil karena menggunakan Dispatcers.Main maka dapat mengg-update UI di Android.

override fun onGetPost(response: List<PlaceholderPosts>) {
    response?.forEach {
        val text = TextView(this)
        text.text = it.toString()
        drawer_layout?.addView(text)
    }
}

Untuk code lebih lengkap bisa buka di sini

yanuwar/CoroutinesMeetRetrofitAndroidX

Sebagai penutup, Coroutines sangat cocok digunakan untuk melakukan asynchronous programming dengan kondisi saat fetch API, read-write database, parsing data, dan kondisi dimana hanya membutuhkan satu pekerjaan ditiap function yang mungkin dapat menggangu UI thread pada Aplikasi android.