The document presents an overview of Kotlin's Flow, detailing its operation flow, types of functions/operators, and various builders and collectors. It includes examples for creating and manipulating asynchronous data streams and covers aspects like intermediate and terminal operations. Additionally, it touches on cold vs hot flows, testing methodologies, and resources related to Kotlin Flow.

1. In the name of God
Operation Flow

2. I am
Seyed Jafari
Senior Software Engineer @ Revolut Ltd
worldsnas.com @worldsnas

3. My sincere condolences on the occasion of
Imam Hussain Arbaeen

4. What is Flow
Docs: An asynchronous data stream that
sequentially emits values and completes
normally or with an exception.

5. Everything is a stream
Image from reactiveStreams:
https://gist.github.com/staltz/868e7e9bc2a7b8c1f754

6. val myFlow = flowOf("1")

7. val myFlow = flowOf("1")
myFlow.collect {
println(it)
}

8. suspend fun run() {}
CoroutineScope
scope.launch {
run()
}
Coroutines

9. Flow functions/operator types
● Builders/Creators
● Intermediate
● Terminal

10. 1. Builders/Creators

11. 1. Builders/Creators
● flowOf<String>(“first”)
● emptyFlow<String>()
● flow<String> {}
● callbackFlow<String> {}
● channelFlow<String> {}
● listOf<String>().asFlow()
● listOf<Flow<String>>().merge()

12. channelFlow<String> {} / callbackFlow<String> {}
callbackFlow<String> {
val listener : object : Listener{
override fun onSuccess(value : String){
sendBlocking(value)
channel.close()
}
}
locationManager.register(listener)
awaitClose {
locationManager.unRegister(listener)
}
}

13. 2. Intermediate

14. 2. Intermediate
flowOf("1")
.filter { it.isNotBlank() }
.withIndex()
.map { it.value }
.drop(1)
.take(1)
.buffer(10)
.debounce(10000)
.distinctUntilChanged()
.onStart { }
.onEach { }
.onCompletion { }
.onEmpty { }
.catch { }
.retry(1)
.flowOn()
.transform<String, String> { }
.zip(flowOf("")) { s, s2 -> s }
.combine(flowOf("")) { a: String , b: String -> "" }
.flatMapMerge<String, String> { value -> flowOf(value) }
.flatMapConcat { value -> flowOf(value) }
.flatMapLatest { flowOf(it) }
.scan("") { accumulator: String , value: String -> accumulator + value }
.runningReduce { accumulator , value -> "" }

15. Intermediates - part 1

16. ● flowOf("1", "", "2").filter { it.isNotBlank() } // "1", "2"
● flowOf(1, 2).map { "$it" } // "1", "2"
● flowOf("first", "second").withIndex()
// "index= 0, value= first", "index=1, value= second"
● flowOf(1, 2, 3).drop(1) // 2, 3
● flowOf(1, 2, 3).take(1) // 1
● flowOf(1, 1, 1, 2, 1, 3).distinctUntilChanged()
// 1, 2, 1, 3

17. flowOf(1, 2, 3)
.onEach { println("onEach= $it") }
.buffer(10, BufferOverflow.SUSPEND)
.collect {
delay(1000)
println("collected= $it")
}
// onEach= 1, onEach= 2, onEach= 3, collected= 1, collected= 2,
collected= 3

18. flow {
emit(1)
delay(50)
emit(2)
delay(150)
emit(3)
}.debounce(100)
// 2, 3

19. Intermediates - part 2

20. flowOf(1, 2, 3)
.onStart { emit(4) }
.onStart { emit(5) }
//5, 4, 1, 2, 3

21. flowOf(1, 2, 3).onEach {
println(it)
delay(1000)
}
// 1, 2, 3
flowOf<Int>(1, 2,).filter{ it > 5 }.onEmpty {
emitAll(flowOf(1, 2, 3))
}
//1, 2, 3

22. flowOf(1, 2, 3).onCompletion { throwable ->
if (throwable == null) {
// normal cancellation
emit(4)
}else{
// exception occurred
// we can not emit anymore
}
}
// 1, 2, 3, 4

23. flow<Int> {
throw IllegalStateException("cancel the flow")
}
.retryWhen { cause, attempt ->
attempt < 3
}
.catch { throwable ->
emit(1)
}
// 1,

24. Intermediates - part 3

25. flowOf(1, 2, 3)
.flowOn(Dispatchers.Default)
.onEach { }
.flowOn(Dispatchers.IO)
// 1, 2, 3

26. Intermediates - part 4

27. flowOf("first", "", "second")
.transform {
if(it.isEmpty()) return@transform
val newItems = api.search(it)
emit(newItems)
}
fun Flow<T>.transform(transform: suspend
FlowCollector<R>.(value: T) -> Unit
): Flow<R> = flow {
collect { value ->
return@collect transform(value)}}

28. api1.get().zip(api2.get()) { f: Response1, s: Response2 ->
f + s
}
api.fetchBookList()
.combine(queryNameFlow){books: List<Book>, s: String ->
books.filter { it.name.contains(s) }
}

29. flatMap*
● flatMapMerge
● flatMapConcat
● flatMapLatest

30. flowOf(1, 2, 3).flatMapMerge { value ->
flow {
emit("a$value")
delay(Random.nextLong(1000))
emit("b$value")
}
}
// a1, a2, a3, ?

31. flowOf(1, 2, 3).flatMapConcat { value ->
flow {
emit("a$value")
delay(Random.nextLong(1000))
emit("b$value")
}
}
// a1, b1, a2, b2,

32. userGenerateQuery.flatMapLatest { query ->
localDataBase.observeForQuery(query)
}
flowOf(1, 2, 3).flatMapLatest { value ->
flow {
delay(50)
emit("a$value")
delay(Random.nextLong(1000))
emit("b$value")
}
}
// a3, b3

33. Intermediates - part 5

34. Reducers
● runningReduce
● scan

35. flowOf(1, 2, 3)
.runningReduce { accumulator, value ->
accumulator * value
}
// 1, 2, 6
resultFlow
.scan(InitialState) { lastState, newResult ->
lastState.createNewStateForResult(newResult)
}

36. 3. Terminals

37. 3. Terminals
● flowOf(1, 2, 3).collect { }
● flowOf(1, 2, 3).collectIndexed { index, value -> }
● flowOf(1, 2, 3).launchIn(scope)
● flowOf(1, 2, 3).toList()
● flowOf(1, 3, 3).toSet()
● flowOf(1, 2, 3).single()
● flowOf(1, 2, 3).first()
● flowOf(1, 2, 3).reduce { acc, value -> acc + value }
● flowOf(1, 2, 3).fold("") { acc, value -> acc + value }

38. Collectors
● flowOf(1, 2, 3).collect { } // 1, 2, 3
● flowOf(1, 2, 3).collectIndexed { index, value->
} // 0:1, 1:2, 2:3
● flowOf(1, 2, 3).launchIn(scope)

39. Collections
● flowOf(1, 2, 3).toList() // [1, 2, 3]
● flowOf(1, 3, 3).toSet() // [1, 3]

40. Firsty
● flowOf(1, 2, 3).single() // throws IllegalStateException
● flowOf(1, 2, 3).first() // 1

41. Reducers
● flowOf(1, 2, 3).reduce { acc, value ->
acc + value
} //6
● flowOf(1, 2, 3).fold("") { acc, value ->
acc + value
} //"123"

42. Cold vs Hot flow

43. Rowing vs Car Engine

44. Entering hot flows
● (Mutable)SharedFlow
● (Mutable)StateFlow

45. SharedFlow Builders
● MutableSharedFlow<String>()
● socketFlow.shareIn(scope, SharingStarted.Eagerly)
SharedFlow Emitters
● scope.launch{ mutableSharedFlow.emit() }
● mutableSharedFlow.tryEmit()

46. StateFlow Builders
● MutableStateFlow<Int>(0)
● flowOfStates.stateIn(scope)
StateFlow Emitters
● scope.launch{ mutableSharedFlow.emit() }
● mutableSharedFlow.tryEmit()
● mutableSharedFlow.value = newValue

47. Testing
@Test
fun test() = runBlocking {
val events = flowOf(1, 2, 3).toList()
assert(events)
}

48. Turbine
@Test
fun hotFlowTest() = runBlocking {
val sharedFlow = MutableSharedFlow<Int>()
sharedFlow.test {
sharedFlow.emit(1)
assert(expectItem())
cancelAndIgnoreRemainingEvents()
}}

49. OSS projects
1. Reyan: https://github.com/islamversity/Reyan
2. FlowMarbles: https://flowmarbles.com

50. 🎇 Operation successful 🎇
Happy Flowing,
Kotlin Slack
@worldsnas
Thanks
We are actively hiring in wide range of positions.
make sure to checkout our openings on:
https://www.revolut.com/careers