Flow: Operator for action on successful completion

[xizzhu]

According to the doc, the onCompletion() "operator is transparent to exceptions that occur in downstream flow and does not observe exceptions that are thrown to cancel the flow".

If I want to do something only when the flow is "successfully completed" (i.e. no exception, not cancelled), how can I do that? Thanks.

It can be reproduced with the following code:

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun foo(): Flow<Int> = flow {
    var i = 0
    while (true) {
        emit(i++)
        delay(100)
    }
}

suspend fun main() {
    val job = GlobalScope.launch {
        foo().onEach { println("onEach: $it")}
            .onCompletion {
                println("onCompletion: $it")
            }
            .collect()
    }
    
    delay(500)
    println("after delay()")
    job.cancel()
    
    delay(100)
    println("after second delay()")
}

[circusmagnus]

But your flow will never successfully complete. It does not stop emitting unless canceled

fun foo(): Flow<Int> = flow {
    var i = 0
    while (true) {
        emit(i++)
        delay(100)
    }
}

If it had finite number of emissions, you could simply write your code after last call to emit():

fun foo(): Flow<Int> = flow {
   repeat(10) { 
      emit(whatever) // just emit values you wanted to emit
   }
   doSomethingAfterFlowEmittedAllValues() // will happen, after all emissions have been dealt with.
}

You can also easily write your own operator to do this further downstream:

Flow<T>.doAfterLast(action: () -> Unit): Flow<T> = flow {
   collect { value -> emit(value) } // just pass upstream values through
   action() // will happen, after all upstream values have been dealt with.
}

Or you can do this simply after final call to collect{}:

launch {
   someFlow.collect { ... } // collect flow as usual
   doSomething() // will happen after everything has been collected
}

In all cases, those actions will only be executed, if flow has been successfully collected (not canceled, not failed on exception).

[elizarov]

@xizzhu In addition to the above comment (you can easily write your own operator for that), I would really like to know why you need that. What is your use-case? Why would you need an operator for successful (non-cancelled) completion?

[xizzhu]

Thanks @circusmagnus for the suggestion!

@elizarov I have a flow that downloads from a server, and emits the downloading progress. When the downloading finishes (not-cancelled), I want to show a toast to inform the user. Is the suggestion to put the "doAfterLastEmit" action directly after collect()?