If you're going to immediately

await

on an

async

job, you might as well just use

withContext

How can we use `Coroutines with Dispatchers.IO`inside Android Service instead of

HandlerThread + Looper

? I tried and it worked for limited use case but not sure about generic use case. I feel it is not a good practice and will not work for all cases? Is it?

Are there any drafts \ keeps for cold channels?

I'm still using rx as I need it to be cold most of the times and I find channels too complicated. Are there other stream abstractions built upon coroutines?

So I upgraded to 1.0.0 and I'm getting experimental warnings for all sorts of coroutine APIs (

produce

,

UNDISPATCHED

, etc). According to the docs I can opt in via "the compiler argument -Xuse-experimental=kotlin.Experimental" but I can't for the life of me figure out how to specify this in my gradle files. I tried adding this to my root build.gradle, but it's not working:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
        kotlinOptions {
            freeCompilerArgs += [
                    '-Xuse-experimental=kotlin.Experimental'
            ]
        }
    }

Does anybody know how I can opt-in properly?

How do I initiate

actor

properly? I tried:

GlobalScope.actor { }

But it is annotated with

ObsoleteCoroutinesApi

Since the

onCompletion

argument of

produce

is marked internal api, and it is not possible to

CoroutineStart.ATOMIC

with

produce

, how can one make sure a given resource is always released?

When converting a listener to a channel is there a better way than creating a channel inside produce and then iterating it like here? https://github.com/Beepiz/BleScanCoroutines/blob/master/core/src/main/java/com/beepiz/bluetooth/scancoroutines/experimental/BleScanner.kt#L44

I tried to do the same with sensor manager - it feels kind of complicated: https://github.com/PaulWoitaschek/Voice/commit/58abc5302af30328e6f11593aed5deac78aa1e5b

Hey gents, I'm writing a little adaptor for grpc (which, has anybody made this into a library?

k-grpc

?

grpc-k-extensions

?), my first implementation looked like this

is there a way to configure the thread names used by the underlying pools and executors for the coroutine dispatchers provided by stdlib?

Before migrating from coroutines experimental, i was able to use the launch as in the above snippet. Trying to do the same on Kotlin 1.3 and am not able. What am i missing?

Then

var currWork: Job = null
launch { if (cancelCurrWork) currWork?.cancel() }
currWork = doWork()

?

It seems

withContext

doesn't throw any

CancellationException

before running the passed block even if the context is cancelled. I thought it checked before, and after running the passed block. Is this an intentional change, a doc misreading or a misunderstanding of the source code from me?

i've finally found how to disable IDE warnings:

compileKotlin {
    kotlinOptions {
        freeCompilerArgs = ['-Xuse-experimental=kotlinx.coroutines.ObsoleteCoroutinesApi']
    }
}

Hello. I'm trying to make 3 http requests concurrently and return single result(like rx

zip

) with coroutines. Api calls are

Deferred<T>

with

retrofit-coroutines-adapter

. But they don't seem to execute in parallel. What am I doing wrong?

if i need a library that still uses the expermental coroutines packages, can i still upgrade to kotlin 1.3?

A way to launch new coroutines inside a coroutine, without creating a new scope (i.e. using the current coroutine's scope), seems to be

CoroutineScope(coroutineContext).launch {...}

. 1) Is there a better way? 2) Is this a bad practice?

I don't have a concrete reason, just exploring possibilities. However, an abstract example would be: if I want to explore some parallelism by launching children coroutines inside a coroutine, the immediate way seems to be by using a

coroutineScope{ launch {...} launch {...}}

. However,

coroutineScope

suspends until all the children coroutines are completed. Probably most of the times this is a good thing, however there may be situations where I want to continue without waiting for the child coroutines to end.

Hi everyone, I have a problem, pls help to clear it. How multi coroutines work in cpu?

In android i am launching coroutine using

launch

builder but now inside this builder i'm confused with

async

,

withContext

and

coroutineScope

like what is best for which situation? can please anybody tell me when to use one of them inside

launch

?

In all these coroutine talks they talk about fan-out fan-in like its a common term. What does that mean?

Hi guys, is there any doc around on how to execute a suspend function from Java?

hi guys I have a coroutine base question on SO can I post it on here?

when using

produce{}

for a finite sequence of items, the docs say to call

SendChannel.close()

to indicate no more items will be sent. But isn’t the common case for no more items to be sent once

produce

lambda has completed naturally? In which case, why is

SendChannel.close()

not done automatically?

Why

ReceiveChannel.toSet()

and

ReceiveChannel.toMap()

are

ObsoleteCoroutinesApi

but

ReceiveChannel.toList()

is not?

Idiomatic way to add Coroutine scope to a function that is already an extension function of something else? Take it as a parameter?