Goal

I have a computation heavy function calculateItems: suspend (String) -> Sequence<String>.

I want to load the outputs of this calculation while showing the progress to the user and keeping the UI responsive. I also want to cancel this calculation in case the user input changes, and start again once the user clicks a button.

Approach

I use produceState. Inside produceState, I delegate this computation to a non-Main-dispatcher in order to keep the UI responsive. I also collect the items emitted from that sequence and update the progress on each received item.

val totalSize = 255 // for sake of this example
var input by rememberSaveable(stateSaver = TextFieldValue.Saver) {
    mutableStateOf(TextFieldValue("Test Input"))
}
var doCalculation by rememberSaveable(input) {
    mutableStateOf(false)
}
val resultState by produceState(
    State.Null as State,
    input,
    doCalculation,
) {
    value = DealingState.Null
    if (!doCalculation) {
        value = DealingState.Null
        return@produceState
    }

    value = DealingState.Loading(
        progress = 0,
        required = totalSize,
    )

    launch(Dispatchers.Default) {
        runCatching {
            val resultList = mutableListOf<String>()
            calculateItems(input).forEach {
                resultList.add(it)
                value = State.Loading(
                    progress = resultList.size,
                    required = totalSize,
                )
            }
            value = State.Success(resultList)
        }.getOrElse {
            value = State.Failure(it)
        }
    }
}

What I Tried

I tried the following things:

• define a coroutine scope specifically for this routine and call scope.cancel() when a new state is to be produced.

val scope = CoroutineScope(Dispatchers.Default)
val resultState by produceState(...) {
    scope.cancel()
    ....
    scope.launch(Dispatchers.Default) {...}
}

• store the job from launch and cancel the job or the children

var job: Job? = null
val resultState by produceState(...) {
    job?.cancel() // and job?.cancelChildren()
    ....
    job = launch(Dispatchers.Default) {...}
}

Goal

I have a computation heavy function calculateItems: suspend (String) -> Sequence<String>.

I want to load the outputs of this calculation while showing the progress to the user and keeping the UI responsive. I also want to cancel this calculation in case the user input changes, and start again once the user clicks a button.

Approach

I use produceState. Inside produceState, I delegate this computation to a non-Main-dispatcher in order to keep the UI responsive. I also collect the items emitted from that sequence and update the progress on each received item.

val totalSize = 255 // for sake of this example
var input by rememberSaveable(stateSaver = TextFieldValue.Saver) {
    mutableStateOf(TextFieldValue("Test Input"))
}
var doCalculation by rememberSaveable(input) {
    mutableStateOf(false)
}
val resultState by produceState(
    State.Null as State,
    input,
    doCalculation,
) {
    value = DealingState.Null
    if (!doCalculation) {
        value = DealingState.Null
        return@produceState
    }

    value = DealingState.Loading(
        progress = 0,
        required = totalSize,
    )

    launch(Dispatchers.Default) {
        runCatching {
            val resultList = mutableListOf<String>()
            calculateItems(input).forEach {
                resultList.add(it)
                value = State.Loading(
                    progress = resultList.size,
                    required = totalSize,
                )
            }
            value = State.Success(resultList)
        }.getOrElse {
            value = State.Failure(it)
        }
    }
}

What I Tried

I tried the following things:

• define a coroutine scope specifically for this routine and call scope.cancel() when a new state is to be produced.

val scope = CoroutineScope(Dispatchers.Default)
val resultState by produceState(...) {
    scope.cancel()
    ....
    scope.launch(Dispatchers.Default) {...}
}

• store the job from launch and cancel the job or the children

var job: Job? = null
val resultState by produceState(...) {
    job?.cancel() // and job?.cancelChildren()
    ....
    job = launch(Dispatchers.Default) {...}
}

• android
• kotlin
• android-jetpack-compose
• kotlin-coroutines
• side-effects

2 Answers 2

Try making your inner coroutine cancellable by adding ensureActive(), for example:

calculateItems(input).forEach {
    ensureActive()
    resultList.add(it)

You are launching a coroutine inside produceState without tying it CoroutineScope correctly. Instead, produceState already runs in a coroutine scope, so you should use launch directly inside it and let produceState handle cancellation automatically.

Try this code I think this may help you.

val totalSize = 255 // Example total size
var input by rememberSaveable(stateSaver = TextFieldValue.Saver) {
    mutableStateOf(TextFieldValue("Test Input"))
}
var doCalculation by rememberSaveable(input) {
    mutableStateOf(false)
}

val resultState by produceState<State>(
    initialValue = State.Null,
    input,
    doCalculation
) {
    if (!doCalculation) {
        value = State.Null
        return@produceState
    }

    value = State.Loading(progress = 0, required = totalSize)

    try {
        val resultList = mutableListOf<String>()
        calculateItems(input.text).forEachIndexed { index, item ->
            resultList.add(item)
            value = State.Loading(progress = index + 1, required = totalSize)
        }
        value = State.Success(resultList)
    } catch (e: Exception) {
        value = State.Failure(e)
    }
}