I would like to express a suspend function as a callback:

suspend fun getMyObject() : MyObject {
   ...
   return myObject
}

val myApp = myCallback { myObject ->
   /* code using myObject */
}

how should I write the function

myCallback

?

Is there some significant runtime overhead for CoroutineScope instance, i.e lets say having 30of them, vs 1 shared thats being injected?

I've got a StateFlow that doesn't seem to emit any values (classic StateFlow problem) I don't think this is due to object equality, but I can't figure out what's going on..

We’ve been using payloads and diffs in our recycler views to react to state changes for a long time now. One idea that came to mind was exposing a flow of state + lifecycle scope to our recycler view’s adapters and collecting the state (from each viewholder) and updating the viewholders’ UI that way. One benefit i see to this is our code complexity drastically reduces while also having a good UX (no flickering/glitches). Does anyone have thoughts on this, pros or cons to considering such an approach?

answer is: not exactly. It all works with the assumption that the underlying executor will throw if shutdown. I was looking at “bad” code that’s wrapping an android handler and not throwing if the task is rejected, hence blocking forever

Just to clarify - coroutines now requires Java 8 (with version

1.5.0

of the lib), which means all Android projects that consume it must enable Java 8 desugaring?

If I have a list of Deferred's created inside a

supervisorScope

using

async

. What is the most efficient way to await for the first failure of any of the jobs? At the moment I am looping the jobs, saving away successes, and capturing the first failure, then when that happens issuing a "controlled cancellation on the others" and using a yield (or delay) inside the tight loop, but it feels like there must be a better way of doing this

I am wondering if we can implement a

suspend

method in Java class. What's the correct way to do it? SO Thread: https://stackoverflow.com/questions/68032757/how-can-i-implement-kotlin-suspend-method-in-a-java-class

Trying to understand this section in the kotlin native-mt coroutine documentation.

However, it is known to leak memory in scenarios involving concurrency under load, for example when multiple children coroutines running in different threads are simultaneously cancelled.

Would multiple jobs launched like the above roughly at the same time, produce the leak.

Hi everyone, I'm trying to test a ktor call, which is a suspend function, in commonTest. Should I use

runBlocking

,

GlobalScope

, or what? I've tried kotlinx-coroutines-test, to use

runBlockingTest

, but apparently this library is only for JVM?

Hi folks, there is any CoroutinesContextElement/Key that says when is running inside a

runBlocking

?

Can we get eyes and a priority check on this issue? Exceptions thrown from

Dispatchers.Default

fail to terminate the program and it was reported in November https://github.com/Kotlin/kotlinx.coroutines/issues/2398

Hey all, question for a coroutine novice, I have a method that can be called concurrently and if a certain condition is met, I’d like to start a job with the first method that sees the condition is met, and then have the other threads wait for the result of that job. My first thought was to have some Atomic Semaphore / Lock that indicates one of the threads has claimed this job, but that would not allow for me to join on that result. What is the idiomatic way to do this in kotlin?

Is there a way to

send

something to an actor and “suspend” until the message was processed?

when to use "suspend function" vs "function returning Deferred"?

Is there anything like 'daemon coroutine' in

coroutineScope

that will be cancelled if other things in it are completed? Normally tasks running in

launch

in it will cause

coroutineScope

not to return.

I'm trying to make firebase-admin calls coroutine-friendly. The api call returns an ApiFuture. I want to wrap that in a suspend function with a set timeout. The attached code is my approach to it but the timeout never seem to trigger if the third party request stalls for whatever reason. I'm trying to figure out if this is at all a sane approach or if I'm doing something wrong. Can I expect the

withTimeout

to trigger an exception after 5 seconds of no response?

Hi, I'm new to coroutines and I'm trying to understand some basic behavior of async. The following code runs in 2 seconds and I understand that because I'm using async. What I don't understand is how this can happen if both asyncs are running on the same Thread (main)? Can coroutines run in parallel although they run in a single thread?

import kotlinx.coroutines.*
import kotlin.system.*
fun main() = runBlocking {
    val time = measureTimeMillis {
        println("The answer is ${concurrentSum()} en ${Thread.currentThread()}")
    }
    println("Completed in $time ms en ${Thread.currentThread()}")    
}
suspend fun concurrentSum(): Int = coroutineScope {
    val one = async { doSomethingUsefulOne() }
    val two = async { doSomethingUsefulTwo() }
    one.await() + two.await()
}
suspend fun doSomethingUsefulOne(): Int {
    println("1 in Thread ${Thread.currentThread()}")
    delay(2000L) // pretend we are doing something useful here
    return 13
}
suspend fun doSomethingUsefulTwo(): Int {
    println("2 in Thread ${Thread.currentThread()}")
    delay(2000L) // pretend we are doing something useful here, too
    return 29
}

I think some time ago I read an article that suggested to always use the main dispatcher by default and only switch to sth else on demand. Can anybody recall if he read that too and where?

I am pretty sure that I am missing something obvious but in the following code the first emission from the notificationsViewModel StateFlow works but when I call the refresh function it doesn’t flow the updates through notificationsViewModel. What am I missing here? (Apologize about the naming conventions as they may be confusing)

Hi I am new to coroutines. I am having an issue with delay function. I have a foreground service in which I am starting bluetooth scanning then delaying for 20 seconds and then calling stopScan. Now, scan result is start coming 20 seconds late, is it because of delay?

I'm thinking about building a flow around a kafka consumer; problem is that the consumer only allows me to call its methods from a single thread. I was able to implement this using coroutines fired by a single-threaded dispatcher and communicating via channels. But for a Flow-centered solution I build a flow using the

flow{}

builder, can I somehow guarantee that the code in the

flow{}

will run inside a specific dispatcher but the code that collects the results sent by `emit()`will run in a less-restricted dispatcher?

Hey y’all! I’m seeing some

combine

behavior that I don’t expect, hoping someone can help me shed some light. (putting code snippet in thread)

Hi, I am trying to write a test for my android app but I can’t get it to work. I never receive the ViewState.Info state. Instead I only get the initial Loading state. The code is in the reply thread.

I’d like to create a Unit returning suspend function which launches another coroutine inside it and must not return until that coroutine has finished. Is this “pattern” a good way for implementing this?

suspend fun myFunction(myParam: String): Unit = myScope.launch {
	doSomethingElseSuspending()
	withContext(anotherContext) { doSomeOtherStuffInTheOtherContext(myParam) }
}.join()

The rationale is that the caller of

myFunction

should not care of what’s happening inside it, the caller merely calls a suspending function (

myFunction()

) that suspends until all work done inside it is done and then either throws or returns Unit.

in my program i have multiple commands that i want to execute (where a command is something that is triggered, and polled upon until it completes). only one command can be executed at a time (limitation on the remote system). If i was only doing one of these at a time i would just call my

suspend fun

and wait for the result. however i am calling multiple `suspend fun`s from throughout my code base. I’m trying to think of a way to group these together and allow them to queue since each of the call sites uses a separate context/scope. another requirement is that if a particular command completes, it can cancel all remaining commands that are queued up. my first attempt at it in the thread -->

Hi everyone!  I want to update my app behavior depending on if a user is touching the screen or not. So I came with the idea of having a MutableSharedFlow that emits user interaction and collecting the values with collectLatest. The problem is that I'm only interested in the last event and would want to drop all older processing. How could I achieve this? The code looks like this:

val userInteracting = MutableSharedFlow<Unit>(replay = 0)

onEvent(){
    coroutineScope.launch {
        userInteracting.emit(Unit)
    }
}

coroutineScope.launch {
    userInteracting.collectLatest {
        showSky.value = false
        delay(5000)
        showSky.value = true
    }
}

How'd I go implementing a

List#sortedWith

that takes a comparator which can be suspended? Suppose I'd need something like this:

someList.sortedWith { o1, o2 -> suspendedComparison(o1, o2) }

Where

suspendedComparison

is a function which returns

Int

(satisfying

Comparator

) and is a

suspend fun

...

What are possible negatives of running a

Retrofit

call without suspend keyword from a

Coroutine

?