Practical Examples of Kotlin Flow

Understanding Kotlin Flow

Kotlin Flow is a powerful API that allows developers to handle asynchronous data streams in a structured way. It provides a way to transmit a sequence of values over time, making it ideal for use cases that involve streams of data like network requests, database queries, or UI updates. In this article, we will explore three diverse examples of Kotlin Flow that highlight its practical applications.

Example 1: Basic Flow to Emit Values

Use Case

In this example, we will create a simple flow that emits a sequence of integers. This is useful for understanding the fundamentals of how flows work in Kotlin.

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.runBlocking

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..5) {
        emit(i)  // Emit the next value
        delay(100) // Simulate some asynchronous work
    }
}

fun main() = runBlocking {
    simpleFlow().collect { value ->
        println(value) // Collect and print each emitted value
    }
}

Notes

• The flow builder is used to create a flow and the emit function is called to send values to the collector.
• The delay function simulates asynchronous work (like a network request).

Example 2: Flow with Transformations

Use Case

In this example, we will demonstrate how to transform emitted values using the map operator. This can be particularly useful when processing data before it gets to the UI.

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.runBlocking

fun numberFlow(): Flow<Int> = flow {
    for (i in 1..5) {
        emit(i)
        delay(100)
    }
}

fun main() = runBlocking {
    numberFlow()
        .map { it * it } // Transform each emitted value to its square
        .collect { value ->
            println(value) // Collect and print the transformed value
        }
}

Notes

• The map operator allows you to apply a transformation to each value emitted by the flow.
• This pattern is commonly used when you need to format or modify data before displaying it.

Example 3: Combining Multiple Flows

Use Case

Here, we will combine two flows using the combine operator. This is useful when you want to aggregate data from multiple sources, such as user input and network responses.

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.delay

fun flowA(): Flow<Int> = flow {
    for (i in 1..5) {
        emit(i)
        delay(200)
    }
}

fun flowB(): Flow<String> = flow {
    val messages = listOf("A", "B", "C", "D", "E")
    for (message in messages) {
        emit(message)
        delay(300)
    }
}

fun main() = runBlocking {
    combine(flowA(), flowB()) { number, message ->
        "Number: \(number, Message: \)message"
    }.collect { combinedValue ->
        println(combinedValue)
    }
}

Notes

• The combine operator merges the latest values emitted by both flows and allows you to create a combined result.
• This approach is particularly useful in scenarios where you need to synchronize data from different sources.