I think I done something wrong 😞

AVERTISSEMENT io.netty.bootstrap.ServerBootstrap$ServerBootstrapAcceptor forceClose Failed to register an accepted channel: [id: 0x01a0436e, L:0.0.0.0/0.0.0.0:8080]
java.lang.IllegalStateException
	at io.vertx.core.net.impl.VertxEventLoopGroup.next(VertxEventLoopGroup.java:47)

I miss something about Coroutine, it return Unit instead of my MutableList and I got this inside my logs:

java.lang.IllegalStateException: Job StandaloneCoroutine{Completed}@6daf38a4 is already complete, but is being completed with kotlin.Unit]]`

When calling:

suspend fun getValidNextEvent(node: Node, messageBody: MessageBody): MutableList<Event<MessageBody>> {

        return suspendCoroutineOrReturn { cont ->
            val eventsToEmit = mutableListOf<Event<MessageBody>>()
....
            cont.resume(eventsToEmit);
        }

    }

I'm really just interested in the latest offer

How can I close a channel from which I am receiving values in a coroutine/suspend func as response to canceling the coroutine?

so I have a pretty weird use case, but has anyone ever had a "java.lang.VerifyError: Bad type on operand stack" exception when using coroutines?

Hi, is there a way to also intercept when a coroutine suspends. I got it working for resume with the CoroutineInterceptor. The reason why I need this is for instructing the logging framework with fields (https://logback.qos.ch/manual/mdc.html) for logging.

Is it possible to create a Deadlock passing down

coroutineContext

of a parent to child coroutines?

Hi guys, how can I mock suspend function? For example, I would like to mock:

val mockContextManager = Mockito.mock(ContextManager::class.java)
        Mockito.`when`(mockContextManager.get(1)).thenReturn(2)

where get is a suspend function

Do you have breakpoint issue inside suspend function? sometimes there are never call, or I can’t see variables ...

In decompiled final class's code, I can see that

suspend fun

is

open

. What's going on, why?

📣 📣 📣

kotlinx.coroutines

version

0.20

for Kotlin 1.2.0 with sequence-like extensions for channels, improvements to parent-child relations, more Android support and fixes. See full changes here: https://github.com/Kotlin/kotlinx.coroutines/releases/tag/0.20

upgrading to coroutines 0.20… mostly seamless 🙂 it also introduced a couple compilation errors, which was the first time an upgrade has done that

@kevinherron The approach with parent job suggest by @bj0 is indeed intended replacement if you need ability to cancel and join your actors. Alternatively, you should consider closing your actors via

close

that performs a graceful closing (letting actor finish all the processing). However, the

close

does not assume that you will be joining them.

@elizarov i meant if you use

close

instead of cancel, so you let it finish all processing

with

coroutineContext

what do you mean in this context? literally accessing the field on your parent coroutine, if you’re in one of its blocks

@elizarov But in the docs, it says that

Unconfined

is the equivalent of not using a scheduler in Rx, and it's very common, say in android, to want to run mainly on the current thread (with fan out/in, that SHOULD block the current thread only for the result), like in an IntentService that already has a working thread (that shouldn't stop until all tasks are finished, otherwise there could be leaks...)... in that case, is it better to use

runBlocking

or

launch(Unconfined)

, or is there no difference...? There's no clear rules about this in the docs, only 'hints' that seem a bit contradictory at times... Also, when is there a need for the top level

yield

function I mentioned before? Does it have to do with certain contexts being CorotineStart.dispatched by default or not?

Say

suspend fun getX()

needs to be able to be run either in main thread context using

CommonPool

, or in an existing

coroutineContext

or in an already existing worker thread in a blocking fashion, depending on from where it's called, what's the recommended way to do each, and when would I have to

yield

?

With Rx, it's very simple and clear with

subscibeOn

and

observeOn

to do all this (but coroutines are much better in other aspects... 😉 ). In coroutines things seem much more complex in this aspect, and the 'danger' you mentioned... does that also exist in rx?

@dave08 The rule of thumb for coroutines is simple. If you have to ensure that certain code runs in a certain context (because it touches some confined shared mutable state like UI classes or because it is blocking), then you specify the context explicitly for this code. If your code is pure and does not care about its execution context (which should be true for most of the well-designed code) , then you leave the context specification out and go with default.

Hi, could anyone hint me at how I can convert an API with a God Callback to coroutines? This API is Bluetooth Low Energy GATT (General ATTribute) in Android, where you can only pass a

BluetoothGattCallback

instance with the overriden methods you'll need once, when connecting, and the connection result, the attributes discovery and read/write operations are passed to this callback. What I aim at is to use coroutines to handle failures without callback hell, in a procedural style, and to handle success this way too. The issue that I have is that this

BluetoothGattCallback

listens to too many different things. When connecting, I'm just interested in the connectionState callback. When writing data, I'm just interested in waiting for completion or error and knowing if it succeeded or failed, when reading data, just need the data, or exception... Is it possible to separate these things from this god callback? For reference, here is the key method with the two

BluetoothGatt

and

BluetoothGattCallback

key classes in its signature:

<https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#connectGatt(android.content.Context>, boolean, android.bluetooth.BluetoothGattCallback)

(select the whole link to get directed to the right method, slack doesn't like this url formatting) Please, reply in thread since this is quite specific to Android, so this channel doesn't get too cluttered

@elizarov, I just wanted to shout out a big thank you! I just watched both your talks from kotlinkonf and they do really help with understanding coroutines both on low and high level. After them reading the guide is much easier. Great job on preparing and delivering the information, much appreciated!

Can you use CoRoutines on Kotlin onlinez?

Silly question 😄 I'd like to

await

a block execution to not block the current thread, but I don't care about the result value. Is there a better practice for it than calling

await()

without using the result?

Is the statement in the reactive guide:

Note, that we can replicate the same behaviour that we saw with channels by using Rx publish operator and connect method with it.

really true? In Rx,

publish

makes a

ConnectableObservable

which I would think is the equivalent of a

BroadcastChannel

? Also is there a simple way of making a

produce { }

for a

BroadcastChannel

?

i like that but its not really different. slightly more terse. im doing asyncronous select hell, trying to channelize the inputs from disjunct packets to lines to headers to .. FSM progression. is there a "best" way to simply have var callback={it->....}; chan.foreach{callback(this)}

Hi guys, I’m using Kotlin 1.2, tried to introduce coroutines to my application, but but I get this error: java.lang.NoClassDefFoundError: kotlin/coroutines/experimental/CoroutineContext$Element$DefaultImpls

instead of

while / try / receive

you can just use a

for

loop over

channel

. As for testing,

runBlocking

is generally used to make the function wait until the coroutines are done.

Plain

receive

and

for (x in channel)

loop are both non-terminal

So @elizarov I managed to test it but I had to remove the

actor

construct. Now I am calling the

suspend

fun

loadProducts()

from a

runBlocking

block directly. The question remains how I could make the

runBlocking

block to wait for the

consumeEach

in

loadProducts()

to finish, controlling somehow the mock

channel

I return from the mocked

loadProducts()

in my test. I hope I did explained it well. Thank you in advance for your interest.