Belajar Kotlin Part 16: Kotlin Flow untuk Pemrograman Reactive di Android

Pelajari Kotlin Flow untuk menangani data asynchronous dan reactive stream di Android agar aplikasi lebih responsif dan efisien.

Pendahuluan

Setelah mempelajari Kotlin Coroutines (Part 15), kita sudah tahu bagaimana cara menjalankan tugas asynchronous tanpa membekukan UI.
Namun, bagaimana jika aplikasi membutuhkan aliran data yang terus-menerus berubah?

Misalnya:

• Aplikasi cuaca yang update setiap beberapa detik.

• Aplikasi chat yang menerima pesan real-time.

• Aplikasi e-commerce yang memantau harga atau stok barang.

Untuk kasus seperti itu, Kotlin Flow adalah jawabannya.

Apa Itu Kotlin Flow?

Flow adalah API di Kotlin yang digunakan untuk menangani stream of data secara asynchronous dan reaktif.

Bayangkan Flow seperti pipa air: data akan mengalir sedikit demi sedikit (bukan sekaligus), dan kita bisa memproses aliran itu dengan mudah.

📌 Dengan Flow, kamu bisa:

• Menerima data yang terus berubah secara real-time.

• Menggunakan coroutine di belakang layar.

• Memproses data dengan operator fungsional (map, filter, collect).

Perbedaan Flow vs Coroutines

Fitur	Coroutines	Flow
Eksekusi	Satu kali task asynchronous	Data stream (bisa berkali-kali)
Hasil	Return tunggal (1 data)	Bisa menghasilkan banyak data
Contoh kasus	Fetch API sekali	Chat, sensor, event listener

Cara Menggunakan Kotlin Flow

1. Tambahkan Dependency

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")

---

2. Membuat Flow

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(1000L)
        emit(i) // mengirim data ke collector
    }
}

fun main() = runBlocking {
    simpleFlow().collect { value ->
        println("Dapat data: $value")
    }
}

📌 emit() = mengirim data ke collector.
📌 collect {} = menerima data dari flow.

---

3. Menggunakan Operator Flow

Flow mendukung banyak operator mirip Stream di Java.

fun main() = runBlocking {
    (1..10).asFlow()
        .filter { it % 2 == 0 }
        .map { "Angka genap: $it" }
        .collect { println(it) }
}

📌 Dengan filter + map, kita bisa memproses data sebelum dikirim.

---

4. Flow di Android dengan LiveData

Contoh penggunaan Flow untuk update UI secara real-time:

class MainViewModel : ViewModel() {
    private val _dataFlow = MutableStateFlow("Loading...")
    val dataFlow: StateFlow<String> = _dataFlow

    fun loadData() {
        viewModelScope.launch {
            repeat(5) {
                delay(1000L)
                _dataFlow.value = "Update ke-${it + 1}"
            }
        }
    }
}

Di Activity atau Fragment:

lifecycleScope.launch {
    viewModel.dataFlow.collect { data ->
        textView.text = data
    }
}

📌 StateFlow = cocok untuk data yang selalu punya nilai terkini.
📌 SharedFlow = cocok untuk event seperti notifikasi.

---

Contoh Kasus Nyata

1. Chat Real-Time

fun chatFlow(): Flow<String> = flow {
    val messages = listOf("Hai!", "Apa kabar?", "Lagi ngoding Kotlin Flow?")
    for (msg in messages) {
        delay(1500L)
        emit(msg)
    }
}

Collector:

chatFlow().collect { println("Pesan masuk: $it") }

---

2. Sensor / IoT

fun sensorFlow(): Flow<Float> = flow {
    while (true) {
        val suhu = (30..35).random() + Math.random().toFloat()
        emit(suhu)
        delay(2000L)
    }
}

Collector:

sensorFlow().collect { println("Suhu: $it °C") }

Manfaat Kotlin Flow

1. Mendukung data real-time → cocok untuk aplikasi modern.

2. Asynchronous → berbasis coroutine, efisien dan ringan.

3. Fungsional → operator map, filter, reduce.

4. Integrasi Android → bekerja dengan ViewModel, LiveData, StateFlow.

5. Lebih mudah dari RxJava → sintaks lebih sederhana, bawaan Kotlin.

Tips Menggunakan Kotlin Flow

• Gunakan StateFlow untuk data UI yang selalu update.

• Gunakan SharedFlow untuk event satu kali (contoh: snackbar).

• Selalu gunakan lifecycleScope atau viewModelScope di Android.

• Hindari GlobalScope karena bisa menyebabkan memory leak.

• Gabungkan catch {} untuk menangani error.

Contoh error handling:

simpleFlow()
    .catch { e -> println("Error: $e") }
    .collect { println("Data: $it") }

Rekomendasi Belajar Selanjutnya

• Part 17: Advanced Flow (buffer, debounce, zip, combine).

• Part 18: Integrasi Flow dengan Room Database.

Kesimpulan

Di Part 16, kita belajar bahwa Kotlin Flow adalah solusi elegan untuk menangani aliran data asynchronous.
Dengan Flow, aplikasi bisa:

• Mengambil data secara real-time.

• Memproses data dengan operator fungsional.

• Lebih ringan dan mudah dibanding RxJava.

👉 Setelah menguasai Coroutines (Part 15) dan Flow (Part 16), kemampuan asynchronous Kotlin kamu sudah naik level.
Selanjutnya di Part 17, kita akan mendalami Advanced Flow seperti buffer, debounce, zip, dan combine untuk data yang lebih kompleks.