and if the awaitClose lambda would be called properly in this case

Hi, i want to schedule coroutine for every 5-9 minutes in my app, my actual requirement is to show ad after 5-9 minute so that's why i want to use coroutine to

delay

execution for random time between 5-9 mins, So what is best way to do it with kotlin in android ? Simply using

delay

or

flows/channels

?

hey folks! I have a list of parallel computations. How would I write a function like this? Can’t really wrap my head around it

fun <T> List<Deferred<T>>.toFlow(): Flow<T>

I want the flow to emit values as soon as they become available

it’s so weird that

callbackFlow

just calls

channelFlow

🙂

I have the following use case: I fire off a number of REST calls to a very slow REST service, and want to return a filtered list of the results. So currently I'm creating a channel, launching each REST call in a coroutine, and writing the result of each to a channel. I then iterate through the channel, do a manual filter via an if statement, and add any filtered result to a mutable list. This feels a bit imperative to me - is there a better way of doing this that doesn't for example, rely on a mutable list and manual filtering ? Should I be using Flow and filters instead ?

val output = mutableListOf<String>()
            for (something in channel) {
                if (some condition based on something) {
                    output.add(something)
                }

            }

anyways, given I wrapped the executor with IO.. that was kind of my rationale, thread spawn + switch from IO to IO seems pointless and wasteful, I liked that it didnt apply threads

Just to make shure I got that right, I'd like to know if this chain does the following: - Run updateNotifications on each emission - If the function takes too long to execute, buffer 1 emission and ignore all others - When the function finishes, run it again if there's a buffered emission

flow()
        .conflate()
        .buffer(1)
        .onEach { updateNotifications() }
        .launchIn(GlobalScope)

Hi, if I have two existing scopes and want to launch a coroutine that cancel if any of the two scopes is cancelled, how can I do it?

hi

runBlocking {
      println("start main")
      execute(coroutineContext) {  println("some long operation")  }
      println("main done")
}

fun execute(context: CorouitneContext, action: suspend () -> Unit) {
      action.startCorouitne(Continuation(context + <http://Dispatchers.IO|Dispatchers.IO>) {
            println("corouitne complete")
     })
}

so when execute : start main main done, i expected to see : corouitne complete "startCorouitne" start a new coroutine in my case i bound it to runBlocking scope (with context as parent) and with dispather IO, so i expect to see "coroutine complete" in console ?? i think this new coroutne created by startCoroutine its not bound to runBlocking so when main is finish its ignore this corouitne

Does

Flow<T>

support multicasting yet?

How can I manage Error in coroutines in case of API requesting? Using RxJava, we can easily manage error in onError operator. I want to know is there any operator like RxJava

This lambda with receiver stuff in the kotlinx coroutines API is playing with fire.

Is this code thread safe? If update() is called from different threads it will use the context of Example: CoroutineScope so it will never be inside update() from two different threads correct?

^ this inspired me to test whether switching threads in a coroutine flushes the cache similarly to java

synchonized

block. Here's the test, results in thread

import kotlinx.coroutines.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.yield

class Test {
    var i = 0

    suspend fun countWithThreadSwitching(){
        repeat(10) {
            i++
            delay(1) //yield() didn't make coroutine resume on another thread
        }
        println(i)
    }
}

fun main() = runBlocking {
    coroutineScope{
        repeat(100) {
            launch(Dispatchers.Default) {
                Test().countWithThreadSwitching()
            }
        }    
    }
}

I wish there was a shorthand/more optimized version of this:

someFlow
  .conflate()
  .broadcastIn(someScope)
  .asFlow()

So far, I understand the basic about coroutine topic (CoroutineBuilder, CoroutineScope, Dispatchers. etc.). However, I find one topic in coroutine that is difficult for me to understand. It’s about the cancellation of coroutine(s). I wrote the detailed question on StackOverflow here: https://stackoverflow.com/questions/57335077/how-to-properly-handle-cancellation-in-coroutines-computation-code If you guys have time, please help me to answer the question. I will re-post the question on reply thread.

Is there an established pattern for memoizing async tasks? within some coroutine scope? if the scope is per request, it would be great to avoid duplicate work etc

Room suspend function with Livedata not working. Conversion error is occurred while compiling. Room version is 2.1.0. PS: I resolved this error by removing the suspend keyword. Any other ways to resolve this error.

i just stumbled across this sentence in the

coroutineContext

documentation "By convention, should contain an instance of a job to enforce structured concurrency.". What does it mean? It'spossible that a context does NOT contain a job? what are the consequences if a job instance is missing?

I have a problem wrapping my head around coroutines and wrapping coroutines around an existing callback-based API: https://gist.github.com/Bombe/fb1ec487ea03614d96e9d152f21e64cc – the exception from line 55 is being thrown from line 55 and not from line 57, like I’d expect. What’s going on there?

Today I found there are two functions in coroutine package;

coroutineScope

or

supervisorScope

. When should we use it instead of using

CoroutineScope(SupervisorJob())

? How do we cancel

coroutineScope

or

supervisorScope

?

I don't understand why this code throws

ClosedSendChannelException: Channel was closed

, can someone explain it to me?

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

@UseExperimental(ExperimentalCoroutinesApi::class)
fun main() = runBlocking {
    val scope = CoroutineScope(Job())
    val f = channelFlow {
        launch(scope.coroutineContext) {
            repeat(10) {
                delay(200L)
                send(it)
            }
        }
    }
    f.collect {
        println(it)
    }
    delay(3000L)
}

I have the following setup:

val flow get() = channel.asFlow()
    private val channel =
        BroadcastChannel<T>(???)

I want that each time a user of the API calls

flow.collect{}

the last value is received on collect, but no values are lost if they are received in quick succession and the sender should suspend if needed for this to happen. With

CONFLATED

I get the last value emited on each new

collect

and with

BUFFERED

I get the "suspend if needed, don't loose any values" behaviour. Is there a way to achieve what I want?

I can't seem to get

suspend operator fun <T> invoke(block: suspend () -> T): T {
        // ...
    }

to work. Does

invoke

work with

suspend

keyword?

Is there a less

try

/

catch

oriented way of accessing the result of

async

? Thinking of something similar to

Result

I’m trying to coerce Realm to work with coroutines, but my

ReceiveChannel

is coming back already closed from this signature

@ExperimentalCoroutinesApi
override fun CoroutineScope.messageUpdateProducer(): ReceiveChannel<List<Message>> = produce {
    realm.where(RealmMessage::class.java).findAll().addChangeListener { results ->
        offer(results.takeIf { it.isNotEmpty() }?.map { it.messageActual } ?: listOf())
    }
}

It looks like, from the documentation that if the producer encounters an error, it will close automatically, but I’m not sure what’s generating an error in there. I’m handling all the null cases and my crashes are only generating a stack trace internal to the channel mechanism.

kotlinx.coroutines.channels.ClosedReceiveChannelException: Channel was closed
        at kotlinx.coroutines.channels.Closed.getReceiveException(AbstractChannel.kt:1094)
        at kotlinx.coroutines.channels.AbstractChannel$ReceiveSelect.resumeReceiveClosed(AbstractChannel.kt:993)
        at kotlinx.coroutines.channels.AbstractSendChannel.helpClose(AbstractChannel.kt:332)
        at kotlinx.coroutines.channels.AbstractSendChannel.close(AbstractChannel.kt:271)
        at kotlinx.coroutines.channels.SendChannel$DefaultImpls.close$default(Channel.kt:95)
        at kotlinx.coroutines.channels.ProducerCoroutine.onCompleted(Produce.kt:98)
        at kotlinx.coroutines.channels.ProducerCoroutine.onCompleted(Produce.kt:91)
        at kotlinx.coroutines.AbstractCoroutine.onCompletionInternal(AbstractCoroutine.kt:102)
        at kotlinx.coroutines.JobSupport.tryFinalizeSimpleState(JobSupport.kt:274)
        at kotlinx.coroutines.JobSupport.tryMakeCompleting(JobSupport.kt:784)
        at kotlinx.coroutines.JobSupport.makeCompletingOnce$kotlinx_coroutines_core(JobSupport.kt:764)
        at kotlinx.coroutines.AbstractCoroutine.resumeWith(AbstractCoroutine.kt:111)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:46)
        at kotlinx.coroutines.DispatchedTask.run(Dispatched.kt:238)
        at android.os.Handler.handleCallback(Handler.java:739)
        at android.os.Handler.dispatchMessage(Handler.java:95)
        at android.os.Looper.loop(Looper.java:135)
        at android.app.ActivityThread.main(ActivityThread.java:5223)
        at java.lang.reflect.Method.invoke(Native Method)
        at java.lang.reflect.Method.invoke(Method.java:372)
        at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:899)
        at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:694)

Retrofit does not support Flow. So if I need to merge concurrent requests using 'flatMapMerge' what is the right way to do this?

I have a use case for

BroadcastChannel

but I'm not sure how to expose it. Should I literally expose the

BroadcastChannel

for users to call

openSubscription()

or should I wrap this up?

Is there a way to forcefully terminate a coroutine?