Belajar Kotlin Part 17: Advanced Kotlin Flow (Buffer, Debounce, Zip, Combine)

Pelajari Kotlin Flow tingkat lanjut: buffer, debounce, zip, dan combine untuk aplikasi Android yang efisien dan responsif.

Pendahuluan

Di Part 16, kita sudah belajar dasar Kotlin Flow untuk menangani aliran data asynchronous.
Namun, di dunia nyata, aliran data sering lebih kompleks.

Contoh kasus:

• Input pencarian user (butuh debounce agar tidak spam API).

• Menggabungkan data dari dua sumber (zip dan combine).

• Mengatur kecepatan aliran data dengan buffer.

Itulah sebabnya kita perlu Advanced Flow.

---

⚡ Buffer: Menyimpan Data Sementara

Tanpa Buffer

fun flowTanpaBuffer() = flow {
    repeat(3) {
        delay(100L) // kirim data
        emit(it)
    }
}

fun main() = runBlocking {
    flowTanpaBuffer().collect {
        delay(300L) // lambat menerima
        println("Data: $it")
    }
}

Output:

Data: 0 (≈400 ms)
Data: 1 (≈800 ms)
Data: 2 (≈1200 ms)

📌 Karena collector lambat, aliran jadi ikut lambat.

---

Dengan Buffer

fun main() = runBlocking {
    flowTanpaBuffer()
        .buffer() // pisahkan kecepatan producer & consumer
        .collect {
            delay(300L)
            println("Data: $it")
        }
}

Output lebih cepat, karena producer tetap jalan meski consumer lambat.

📌 Gunakan buffer() untuk meningkatkan performa aplikasi real-time.

Debounce: Menunggu Input Stabil

Kasus: user mengetik pencarian.
Tanpa debounce → API dipanggil setiap karakter → boros!

Contoh Debounce

fun main() = runBlocking {
    flow {
        emit("K")
        delay(100)
        emit("Ko")
        delay(100)
        emit("Kot")
        delay(400)
        emit("Kotlin") // berhenti mengetik
    }
    .debounce(300)
    .collect { println("Cari: $it") }
}

Output:

Cari: Kot
Cari: Kotlin

📌 debounce(300) menunggu 300 ms sebelum mengirim data terakhir.

Zip: Gabungkan Dua Flow Secara Berpasangan

Contoh Zip

fun main() = runBlocking {
    val flow1 = (1..3).asFlow().onEach { delay(100L) }
    val flow2 = flowOf("A", "B", "C").onEach { delay(200L) }

    flow1.zip(flow2) { num, str -> "$num -> $str" }
        .collect { println(it) }
}

Output:

1 -> A
2 -> B
3 -> C

📌 zip = hasil sesuai pasangan (1 ke A, 2 ke B, dst).

Combine: Gabungkan Dua Flow Real-Time

Contoh Combine

fun main() = runBlocking {
    val angka = (1..3).asFlow().onEach { delay(300L) }
    val huruf = flowOf("X", "Y", "Z").onEach { delay(400L) }

    angka.combine(huruf) { num, str -> "$num + $str" }
        .collect { println(it) }
}

Output (real-time update):

1 + X
2 + X
2 + Y
3 + Y
3 + Z

📌 combine = update terus berdasarkan nilai terbaru dari kedua flow.

Contoh Kasus Nyata di Android

1. Search Box dengan Debounce

fun searchFlow(queryFlow: Flow<String>): Flow<List<String>> {
    return queryFlow
        .debounce(300)
        .filter { it.isNotEmpty() }
        .map { query -> fetchResult(query) }
}

📌 API hanya dipanggil saat user berhenti mengetik.

---

2. Sensor + GPS (Combine)

val gpsFlow = flow {
    emit("Lat: -6.2, Lon: 106.8")
    delay(1000)
    emit("Lat: -6.3, Lon: 106.9")
}

val sensorFlow = flow {
    emit("Suhu: 32°C")
    delay(2000)
    emit("Suhu: 33°C")
}

fun main() = runBlocking {
    gpsFlow.combine(sensorFlow) { gps, suhu -> "$gps | $suhu" }
        .collect { println(it) }
}

Output:

Lat: -6.2, Lon: 106.8 | Suhu: 32°C
Lat: -6.3, Lon: 106.9 | Suhu: 32°C
Lat: -6.3, Lon: 106.9 | Suhu: 33°C

📌 Cocok untuk aplikasi IoT, kesehatan, atau peta real-time.

Manfaat Advanced Flow

1. Buffer → percepat stream dengan memisahkan producer & consumer.

2. Debounce → hemat API call, cocok untuk search bar.

3. Zip → gabungkan dua flow secara berpasangan.

4. Combine → sinkronisasi data real-time.

5. Lebih efisien → UI tetap responsif meski data kompleks.

Tips

• Gunakan debounce untuk search input.

• Gunakan buffer jika collector lambat.

• Gunakan combine untuk aplikasi real-time multi-sumber.

• Gunakan zip jika data harus berpasangan.

• Tambahkan catch {} untuk error handling.

Kesimpulan

Di Part 17, kita sudah membahas Advanced Kotlin Flow:

✅ Buffer untuk performa.
✅ Debounce untuk pencarian efisien.
✅ Zip untuk data berpasangan.
✅ Combine untuk sinkronisasi real-time.

👉 Selanjutnya di Part 18, kita akan belajar Integrasi Kotlin Flow dengan Room Database untuk aplikasi Android yang menyimpan data lokal secara reaktif.