Hello guys. I’m trying to escape callback hell in my current application, and it seems I can’t find proper coroutine-based approach. Almost all existing code is following this pattern:

element.call() {
   service.run() {
      element2.call() { ... }
   }
}

there is 2 requirements: 1. every element or service is invoking callback on proper thread already 2. every call shouldn’t block its own thread, i.e. each callback should exit after invoking next element/service (i can’t use

suspendCoroutine

because of that) what is proper coroutine way to do that?

When I wrap a single value in a flow: Is there a better way than writing

flow { emit(mySuspendingFunction()) }

?

If I create a new coroutine context and use

withContext

to

launch

a bunch of `Job`s in that context, does that mean I don't have to explicitly

join

all those jobs at the end of the block?

https://android.googlesource.com/platform/frameworks/support/+/refs/heads/androidx-master-dev/lifecycle/lifecycle-viewmodel-ktx/src/main/java/androidx/lifecycle/ViewModel.kt Why don't they cancel the scope directly but instead get a reference to the context and cancel that only?

I have a question on how Exceptions are handled in Coroutines that run within a

SupervisorJob

. To me it seems the code has a bug in how exceptions propagate (or not) to the parent of a Coroutine run within a SupervisorJob. I logged the issue here: https://github.com/Kotlin/kotlinx.coroutines/issues/1317 Can someone shed a light on how this is supposed to work? I’m a bit baffled 🙂 Thanks!

if I have a

Flow

of data that has separators in it, is there an easy way to split it into a flow of separated chunks? ie:

"@some data@more data@

->

[some data, more data]

What do you good people think of this? https://twitter.com/pablisc0/status/1148866357188055040?s=19

What's the difference betwenn

channelFlow

and

callbackFlow

?

I've been getting a warning for the following code. The warning is:

Non-applicable call for builder inference

and it occurs on the line that starts with

channel.send

override val animationProgressChannel: ReceiveChannel<Float> = resumeScope.produce {
    lottieAnimation.addAnimatorUpdateListener { animation ->
      resumeScope.launch {
        channel.send(animation.animatedValue as Float) // Non-applicable call for builder inference (channel is highlighted)
      }
    }
  }

If I change it to

resumeScope.produce<Float>

the warning goes away, but the IDE suggests that I "remove the explicit type arguments". Anyone know what's up with that?

Hey guys, kotlin co routine multiplatform mentioned that it is single thread (js style) on native platform. Is it exactly like JS with a delegation principal to a background thread? Or does everything solely run on the main thread ??? If so. Is there a way to "hook" it up to iOS dispatch system in order to have at least one more thread to be able to do computation in the background and updating progress on the main thread for example?

I came across a problem that I cannot figure out how to achieve using coroutines. I have two

async

coroutines that both return the same type. I want to return only the value of the coroutine that finishes first and discard the value of the slower one. I have found that

select

takes care of selecting and returning value the faster coroutine but the other one is not cancelled and coroutineScope waits until the other one returns too. What would be the best approach?

Hello guys, I was trying out flow and did implement following example:

flowOf("one string", "second string", "third string")
            .debounce(300)
            .map { it.trim() }
            .filter { it.length > 2 }
            .flowOn(Dispatchers.Default)
            .distinctUntilChanged()
            .switchMap {
                // Simulate server call
                delay(2000)
                flow {
                    // Just return search term for the moment
                    emit(it)
                }
            }
            .flowOn(<http://Dispatchers.IO|Dispatchers.IO>)
            .collect {
                _viewState.value = it
            }

Now I want to define a unit test for that but I am not sure how to do this for the above flow. Do I need to extract the flow except from the

collector

at the end to a function and then add a test

collector

and verify the values I would expect to get there? Or is there any other idiomatic way?

how soon cease to be Flow an experimental API?

Could someone give me a hint on how to do multicasting with flow? (Multiple subscribers, possibly after flow has finished emitting items, like what

cache

or

replay

would do from Rx)

Under what situations can a thread using

runBlocking

remain parked, even though the underlying coroutines are no longer running?

In other words,

flow.grouped(10)

// should give me List<T> now for each element, containing 10 elements except for the last list`

Hi guys and a big thanks in advance: I want to solve the following problem and I honestly don't know where to start googling it 😕 Lets say we have a database class and it has two methods:

class Database {
    fun prefillDatabase() {
      // launch a non blocking job here that puts some data in the database
      // image this is done on application start
    }

    suspend fun getEntities() {
      // launch a blocking coroutine to get all entities of the database but only AFTER the job in prefillDatabase() completed
      // imagine this is called later in the application on button click.
    }
}

Is this a case for .join()? The job started in prefillDatabase() could already be well completed before getEntities() is called

How can make this network calls run simultaneously using Retrofit and Coroutines

someone knows a good open source project doing redux / mvi with coroutines ? just hacked together a very simplified experiment. As i am very new to coroutines i would be curious what there could be done better on the context of coroutines usage https://gist.github.com/AdrianoCelentano/d6d5833207a2a9db6c7fcfe3e9d67ca0

I’m writing some tests that require a bit more fine grained control around advancing the dispatcher’s clock by using

runBlockingTest

but it seems to eagerly execute despite invoking

pauseDispatcher()

I tried out the sample provided on the kotlinx-coroutines-test documentation but still hitting similar problems. I’m wondering if there’s just something I’m overlooking here? Here’s what I’m running from the documentation sample:

@Test
    fun testFooWithPauseDispatcher() = runBlockingTest {
        pauseDispatcher {
            foo() // <-- this is still eagerly executed
            // the coroutine started by foo has not run yet
            // runCurrent() // the coroutine started by foo advances to delay(1_000)
            // the coroutine started by foo has called println(1), and is suspended on delay(1_000)
            // advanceTimeBy(1_000) // progress time, this will cause the delay to resume
            // the coroutine started by foo has called println(2) and has completed here
        }
    }

    fun CoroutineScope.foo() {
        launch {
            println(1)   // executes after runCurrent() is called
            delay(1_000) // suspends until time is advanced by at least 1_000
            println(2)   // executes after advanceTimeBy(1_000)
        }
    }

If I run this:

import kotlinx.coroutines.*

fun main(args: Array<String>) {
    runBlocking {
        withTimeout(1300L) {
            repeat(1000) { i ->
                 println("I'm sleeping $i ...")
                delay(500L)
            }
        }
    }
}

then I'll get this output:

I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...
Exception in thread "main" kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1300 ms
 at kotlinx.coroutines.TimeoutKt.TimeoutCancellationException (Timeout.kt:126) 
 at kotlinx.coroutines.TimeoutCoroutine.run (Timeout.kt:92) 
 at kotlinx.coroutines.EventLoopImplBase$DelayedRunnableTask.run (EventLoop.kt:307) 
 at kotlinx.coroutines.EventLoopImplBase.processNextEvent (EventLoop.kt:116) 
 at kotlinx.coroutines.DefaultExecutor.run (DefaultExecutor.kt:68) 
 at java.lang.Thread.run (Thread.java:745)

But if I run this one:

import kotlinx.coroutines.*

fun main(args: Array<String>) {
    runBlocking {
		launch{
            withTimeout(1300L) {
                repeat(1000) { i ->
                    println("I'm sleeping $i ...")
                    delay(500L)
                }
            }
        }
    }
}

I'll get another output:

I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...

why the second one doesnot throw exception?

Yesterday I ran into a bug with

runBlocking

In my program I have a top level coroutine dispatcher that uses

runBlocking

as an event loop for the main thread. In the application code, it uses

runBlocking

somewhere else for something more trivial. It seems that the dispatcher for the 2 contexts are sharing some state. It runs a few main loop frames when the second

runBlocking

is called. Moreover, the stacktrace in intellij, which says async stack trace, doesn't indicate any difference when the main loop is executed in this way.

@channel any idea about this? https://kotlinlang.slack.com/archives/C1CFAFJSK/p1563102979226700

what are the rules of thumb about when to make a function

suspend

or just call a coroutine from within that method?

it is possible with simple pipeline? Without adding channels and etc

i tried to start my application with

-javaagent:kotlinx-coroutines-debug-1.2.2.jar

but then i got

java.lang.NoClassDefFoundError: kotlin/jvm/internal/Intrinsics

. any idea what i am doing wrong?

has anybody got a good description of how mockito (and or some nice extension for it) can/should/will handle mocking `suspend fun`s? I remember mockito 1.X (1.95?) simply wouldn't, but now I notice that I've got 2.23 on my classpath. Does that automagically handle mocking suspend-funs for me?

Is it okay for java code to pass an instance of

Continuation

to a kotlin suspend function? Isn't it pretty much the same as using callbacks?

Since the inception of

Flow

, I am somewhat confused about when I should use

Flow

VS `Channel`s and `actor`s. I know that

Flow

represents a cold stream of values, but that stream can also be generated from a hot source, making it a deferrable hot stream. Do you have some specific use cases where you'd use `Channel`s over

Flow

, and why ? It seems to me that

Flow

can handle most use-cases.