Can someone please tell why.. I have a shared flow that emits a value when user taps a button:

sharedFlow.collect { println("first") }

sharedFlow.collect { println("second") }

But actually 10 taps results in 10 prints of "first" message and never prints the "second" one. Does the shared flow accept only one collector, or could it's behavior widely depend on configuration and usage?

Hi, I'm trying to get progress when loading data in my application and I've come to two solutions One of them uses flow:

suspend fun flowProgress(block: (Flow<Int>) -> Unit) {
    block(
        flow {
            do {
                val progress: Int // .... getting progress
                emit(progress)
            } while (true)
        }
    )
}

The other uses plain callback function:

suspend fun intProgress(block: (Int) -> Unit) {
    do {
        val progress: Int // .... getting progress
        block(progress)
    } while (true)
}

Can somebody tell me what's the difference between these two and why should I go with one over the other?

A somewhat trivial question but i couldn’t find a straightforward answer by googling; what’s the best way to convert one of the many Rx / Reactive types to a coroutine? Things like

Single

,

Flowable

etc

I need a flow builder that emits

Unit

every

X

milliseconds while it has a subscriber. What’s the idiomatic approach for this?

So, no .forEach but more like .forLatest... or does .forEach not look into the past anyways?

Anyone of you can explain how retrofit / room are doing the main-safety stuff? I know that if I put suspend I can avoid the

withContext(<http://Dispatchers.IO|Dispatchers.IO>)

but what if I have some mappers and some business logic? Is it safe to remove the

withContext(<http://Dispatchers.IO|Dispatchers.IO>)

?

Let's say you are within a suspend function... What's the most pragmatic way to cancel your execution? Should you just throw a cancellation exception? Or maybe somehow grab the current job and cancel that?

has anyone tried to use coroutines within

StreamingOutput

before?

I remember from somewhere that putting a loop inside of a coroutine is a pretty bad idea but I cant remember why. Could someone please explain why?

How to avoid accidentally catching

CancellationException

? For example, any inline (not suspending) higher order function could innocently be catching

Exception

and converting to some sealed class. It knows nothing about coroutines and so would have no reason to give special treatment to

CancellationException

.

fun main() {
    runBlocking {
        val job = launch {
            test {
			    delay(1000L)
                println("finished long delay")
            }
            println("finished test")
        }
        delay(100L)
        job.cancel()
    }
}

inline fun test(block: () -> Unit) {
    try {
        block()
    } catch (e: Exception) {
        println(e.toString())
    }
}

// kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job="coroutine#2":StandaloneCoroutine{Cancelling}@de0a01f
// finished test

If I have my presenter that has a

CoroutineScope

as a parameter with dagger like

fun provideFragmentScope(fragment: MyFragment): CoroutineScope = fragment.lifecycleScope

if on

onDestroyView

I put

lifecycleScope.coroutineContext.cancelChildren()

then is a good praxis to cancel coroutines? Note I'm not using

ViewModel

so I have to cancel it manually...

How do I set the flow to start collecting only when the data meet certain conditions. For example:

flowOf(1, 2, 3, 2, 1, 2, 3)
    .startCollectWhen { it == 3 }
    .collect { print(it) }

// Result: 3, 2, 1, 2, 3

does kotlin flow currently support creating batches of items, e.g. for executing batched sql inserts? like that (pseudo code): flow.batch(size=20).collect { batchOfUpTo20ItemsFromFlow -> /* do something */ }

How can I have a SharedFlow buffer emissions that come while there are no subscribers?

Hello devs, which one do you think it's better to be used and why? 1. private val stateData = MutableStateFlow<State>(State.Idle) val state: StateFlow<State> get() = stateData Or 2. private val stateData = MutableStateFlow<State>(State.Idle) val state: StateFlow<State> = stateData

This is scary. I just published my first blog 🙏🏼 . I breakdown the suspend function. Let me know your thoughts! https://recheecodes.com/kotlin-coroutines-suspend-function/

(crossposting here as well)

I'm getting a report of a StackOverflowError crash in an Android app (can't repro locally). It looks like it's coroutines related, but the crash happens in a kotlin.text function. How can I debug something like this?

I remember from a KotlinConf about testing with coroutines that multiple coroutine scopes can be on the same thread, am I remember this correctly? also if this ^ is true, is there a way to ensure that multiple coroutine scopes are on the same thread?

Any ideas why this prints: Inner Value: 0 Outer

fun main() {
   println("Outer")
   
   CoroutineScope(Dispatchers.Default).launch {
       getFlow()
            .onEach { println("Value: $it") }
            .collect()
   }
}


fun getFlow() = callbackFlow<Int> {
   println("Inner")
   delay(1)
   sendBlocking(0)
}

Shouldn't

Outer

get printed first?

are

CoroutineScopes

cheap? Can I just create a

MainScope()

or sth for e.g. every usecase execution or does it come with some significant overhead? it's a specific use case in kotlin multiplatform where I would rather create it every time than reuse it for a much more concise code.

How does one debug coroutines just from the logs, I got an exception (TimeoutCancellationException) that appeared randomly but it never said where it was coming from so I had to dissect my program to finally find the ktor call that was responsible. Is there something that would allow to log where the exception really happened (without having a debugger attached all the time as it is not possible in production)?

myFlow.previousMap { previousValue, currentValue -> }

I have a program, a web server, that currently uses a cached thread pool executor with a default thread factory. Is there an easy way I can switch in coroutines there? I tried with project loom and it worked beautifully, is it similar in coroutines?

When working with Java

Future

or

CompletableFuture

in JVM > 8 within

suspendCoroutine

what's the suggested pattern for interaction. From what I can tell, the

suspendCoroutine

is designed for an asynchronous callback but from what I can tell JDK 11, 12, 13 and 14 don't have a way to implement a CompletionStage interface.

how to i take the first element fro ma flow and then consume the rest with collect ? seems like when i use

take

it closes the flow

Has there been any recent talk of suspend getters/setters for properties? I would really love to see this. Anyone know if it’s being planned?

i keep getting this crash while using 

debounce

 on android:

java.lang.AbstractMethodError: abstract method "kotlinx.coroutines.DisposableHandle kotlinx.coroutines.Delay.invokeOnTimeout(long, java.lang.Runnable, kotlin.coroutines.CoroutineContext)"

this is an example of how it arises

myScope.launch {
    myFlow
    .debounce(500)
    .collect {
        Timber.e("received input $it")
    }
}

Anyone know what causes this?

is there a way to get the number of items in a channel (like queue.size) ?