Android Reactive Programming (Part 3)

Halo kawan-kawan semua! apa kabar nih ? udah lama ya Saya gak nulis lagi 😄 … Kesibukan kerja saat ini membuat Saya agak terhambat untuk melanjutkan tulisan dari artikel sebelumnya

Tanpa basa-basi lagi, kita mulai aja yuk! Bagi yang sudah paham tentang reactive programming mungkin tidak akan mengalami kesulitan untuk mencoba migrasi dari versi 1 ke versi 2 😜… Dan bagi yang belum paham apa itu reactive, ada baiknya baca kembali di artikel Saya yang pertama

Pada versi 2 ini, kita akan di suguhi berbagai macam tipe reactive yang bisa kita pakai sesuai kebutuhan. Apa saja sih tipe-tipe tersebut ? yuk kita bahas satu persatu 🙂

• Flowable: Tipe ini sejatinya hampir serupa dengan observable, namun ada sedikit perbedaan mendasar dari kedua tipe tersebut. apa tuh 🤔 … IMHO, biasanya observable digunakan untuk melakukan proses threading kurang lebih 1000 element dalam 1 proses. Bisa juga dikatakan untuk melakukan proses yang tidak terlalu heavy, sebaliknya flowable digunakan untuk melakukan proses threading yang simultan (ada beberapa flow yang akan dilakukan dalam 1x pemanggilan proses). Lalu, bagaimana sih bentuk implementasinya ?

Flowable.just(1, 2, 3, 4, 5)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeOn(Schedulers.io())
        .reduce(50) { t1, t2 -> t1 + t2 }
        .subscribe(
                { textView.text = it.toString() },
                { it.printStackTrace() }
        )

Contoh di atas merupakan salah satu bentuk implementasi sederhana dari flowable yang ditulis menggunakan bahasa pemrograman Kotlin 😮

• Single: Tipe ini dapat digunakan untuk menjalankan beberapa proses/thread yang hasil keluarannya dapat dijadikan dalam 1 proses threading, bisa juga dikatakan dengan istilah can emit a single item or event. Kira-kira bentuk implementasi sederhananya adalah seperti berikut ini

val todos = arrayListOf("Eat", "Sleep", "Work")

Single.just(todos)
      .observeOn(AndroidSchedulers.mainThread())
      .subscribeOn(Schedulers.io())
      .subscribe(
              { textView.text = it.joinToString(" , ") { it } },
              { it.printStackTrace() }
      )

• Completable: Tipe completable merupakan salah satu tipe yang tidak memperdulikan apakah proses dalam suatu thread ada kemungkinan gagal atau tidak (CMIIW 😅), sehingga tidak mempengaruhi stream dari event yang sedang kita jalankan. Bisa juga digunakan untuk menggantikan runnable thread yang biasa kita lakukan ketika tidak menggunakan reactive. Contohnya adalah seperti ini

val current = "Start counting..."
textView.text = current

Completable.timer(3000, MILLISECONDS)
           .observeOn(AndroidSchedulers.mainThread())
           .subscribeOn(Schedulers.io())
           .subscribe(
                   { val result = "Done after 3 second"
                     textView.text = result
                   },
                   { it.printStackTrace() }
           )

• Maybe: IMHO tipe ini merupakan bentuk implementasi reactive dengan pendekatan optional. Dapat digunakan untuk melakukan suatu proses yang hasil keluarannya membutuhkan 2 flow antara sukses atau gagal ataupun tidak menghasilkan event apapun, dalam 1 kesatuan proses/thread. Bentuk sederhana dari implementasi maybe adalah sebagai berikut

val questions = arrayListOf("Yes", "or", "No")
Maybe.create<List<String>> { maybeEmitter ->
    try {
        when { 
            questions.isNotEmpty() -> 
                maybeEmitter.onSuccess(questions)
            else -> 
                maybeEmitter.onComplete() 
        }
    } catch (e: Exception) {
        maybeEmitter.onError(e)
    }
}.observeOn(AndroidSchedulers.mainThread())
 .subscribeOn(Schedulers.io())
 .subscribe(
         { textView.text = it.size.toString() },
         { it.printStackTrace() }
 )

Nah, bagaimana kira-kira ? apakah teman-teman sudah cukup puas dan paham dengan penjelasan singkat mengenai Rx2 ini ? Jika belum puas atau ada yang kurang, mohon dimaafkan ya 😅 … Untuk lebih jelasnya lagi, bisa coba dilihat pada source lengkapnya di sini