Internally, I found that the suspend function is suspended when the invokeSuspend function returns a

COROUTINE_SUSPENDED

Enum . If so, when exactly does COROUTINE_SUSPENDED return?

A default

Flow

isn't closable because it's cold?

I am seeing this report in Bugsnag where the root exception is swallowed. Has anyone seen something similar before or have tips on how to best find the true root cause?

0  libsystem_kernel.dylib  ___pthread_kill
1  libsystem_pthread.dylib _pthread_kill
2  libsystem_c.dylib       _abort
3  BaseBetaiOS             konan::abort() (BaseBetaiOS)
4  BaseBetaiOS             (anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1::operator()() const (BaseBetaiOS)
5  BaseBetaiOS             void (anonymous namespace)::$_0::operator()<(anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1>((anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1) (BaseBetaiOS)
6  BaseBetaiOS             (anonymous namespace)::terminateWithUnhandledException(ObjHeader*) (BaseBetaiOS)
7  BaseBetaiOS             (anonymous namespace)::processUnhandledException(ObjHeader*) (BaseBetaiOS)
8  BaseBetaiOS             kfun:kotlinx.coroutines#handleCoroutineException(kotlin.coroutines.CoroutineContext;kotlin.Throwable){} (BaseBetaiOS)
9  BaseBetaiOS             kfun:kotlinx.coroutines.StandaloneCoroutine.handleJobException#internal (BaseBetaiOS)
10 BaseBetaiOS             kfun:kotlinx.coroutines.JobSupport.finalizeFinishingState#internal (BaseBetaiOS)
11 BaseBetaiOS             kfun:kotlinx.coroutines.JobSupport.tryMakeCompleting#internal (BaseBetaiOS)
12 BaseBetaiOS             kfun:kotlinx.coroutines.JobSupport#makeCompletingOnce(kotlin.Any?){}kotlin.Any? (BaseBetaiOS)
13 BaseBetaiOS             kfun:kotlinx.coroutines.AbstractCoroutine#resumeWith(kotlin.Result<1:0>){} (BaseBetaiOS)
14 BaseBetaiOS             kfun:kotlin.coroutines.native.internal.BaseContinuationImpl#resumeWith(kotlin.Result<kotlin.Any?>){} (BaseBetaiOS)
15 BaseBetaiOS             kfun:kotlinx.coroutines.DispatchedTask#run(){} (BaseBetaiOS)
16 BaseBetaiOS             kfun:kotlinx.coroutines.DarwinGlobalQueueDispatcher.$dispatch$lambda$0$FUNCTION_REFERENCE$693.$<bridge-UNN>invoke(){}#internal (BaseBetaiOS)
17 BaseBetaiOS             ___6f72672e6a6574627261696e732e6b6f746c696e783a6b6f746c696e782d636f726f7574696e65732d636f7265_knbridge762_block_invoke (BaseBetaiOS)
18 libdispatch.dylib       __dispatch_call_block_and_release
19 libdispatch.dylib       __dispatch_client_callout
20 libdispatch.dylib       __dispatch_root_queue_drain
21 libdispatch.dylib       __dispatch_worker_thread2
22 libsystem_pthread.dylib __pthread_wqthread

I have the following use case: My function returns a flow.. for simplicity lets say it returns

Flow<Int>

In this function I have an api call which also returns a flow What is the best way to give result back to the caller? Sample code in thread

Hi everyone 👋 Considering the project setup where you would have implicit dependencies with particular version of kotlinx coroutines enforced, how safe would that be in case of 3rd party dependencies? Would it impose any risk when a library has been compiled with one version of coroutines core but using newer version in the runtime? In case of most API breaking changes it’s quite easy as it will fail during compilation phase but I wonder how safe would it be to assume that breaking changes within core would always come with some new API 🤔

I have a question around testing.. If I have a MutableStateFlow, and a function which updates that StateFlow multiple times, is there a way to test that the StateFlow went through the expected intermediate states?

does

withContext()

get it’s own coroutineScope or inherit it from whoever is calling the function?

How excute in order I want execution in order[FIFO] how i can archive that

scope.launch{
List.forEach{
  Something(it)
}

In new code that doesn't use flows, is there a recommendation/preference between

coroutineContext

and

currentCoroutineContext()

?

Morning! I would like to know how I could, when spring boot is shutting down, await for a CoroutineScope childrens to end, more especifically I would like to "close" a CoroutineScope without cancelling its childrens, that is, prevent new jobs from being posted and throw if an attempt is make, and then await for its childrens to finish their work, and only then finish the application. This is not specific for Spring Boot, I only need to figure out how to close a Coroutine Scope without cancelling its children, how could I do this?

Hello! Does anyone know how to ensure that a suspend lambda parameter is really

suspend

and not a non-suspend one ? If possible it could be an annotation where the ensuring would happen. My use case is:

suspend fun <T> execute(request: suspend () -> T): T {
  // code here
}

...
//code using 'execute'
execute(mySuspendLambda) // OK
execute { 1+1 } // warning or error

I tried to search for it but with no luck. How to combine more than 5 flows?

Hi everyone, I have a question regarding Flow collection inside Fragment. My app heavily depends on Flow, and I have a lot of places where I need to collect it in UI layer, so I wanted to create an extension function to reduce the boilerplate code I need to write every time I have to collect it...

inline fun <T> Fragment.collectFlowSafely(
    flowToCollect: Flow<T>,
    repeatState: Lifecycle.State = Lifecycle.State.STARTED,
    crossinline value: (T) -> Unit
) {
    viewLifecycleOwner.lifecycleScope.launch {
        viewLifecycleOwner.repeatOnLifecycle(repeatState) {
            flowToCollect.collect {
                value(it)
            }
        }
    }
}

Would this way of collecting flow be safe from cancellation point of view? i.e. Would cancel the collection when the view is no longer visible etc?

Hi Team, I understand that runBlocking waits for coroutines launched from its scope to wait. However when I create a new scope using runBlocking scope's coroutine context, runBlocking will wait for the coroutines launched from this new scope. My question is what parameter of coroutine context does runBlocking use to decide if it wants to wait for a launched coroutine. If you have any resources for the inner workings of runBlocking please provide them. Thanks.

How do I wait for

flow

for specific amount of time, and collect all, or return null?

How can you debug the origin (in the code) of a started coroutine on Kotlin/Native? I want to cancel a job but the cancelation does not finish and I am unable to find the cause.

are there any plans in the future to allow overloading methods based on whether they're suspending or not?

fun blah() { ... }

suspend fun blah() { ... }

now if I'm in a coroutineContext and call blah, it calls the suspending one and if I'm not in a coroutineContext or in Java-land, it calls the non-suspending one

Why is

launch

allowed to cancel itself but

coroutineScope

isn’t?

On upgrading a multi-platform (JVM, JS with IR) project to Kotlin 1.7.10 and coroutines 1.6.4, I now get this error at build time:

> Task :shared:kspKotlinFrontend FAILED
e: Could not find "org.jetbrains.kotlin:kotlinx-atomicfu-runtime" in [/home/raman/.local/share/kotlin/daemon]
e: java.lang.IllegalStateException: FATAL ERROR: Could not find "org.jetbrains.kotlin:kotlinx-atomicfu-runtime" in [/home/raman/.local/share/kotlin/daemon]
        at org.jetbrains.kotlin.ir.backend.js.KlibKt$toResolverLogger$1.fatal(klib.kt:106)

This issue exists, but is marked as resolved: https://github.com/Kotlin/kotlinx.coroutines/issues/3305. I don't depend on atomicfu directly -- only indirect dependencies via coroutines.

Hi All! I'm looking at the coroutines code to understand a bit more what is going under the hood and I found this in

delay()

public suspend fun delay(timeMillis: Long) {
    if (timeMillis <= 0) return // don't delay
    return suspendCancellableCoroutine sc@ { cont: CancellableContinuation<Unit> ->
        //some extra code
    }
}

I wonder if there's a reason to do

return suspendCancellableCoroutine[...]

rather than just calling

suspendCancellableCoroutine()

, as

delay()

returns

Unit

.

How come this

error()

doesn’t crash the app? Given there is no supervisor job I was expecting this to crash the program but it doesn’t. I can see the ‘Starting’ the crash and then ‘job done’ in the logs 🤔

suspend fun main() {
    val scope = CoroutineScope(Dispatchers.Main.immediate)
    debugLn { "Starting" }
    scope.launch {
        error("CRASH!")
    }
    delay(500)
    debugLn { "Job done" }
}

so i have this code that fetches data, typical usecases that fetch data from an API upon starting a viewmodel

var location = mutableStateOf<GetLocation.Location?>(null)
var dateRange = mutableStateOf<DateRange?>(null)
var category = mutableStateOf(Category.All)
var period = mutableStateOf(Period.Any)

fun fetchData() {
    viewModelScope.launch(<http://dispatchers.io|dispatchers.io>) {
        getLocation.execute().fold(
            onSuccess = { response ->
                withContext(dispatchers.main) {
                    location.value = response.orNull()
                }
            },
            onFailure = {
                logger.log(it)
            }
        )
.... etc....

but I would like to observe any changes in these fields and fetch again when they’ve been updated is there like a combineLatest?

Is there a common use case for using channels for Android Development? I am only aware of using them for Single UI Events; however, Google recommends not using them for this purpose.

Conceptual question: I have a bunch of coroutines that might at some point want to know, say, the latest USD-EUR conversion rate. My

getUsdEurRate()

function is expensive, so essentially what I want is: • Every consumer registers somewhere • When there is an active registration, the function gets kicked off and all the consumers suspend until we get a value back ◦ As other consumers may register while the function is running • No consumer should ever get a stale value My first approach was to use a 0-capacity synchronization channel, but based on the above thread, it sounds like channels don't really support both "no buffered values" and "multiple consumers get the same value". Is a flow the right approach here? Or something else?

I'm trying to debug coroutines using a javaagent form a

kotlinx-coroutines-debug

library. After sending a

SIGTRAP

signal there are coroutines stacktraces like following:

Coroutine StandaloneCoroutine{Active}@4491c16c, state: SUSPENDED
        ...

Coroutine StandaloneCoroutine{Active}@27559007, state: SUSPENDED
        ...

However it is not possible to understand which stack belongs to which coroutine. All my coroutines have unique names. Is it possible to activate printing coroutine names?

Hi. I have a long running flow (compose 1.2.1), which has several flatMapLatest calls on other observables. When the user logs out an observable near the top of the flow emits. I am having trouble seeing how to interrupt the downstream observables, which are seeing the missing data after logout and attempting to request updates. One of the ideas I tried was

observeLoginState().map { it is LoggedIn }
.distinctUntilChanged()
.flatMapLatest { isLoggedIn ->
    if (isLoggedIn) { dataSource.observe() }
    else { emptyFlow() }
}
...
.flatMap {}
,,,
,launchedIn(scope)

However it really seems like the downstream flatMaps are continuing to observe even when a flatMapLatest upstream has changed. Am I doing something wrong? Is there a way to cancel the downstream observers while keeping the flow alive? A couple of other ideas I tried: • Threading a null or sentinel value through the flow so downstream observers could be swapped out but requires too many compromises about the type of data based along the flow. • throwing an exception and using retryWhen to restart the flow. I ran into an exception retry loop when logged out which I should have seen even before I tried. Even though I expect it could be made workable, I didn’t really spend the time looking further as it felt kludgey.

This message was deleted.

Is there an idiomatic way to create a dynamic Proxy in Kotlin? I've been trying with

java.reflect.Proxy

with awful results This proxy job is to intercept, detect if a particular exception is throw and if so unwrap it and throw the underlying exception. This has to work with suspend functions

class UnwrapExceptionProxy<T>(private val instance: T): InvocationHandler {
    @Suppress("UNCHECKED_CAST")
    override fun invoke(proxy: Any, method: Method, args: Array<out Any?>?): Any? {
        val function = method.kotlinFunction!!

        return if (function.isSuspend) {
            val parameters = Array(args!!.size - 1) {args[it] }
            val continuation = args.last() as Continuation<Any?>
            method.invoke(instance, *parameters, Continuation<Any?>(continuation.context) { result ->
                val wrappedError = result.exceptionOrNull() as? MyWrapException
                if (wrappedError == null) {
                    continuation.resumeWith(result)
                } else {
                    continuation.resumeWith(Result.failure(wrappedError.wrapped))
                }
            })
        } else {
            val parameters = args ?: arrayOf()
            try {
                method.invoke(instance, *parameters)
            } catch (e: MyWrapException) {
                throw e.wrapped
            }
        }
    }
}

1. First, I'm not sure if I've handled the suspend function correctly 2. I get

java.lang.reflect.UndeclaredThrowableException

every time my kotlin code throws a non

RuntimeException

Is there no way to write a Proxy for kotlin? I cannot force declaring all checked exceptions and I wanted to make this as transparent as possible.

How can I avoid the ClosedByInterruptException from being throw up when doing something like this:

val test = withTimeoutOrNull(3.seconds) {
    runInterruptible {
        channel.receive(ByteBuffer.allocateDirect(10))
    }
}

I would have expected null to be returned. Catching the exception results in a value being returned instead of null.