꿈 많은 개발자가 되자 - Taehwan

이 글은 2025 안드로이드 탐구 영역에 나온 문제 중 flow와 관련한 문제를 해석한 글이다.
안드로이드 탐구 영역 후기 글
(😨 오류 정정) 🤔 2025년도에도 개발자들은 코루틴 예외 처리 때문에 밤샘각? 😨 (2025학년도 안드로이드 탐구영역 문제풀이) - link
2025학년도 안드로이드 탐구영역 - link
2025학년도 안드로이드 탐구영역을 준비하며(경완님 작성) - link
무슨 문제인가?
코루틴 flow에 대한 문제가 크게 2문제가 있었다. 이 중 코루틴 영역에 포함한 1개의 문제를 살펴보려 한다.
이 문제는 StateFlow와 flow {}를 복합적으로 사용하는 문제이다.
이 문제에 나오는 Flow에 대한 내용은 이전에 필자의 블로그에 작성했던 다양한 글이 있으니 링크를 추가한다.
Callback으로 받은 데이터를 Coroutines에서 활용하는 방법! Flow 활용 - link
Callback으로 전달받은 데이터를 Coroutines의 Channel로 처리해보자. - link
이 글에서는
2025 안드로이드 탐구 영역에 나온 문제 일부를 정리한다.
Coroutiens flow에 대한 이해가 필요하다.
문제를 살펴보자
아래가 문제에서 나온 전체 코드이다.(Test 부분은 수정)
@Test
fun test() = runTest {
    val stateFlow = MutableStateFlow(1)
    val flow = flow {
        emit(1)
        delay(1_000L)
        emit(2)
        delay(1_000L)
        emit(3)
    }
        .flatMapLatest { value ->
            stateFlow
                .map {
                    value + it
                }
        }
    launch {
        delay(999L)
        stateFlow.emit(2)
        delay(999L)
        stateFlow.emit(3)
    }
    flow
        .collect { value -> println("value: $value") }
}
이 문제에서는 1 개의 StateFlow와 1 개의 flow {}를 초기화하고, flow 다음에 flatMapLatest를 사용하여 StateFlow를 통해 새로운 흐름을 만드는 문제이다.
flatMapLatest는 무엇인가?
flatMapLatest - link의 함수 원형은 아래와 같다.
@ExperimentalCoroutinesApi
public inline fun <T, R> Flow<T>.flatMapLatest(@BuilderInference crossinline transform: suspend (value: T) -> Flow<R>): Flow<R> =
    transformLatest { emitAll(transform(it)) }
문서의 설명 그대로를 가져오면
Returns a flow that switches to a new flow produced by transform function every time the original flow emits a value. When the original flow emits a new value, the previous flow produced by transform block is cancelled.
제미나이에게 해석을 요청한 부분은 다음과 같다.
이 코드는 원본 flow가 값을 내보낼 때마다 transform 함수에 의해 생성된 새로운 flow로 전환하는 flow를 반환합니다.
좀 더 자세히 설명하면,
flow는 코루틴에서 비동기적으로 데이터를 처리하는 데 사용되는 자료 구조입니다. 마치 시간에 따라 값을 내보내는 스트림과 같습니다.
transform은 flow의 각 값을 변환하는 함수입니다. 이 함수는 새로운 flow를 생성할 수도 있습니다.
flatMapLatest는 flow의 각 값에 대해 transform 함수를 호출하여 새로운 flow를 생성하고, 이 flow들의 값을 순차적으로 내보내는 연산자입니다.
중요한 점은, 원본 flow가 새로운 값을 내보낼 때마다 이전에 transform 함수에 의해 생성된 flow는 취소된다는 것입니다. 즉, 항상 최신 값에 대한 flow만 활성화됩니다.
예를 들어, 사용자가 검색어를 입력할 때마다 검색 결과를 가져오는 flow가 있다고 가정해 보겠습니다. flatMapLatest를 사용하면 사용자가 새로운 검색어를 입력할 때마다 이전 검색 결과에 대한 flow는 취소되고 새로운 검색어에 대한 flow가 생성됩니다.
이러한 방식은 최신 값만 처리해야 하는 경우에 유용합니다. 예를 들어, 사용자 인터페이스에서 최신 데이터만 표시해야 하는 경우 flatMapLatest를 사용하면 불필요한 작업을 방지하고 성능을 향상시킬 수 있습니다.
여기서 마지막의 cancel 부분이 궁금하여 상세 코드를 좀 더 살펴보았는데, collect {} 처리 후 apply 부분에서 cancel()과 join()을 처리하고 있음을 알 수 있는데, 항상 최신의 값만을 흘려보냄을 코드로 알 수 있다.
internal class ChannelFlowTransformLatest<T, R>(
    private val transform: suspend FlowCollector<R>.(value: T) -> Unit,
    flow: Flow<T>,
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = Channel.BUFFERED,
    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND
) : ChannelFlowOperator<T, R>(flow, context, capacity, onBufferOverflow) {
    override fun create(context: CoroutineContext, capacity: Int, onBufferOverflow: BufferOverflow): ChannelFlow<R> =
        ChannelFlowTransformLatest(transform, flow, context, capacity, onBufferOverflow)
    override suspend fun flowCollect(collector: FlowCollector<R>) {
        assert { collector is SendingCollector } // So cancellation behaviour is not leaking into the downstream
        coroutineScope {
            var previousFlow: Job? = null
            flow.collect { value ->
                previousFlow?.apply { // 이 부분
                    cancel(ChildCancelledException())
                    join()
                }
                // Do not pay for dispatch here, it's never necessary
                previousFlow = launch(start = CoroutineStart.UNDISPATCHED) {
                    collector.transform(value)
                }
            }
        }
    }
}
결국 flatMapLatest를 사용하면 2 개의 flow 흐름을 합칠 수 있으며, 이전 흐름의 데이터는 언제나 최신 데이터 흐름을 사용함을 알 수 있다.
돌아가서
MutableStateFlow는 가장 마지막 최신 데이터 1 개를 사용할 수 있는 상태를 저장하기 위한 용도이며, HotFlow이다. 언제나 최신 데이터만을 가진다.
반대로 flow는 구독하기 전에는 동작하지 않는 ColdFlow에 속한다.
Kotlin Coroutines Flow의 Cold/Hot flow(Stream)의 데이터 흐름(Data flow) 이해해 보기 - link
val stateFlow = MutableStateFlow(1)
val flow = flow {
    emit(1)
    delay(1_000L)
    emit(2)
    delay(1_000L)
    emit(3)
}
    .flatMapLatest { value ->
        stateFlow
            .map {
                value + it
            }
    }
그럼 이 코드에서의 구독 시점은 이어서 나오는 코드에서 알 수 있는데, launch {}를 실행하고 나서 바로 collect를 하고 있음을 알 수 있다.
launch {
    delay(999L)
    stateFlow.emit(2)
    delay(999L)
    stateFlow.emit(3)
}
flow
    .collect { value -> println("value: $value") }
구독한 데이터의 순서
이 문제는 테스트가 가능하고, 이해할 수 있는 형태로 제공해야 해서 delay를 명확하게 제공해 주고 있다.
구독이 시작되면 emit(1)을 시작하고, 1초의 대기가 걸린다. 그럼 StateFlow의 1과 emit 1을 합산하여 2 출력, 이어서 999ms 후에 stateFlow에 2를 전달하였으므로 1+2의 결과 3을 출력한다.
이후의 결과를 통합하면 2, 3, 4, 5, 6이 순차로 출력된다.
이 문제의 답은
사실 위 코드를 해석할 필요도 없는 간단한 문제이다.
StateFlow에 emit(2)를 하면 flow {} emit(1)부터 다시 발행되어진다. 라는 부분이다.
flatMapLatest에 걸어둔 StateFlow에 값을 넘기더라도 flow {}  부터 실행한다는 건 일어날 수 없다. 하지만 exception이 발생하고, retry를 걸었다면 flow {}부터 실행할 수 있다.
retry 위치가 매우 중요한데, 이전에 작성한 글의 최하단 시나리오 2 번 부분을 살펴보길
Kotlin Coroutines Flow의 Cold/Hot flow(Stream)의 데이터 흐름(Data flow) 이해해 보기 - link
StateFlow가 아니라 SharedFlow를 함께 사용하면?
문제를 조금 바꿔 StateFlow 대신 SharedFlow를 사용한다면 코드의 동작은 어떻게 될까?
@Test
fun test() = runTest {
    val sharedFlow = MutableSharedFlow<Int>()
    val flow = flow {
        emit(1)
        delay(1_000L)
        emit(2)
        delay(1_000L)
        emit(3)
    }
        .flatMapLatest { value ->
            sharedFlow
                .map {
                    value + it
                }
        }
    launch {
        delay(999L)
        sharedFlow.emit(2)
        delay(999L)
        sharedFlow.emit(3)
    }
    flow
        .collect { value -> println("value: $value") }
}
이 코드의 응답은 확연하게 달라지는데 3, 5 만이 출력된다.
SharedFlow는 replay를 하지 않기 때문에 값이 오기 전에는 반응 자체를 하지 않기 때문이다.
그래서 이 코드는
emit(1)을 하더라도 println하지 않고 sharedFlow에 2가 들어와야 만 1+2하여 3이 출력된다.
StateFlow, SharedFlow, flow를 셋 다 합성한다면?
merge, combine, zip을 활용하는 것이 아니라 MutableStateFlow를 하나 더 추가하고 flatMapLatest를 하나 더 추가하여 활용하는 경우를 아래와 같이 추가해 보았다.
@Test
fun test() = runTest {
    val sharedFlow = MutableSharedFlow<Int>()
    val stateFlow = MutableStateFlow(false)
    val flow = flow {
        emit(1)
        delay(1_000L)
        emit(2)
        delay(1_000L)
        emit(3)
    }
        .flatMapLatest { value ->
            sharedFlow
                .map {
                    value + it
                }
        }
        .flatMapLatest { // 여기에 추가
            stateFlow
                .filter { it }
        }
    launch {
        delay(999L)
        sharedFlow.emit(2)
        delay(999L)
        sharedFlow.emit(3)
        stateFlow.value = true // 여기에 추가
    }
    flow
        .collect { value -> println("value: $value") }
}
이 코드는 앞에 코드보다 더 쉽게 딱 한 번의 값만이 출력되는데, 이 값은 true이다.
왜 true인지는 flatMapLatest를 이해한다면 매우 쉽게 알 수 있다.
마무리
이전에 작성한 글 보다 flow가 더 쉽게 느껴질 수 있다. Job()을 이해하는 부분이 더 명확하기 때문이기도 하고, flow는 1개로 해석할 수 있지만 launch {}는 launch 안에 launch를 사용할 수도 있기 때문이다.
가능하다면 아래와 같은 형태는 지향하는 편이 모두가 이해하기 쉬운데 이렇게 활용하는 경우도 사실 많진 않긴 하다.
launch {
    launch {
        launch {
            // ...
        }
    }
}
flow는 하나의 흐름만을 이해하면 되는데 그 사이에 값의 흐름이 A to B로 바뀌는 흐름만 이해하면 해석이 쉬워지기 때문이다.

😱 2025 안드로이드 탐구영역, Coroutines Flow 때문에?! (feat. 쉬운 해설)

댓글