Introduction to Kotlin Flow API

Published in

Appcent

3 min readDec 18, 2023

Kotlin Flow is a library focused on reactive and asynchronous programming. This library provides a set of tools and structures to manage and process the flow of data. In this article, we will explore how to effectively handle data flow using Kotlin Flow.

What is the Flow?

Flow can be summarized as an asynchronous stream where a sequence of values is produced and consumed sequentially. In Flow, the published data must be of the same type.

To use Flow, three fundamental components are required:

Producer: Generates data and sends it to the stream asynchronously.
(Optional) Operators: Can process or modify the values in the stream.
Consumer: Consumes the data in the stream.

Some advantages of Flow:

Concurrent asynchronous operations: Performing multiple asynchronous operations simultaneously.
Operations on the flow with operator functions: Filtering, transforming and other operations on the flow using operator functions.
Lightweight and high performance: Flow has a lightweight structure and offers high performance.
Integration with Kotlin Coroutines: Flow integrates seamlessly with Kotlin coroutines.

Creating a Flow (Producer)

To create a Flow, we use the flow function. We provide a data flow to the stream using the emit function in the FlowCollector.

In the example below, the flow adds consecutive numbers from 0 to 5 to the stream with a 1-second delay.

val flow = flow {
        (0..5).forEach {
            emit(it)
            delay(1000)
        }
    }

flowOf()

Creates a flow and sequentially adds the given dataset to the flow using the emit function.

val flow = flowOf(1, 2, 3, 4, 5)

asFlow()

An extension function that converts arrays and lists into a Flow, adding the elements from the list to the Flow sequentially.

val flow = listOf(1,2,3,4,5).asFlow()

Modifying Flow

Data in the Flow can be processed with intermediate operators before being collected by consumers. In the example below, the map operator is used to calculate the squares of expressions in the Flow.

val producer = flow {
    (0..5).forEach {
        emit(it)
    }
}.map {
    it * it
}

Intermediate operators can be used consecutively, and these intermediate operators do not initiate the collection.

val producer = flow {
    (0..5).forEach {
        emit(it)
    }
}.map {
    it * it
}.filter { 
    it % 2 == 0
}

Collecting Data

Data in a Flow can be collected using the collect function. However, since collect is a suspend function, this operation needs to be performed within a CoroutineScope. In the example below, the flow adds numbers from 0 to 3 to the stream every 1 second, and in the block below, these data in the flow are collected using the collect function.

val producer = flow {
    (0..3).forEach {
        emit(it)
        delay(1000)
    }
}.map {
    it * it
}

runBlocking { 
    producer.collect { number ->
        println(number)
    }
}

Flows have different types based on usage scenarios. Some of the most well-known types are:

Cold Flow: Each consumer starts collecting from the beginning of the stream.
Hot Flow: Each consumer starts collecting from the point where the stream continues. It cannot access past values.
StateFlow: It is similar to LiveData in structure. It does not emit the same value consecutively.
SharedFlow: It can have multiple consumers, broadcasting the same data to these subscribers simultaneously. However, it does not broadcast the same value to each consumer more than once.
ChannelFlow: It falls into the Hot Flow category and does not store data, resembling an outlet of a channel.