This message was deleted.

How would you all expose state stored inside of an Actor? Ideally, I’d be able to observe changes to variables inside the Actor from other classes. I’ve got this implemented already in Android using LiveData, but it’s a bit hacky

Anybody else having issues with debug breakpoints inside coroutines?

Is there some kind of

blockingProduce

? I have an async callback that I want to wrap into a channel

It looks like kotlinx-coroutines-io is missing the 0.25.0 release. I checked the kotlin bintray and maven central

Hi all, what's the best approach for a long-running coroutine with multiple "receivers" ... let's say I have a coroutine which calculates some complex value or fetches something via network. I have multiple locations that might call this coroutine. But instead of starting this coroutine n times it should only run once an deliver the value to all receivers. Is a ConflatedBroadcastChannel here the best architectural choice? So putting the value into the channel so that everyone can take it when needed?

Hello guys, My program calls a function inside a coroutine, which calls a plugin. Now this plugin requires to wait for a specified period of time. I tried java.util.Timer and it didnt work(i put 60 secs but even after that it didnt work). Now i think i'll try this https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/java.util.-timer/schedule.html . But what Im unsure about is that if a plugin can have a coroutine call inside it(also, im not sure if Schedule is a coroutine thingy). Thanks.

How to keep an active subscription to the channel? Documentation doesn’t mention BroadcastChannel/ConflatedBroadcastChannel and I need to keep active subscription to one of those

by the time that this code reaches the oncomplete listener, requests to an API which use the

carsService

object have already went out

I have a generic

retry

function that takes an

action

lambda. Is there a way for me to define this function in such a way that the

action

lambda can be either suspending or non-suspending depending on the caller?

Hello. I want to use

async

coroutine builder to execute some blocking code in parallel. I use my custom thread pool for that. But is it ok to call regular (non-suspending) function inside

async

?

fun doSomething(s: String): String {
// blocking code
}

val def1 = async(myContext) { doSomething("a") }
val def2 = async(myContext) { doSomething("b") }
// ...

println("${def1.await()} ${def2.await()}")

When you have something like this:

val dispatcher = Executors.newFixedThreadPool(64).asCoroutineDispatcher()

runBlocking(dispatcher) {
    launch {
        // do something
    }
}

I thought

launch

in the example would automatically inherit the

dispatcher

, but I see

launch

uses the

CommonPool

if it is implemented like this. Is there a way that this automatically inherits the parents dispatcher or should it always be used like this

launch(coroutineContext)

?

Does this talk to anyone ?

> Could not parse module metadata <https://jcenter.bintray.com/org/jetbrains/kotlinx/kotlinx-coroutines-core/0.25.0/kotlinx-coroutines-core-0.25.0.module>
            > Unsupported format version '0.3' specified in module metadata. This version of Gradle supports format version 0.4 only.

Can anyone recommend a good talk on coroutines? especially one that focuses more on how they work rather than how to use them 🙂

My usecase is to build a lazy cache with a ConflatedBroadcastChannel where when a subscriber is suspending on

receive()

, some code that will send stuff into the channel is executed

i have a bit of parallel processing along the lines of

val targetFiles = Collections.synchronizedMap(mutableMapOf<String, File>())
val features = Collections.synchronizedList(mutableListOf<SKFeatureComposite>())

val jobs = mutableListOf<Job>()
for(...) {
   jobs += launch {
      //do work here
      targetFile[id] = someFIle
      if(feature != null) {
         features += feature
      }
   }
}

jobs.forEach { it.join() }

is there cleaner ways to handle collecting data that lets me juggle less mutable collections ?

If i want to call my

search

function after user finish typing (by being idle for >=400ms). is this the correct way to do this with coroutines?

fun onKeywordChanged(keyword: String) {
  keywordJob.cancel()
  keywordJob = launch {
    delay(400)
    if (!isActive) return@launch
    search(keyword)
  }
}

compile "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.25.0-eap13"

This is correct, right?

so in my code currently it seems to ignore exceptions.. prints them but does not halt the app i start my main with runBlocking and do parallized wirk with launch() in a FixedThreadPoolContext one way i found to handle it is to wrap the entire code in try catch and do couroutineContext.cancel() on failures, but that seems very.. weird to stop working that suddenly

is there any better option than Collections.synchronizedList(mutableListOf()) in stdlib or in libraries ? i would feel a lot safer if i knew that i do not have any nasty ConcurrentCoModificationExceptions waiting for me due to forgetting to synchronize() on the list somewhere

hi guys, someone knows how to close a subscription from ConflatedBroadcastChannel properly? in my case for some unmanaged android behavior we openSubscription() many times so we’re creating a lot of those

@elizarov Do you plan to release an updated

kotlinx.coroutines

EAP in order to avoid the pre-release warnings with Kotlin 1.3-M2?

Does anybody have experience with maintaining both coroutine-based and non-coroutine-based codebases in a library? I.e. marking a random library method with

suspend

is a breaking change, since the callers now have to wrap it inside a coroutine builder. Ideally I'd like library users to opt into coroutines if they decide to and be able to use the library as is if they don't, and avoid duplicating code add coroutines support. Any OS projects that do this already?

Just to confirm, the coroutine API is already stable as of 1.3-M2 correct?

I'm a bit confused about the dependencies of the new kotlinx-io -- the github page https://github.com/Kotlin/kotlinx-io references kotlinx-coroutines-io but this doesn't seem to exist any more?

will there be a

0.25.3-eap13

?

@elizarov is there any news on https://github.com/Kotlin/kotlinx.coroutines/issues/462?

message has been deleted

Is there a way to "wake up" a coroutine that is currently suspended due to having called

delay

so like this:

launch {
   println("This is called right away")
   delay(1, YEARS)
   println("I want this to happen when a criteria is met")
}

if(criteria) {
  cancelDelay()
}