Hey all! We’re considering folding coroutines internal calls in the IDE console output to leave only business logic on the stacktrace thus making analysing them easier. Folding means that all the lines (including the first line that matches a given at

kotlinx.coroutines.

prefix) will not be shown unless you click on 

<3 internal lines>

. After one clicks on this caption — all the underlying folded lines will be shown to the user. Folded code:

at my.business.Logic.f(Logic.kt:30)
at my.business.Logic.g(Logic.kt:150)
at my.business.Logic.main(Logic.kt:99) <3 internal lines>
at not.mine.but.also.BusinessLogic.main$1(BusinessLogic.kt:20)
at not.mine.but.also.BusinessLogic.main(BusinessLogic.kt:19)

Unfolded code:

at my.business.Logic.f(Logic.kt:30)
at my.business.Logic.g(Logic.kt:150)
at my.business.Logic.main(Logic.kt:99)
at kotlinx.coroutines.invokeAsync(Coroutines:999)
at kotlinx.coroutines.applySuspend(Coroutines:18)
at kotlinx.coroutines.runBlocking(BlockingCoroutines:555)
at not.mine.but.also.BusinessLogic.main$1(BusinessLogic.kt:20)
at not.mine.but.also.BusinessLogic.main(BusinessLogic.kt:19)

To understand the possible consequences on user experience we want to know how you feel about seeing or not seeing coroutine internal stuff in your stacktraces (please note that they will be still available via clicking on <N lines folded>). And if you need them, it would be interesting to understand your specific use cases. Please, share your thoughts in the thread.

How can I use lifecyclescope in a class which does not have any lifecycle, Passing the context is it a good approach ?

Do I understand correctly that if I catch an exception in a coroutine I should always check if it is a

CancellationException

? Eg.:

suspend fun etc() {
    try {
        someOtherSuspendFun()
    } catch (e: Exception) {
        if (e is CancellationException) {
            throw e // The operation has also failed but I should not throw WrapperException because it will interfere with the cancellation mechanism
        } else {
            throw WrapperException("Operation failed", e)
        }
    }
}

(The above is pseudo code, I have not tried it.) Thanks.

How do I make a state flow that: • emits its value immediately every time it changes • emits its value periodically X seconds after it changes (and keeps doing it until it changes) • don’t emit anything when the value is null (if it’s changed to null and periodically) I know how to make a flow that basically combines the origin state flow with an independent periodic flow re-emitting the value of the state flow, but it’s not exactly what I want. I found no simple way to make a timer either

Hello! How to distinguish if cancellation come from parent or child?

Hey, any idea why would a

.collect {}

call of a

MutableStateFlow

not work after the initial value? Basically, I create a

MutableStateFlow

in one place and call

emit

(multiple times) there, and at the same time call

.collect {}

in another place, and the callback of

collect

is not executed, except for the initial value. I can clearly see the state of the

Flow

is changing, but

collect

is just not working. I'm also absolutely sure the

collect

call is not getting canceled, as I have tried catching

CancellationException

. The context is a Jetpack Compose app, maybe it's some bug there? SOLVED: the problem was emitting the same list to the StateFlow. Even though the list is changing, its reference has not, and coroutines treat it as the same value, and concludes no new value needs to be emitted. Hence

collect

callback is not called after the initial value.

How do I use

launch { send(..) }

in

produce {}

and ensure I can receive them in

produce.consumeEach

?

Anyone experienced issue with

previousBackStackEntry

? It's always null in case:

val navController: NavHostController = rememberNavController()
val previousBackStackEntry = navController.previousBackStackEntry

and works correctly when has these 2 extra lines:

val navController: NavHostController = rememberNavController()
val currentState by navController.currentBackStackEntryAsState()
val currentRoute: String? = currentState?.destination?.route
val hasPreviousBackStackEntry = navController.previousBackStackEntry

Hi, I am starting a coroutine in a viewmodelscope triggered in the onPause state of my fragment. The coroutine just need to update a value in the data store pref. Some of my users get a nullpointer exception. I think its because of the speed of closing the fragment and the vm. My idea is to start the coroutine in a globalscope, is this a good approach? Thank you

I'm trying to implement something similar to lazy, but suspending. At the start of the program the value is empty, on first access I want to compute it, then reuse the same value throughout the program's lifetime. The easiest solution would be a lock/mutex, however it seems like they are quite expensive, so seem a bit overkill (since the data is immutable, locking is unnecessary after it is initialized)

I'm looking at the implementation of

Flow.debounce()

and I saw it's quite complex. Now thinking about it, can't debounce be simplified to the following implementation?:

fun Flow.debounce(timeoutMillis: Long) = transformLatest {
    delay(timeoutMillis)
    emit(it)
}

Apologies if this has been asked before, but I'm not finding anything via search. Are there plans to cover

SharedFlow

and

StateFlow

under https://kotlinlang.org/docs/? If so, is there a related YouTrack/GitHub issue that could be followed and contributed to? Not that the KDocs aren't good, but it seems like a rather important component of the API, and I'm not seeing any mention of it on the #kotlin-website at all.

how can i have my kmp project use the latest coroutines-core and enforce native-only targets to use the -native-mt variant? I came up with a solution that had me replace my iosMain sourceSet with both iosArm64Main and iosX64Main and duplicate all its code.

Hi, i am using sqldelight to get data from database as flow, however the flow is not being collected whenever a new item is added

val players: Flow<List<HockeyPlayer>> = 
  playerQueries.selectAll()
    .asFlow()
    .mapToList()

players,collect{
   // i am not getting new list when item is added, i only receive data once
}

What could i be doing that is not right ?

I have a function that wants to be able to spawn a new coroutine via

launch

but don't want to dictate which CoroutineScope it is attached to, so I have created it as an extension method to

CoroutineScope

so

launch

can be called against it. This approach feels like it is guarded pretty heavily against through the use of

coroutineScope

and friends - is there a more idiomatic way I should be spawning new tasks in the context of the calling function, or is this approach considered okay?

Hi, I am trying to use coroutines in my spring boot project. I am using RestTemplate for networking which is doing blocking calls. Is it safe if I do next:

private suspend fun getSomething() = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
        RestTemplate().exchange(
            "url", <http://HttpMethod.POST|HttpMethod.POST>, HttpEntity("body"), String::class.java
        )
    }

Will this produce many threads to wait, or I am safe that this will use some limited thread pool? What if I want to limit thread pool size to 2, will it also work?

Is there a built in equivalent of

Observable.never()

?

I have a suspend function:

private suspend fun getThing(){...}

How can I set a minimum return time on this? So it will only return if at least 2000ms have passed, for example?

I have a function to receive a batch of items from a

Channel

, returning a list of items after

timeoutMs

milliseconds (the list might be empty). Here is the code:

public suspend fun <E> receiveBatch(
    channel: ReceiveChannel<E>,
    timeoutMs: Long,
): List<E> {
    val batch = mutableListOf<E>()
    withTimeoutOrNull(timeoutMs) {
        for (item in channel) {
            batch.add(item)
        }
    }
    return batch
}

In simple testing everything is fine, but under load sometimes an item is not added to a list and is lost. What I think happens is that

withTimeoutOrNull

times out between receiving an item from the channel and adding it to the list. Does anyone have a solution for this issue, or a better design for what I am trying to do?

A question about doing parallel async work using map. (More in Thread 🧵)

In a project I ran into something that affected the performance. I implemented 2 methods for comparisons on speed.

without_actor

runs in about ~10ms for 100_000 messages

with_actor

runs in about ~4000ms for 100_000 messages Is this caused by some context switching what is happening internally, or related how locking is done internally?

Does it make sense to have a job and does not assign it to the

launch{}

? Example :

private val job: Job? = null

internal class Foo : CoroutineScope {
  override val coroutineContext: CoroutineContext
   get() = Dispatchers.Main + Job!!

   ...

   private fun bar() {
    job = Job()

    launch { .... }
   }

   override onDetach() {
    job.cancel()
   }
}

Does it really cancel the launch?

Hi,

class Foo {
    private val scope = CoroutineScope(SupervisedJob() + Dispatchers.Main.immediate)

    fun init() {
        println("a")

        scope.launch {
            println("b")

            flowOf("hello")
                .collect {
                    println("c")
                }
        }

        println("d")
    }
}

I'm pretty sure this emmited printed

a, b, c, d

in the past when using immediate main dispatcher on android but now it emits

a, d, b, c

Is there a way to make this blocking as it was in rxjava? I thought this exactly was the difference between

Dispatchers.Main

and

Dispatchers.Main.immediate

In the context of Android and replacing SingleLiveEvent. can anyone explain why a BUFFERED Channel seems to be preferred to the default RENDEZVOUS Channel?

Can I do the follwing, when using

flow

and

stateIn

or does it has unpredictable side effects. It does not feel right to pass

this

into

stateIn

. Does

doSomething()

ever return or will it suspend infinite, because the scope is used by

stateIn

?

suspend fun doSomeThing() = coroutineScope {
    val someState = someFlow.stateIn(this)
    ...
}

Hi 😊, I have a question about coroutine flow and viewmodel scope. I have a case when I register to a flow in my

onStart()

method in my Fragment A. This flow is attached to the

viewModelScope

. My question is: when I open another fragment and return to my Fragment A

onStart

is called again and the register for the flow is called as well, so the flow is called twice without cancel it as it's attached to the

viewModelScope

and the

onCleared

method was not called yet . How do you handle this case to avoid keeping emitting data to the view when the view is not attached ?

Why can't we call

launch

or

async

from

suspend

function directly.

suspend

functions get called from a

coroutine

. Why can't it use that context. If we create a new

coroutineScope

inside a

suspend

function then would the new

coroutines

be attached to the parent that called the

suspend

function? So that these get cancelled when the parent get cancelled.

How to emit the same value with StateFlow? In my case, it's just Unit that I'd like to emit.

I want to use

MutableStateFlow

as a cache for a database (sqldelight). It means, that e. g. I have

fun getKeysForUser(userId:String):MutableStateFlow<Keys?>

, which first looks in the cache (just a MutableMap) if it contains a matching MutableStateFlow and if not, creates one with an initial value from the database. It then also launches a coroutine to collect from the MutableStateFlow and write to the database on changes. If there are no subscribers anymore (except from the db-collect), I want to remove it from the cache. What is the best way to do it and does this whole idea work?