I don't know if this error is directly related to coroutines but started when I implement it... One problem here, I have an android app and I've implemented coroutines in one part of it, the problem is that is showing this error when I try to build:

error: cannot access HttpResult
    kotlin.coroutines.Continuation<? super HttpResult<MyEntity>> p2);

bad class file: HttpResult.class
undeclared type variable: R
    Please remove or make sure it appears in the correct subdirectory of the classpath.

I don't know why but byte code could not find my HttResult class (it's a inline class), I don't know if it's a dependency problem, because I'm importing kotlin(v 1.3.0) and coroutines(v 1.0.0) dependencies in two different modules, but I've already tried to change the versions and dependencies but I could not fix it. Do you guys already got a problem like this before?

Hi all, Is there a Kotlin coroutine implementation equivalent to

private val queue = Executors.newSingleThreadExecutor()
//...
    fun submit(data: Data) {
        queue.submit { updateData(data) }
    }

? I was thinking about

private val queue = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
// ...
    fun submit(data: Data) = runBlocking {
        launch(queue) {
            updateData(data)
        }
    }

but it's seems to be running sequentially somehow? Am I doing something wrong?

How should a single thread executor not be sequential?

but with Globalscope.launch no

if you use

.launch

or

.async

, use the

Dispatchers.Unconfined

which should help the coroutine finish before your test does

If I pass in the coroutine scope from the caller, it works fine, but it feels silly to add a parameter for that.

I'm seeing a strange exception in Android with ktor and coroutines. Anyone ever seen this before?

java.lang.IncompatibleClassChangeError: Class kotlinx.coroutines.io.internal.MutableDelegateContinuation implements non-interface class kotlinx.coroutines.DispatchedTask (declaration of 'kotlinx.coroutines.io.internal.MutableDelegateContinuation'

I want to use

ktor

http client with

nodejs

and found out that

Js

engine only works within browser environment. So I took code of js engine and try to adopt it to work with

http

module of nodejs. But it uses streams to read data (an example of how to read data: https://nodejs.org/api/http.html#http_http_request_url_options_callback). And I can't figure out how to do it better. Now I pass all data via channel:

class ResponseReader(response: IncommingMessage) {
    private val chunksChannel = Channel<ByteArray>(UNLIMITED)

    init {
        response.on("data") { chunk: Uint8Array ->
            chunksChannel.offer(chunk.asByteArray())
        }
        response.on("end") { ->
            chunksChannel.close()
        }
    }

    suspend fun readChunk(): ByteArray? {
        return try {
            chunksChannel.receive()
        } catch (exc: ClosedReceiveChannelException) {
            null
        }
    }
}

With this solution I cannot cancel reading data. Also as I understand it misses a backpressure propagation thus if data arrives faster then we can process it may lead to a huge memory consumption.

I’m trying to understand how scopes are ment to use. I have a sample implementation of a

mapAsync

function. The goal here is to process and map the result of every item asynchronously, but I want to cancel all tasks as soon as one of them fail, also I don’t want to cancel the parent scope. What do you think of this example:

is there a way to prevent the scope/job from running twice on the same time?

looking into the implementation of Job() method, it will create

active

job by default

How can I test a suspending function in multiplatform? Suppose I have following function:

suspend fun CoroutineScope.foo() : ReceiveChannel<List<Int>> =
    produce {
        launch {
            val cache = cache.getCachedInts()
            offer(cache)
        }
        launch {
            val network = network.getNetworkInts
    
            if (network.isNotEmty()) {
                cache.cacheInts(network)
            }
    
            offer(network)
        }
    }

I tried

runBlocking

but it seems unavaible in MPP?

this error has nothing to do with coroutines, make sure your app has the internet premission, and the device reaches to the server you are trying to acess

I’m not using retrofit 😉 And yes I do receive 99,99% of them 😉 Sometimes catch does not work. I should really learn to write better English.

Perhaps, rather than directly using suspendCancellableCoroutine {}, I think that it is safer to await () after creating Deferred https://github.com/JakeWharton/retrofit2-kotlin-coroutines-adapter/blob/master/src/main/java/com/jakewharton/retrofit2/adapter/kotlin/coroutines/CoroutineCallAdapterFactory.kt#L87

@elizarov And what is recommended way to handle it?

tryResumeWithException

? I understand this behaviour, avoid exception swallowing, but in this particular case looks that this is the only valid option

Is there a way to reactivate a cancelled job, or do I need to instantiate a new one?

Can anyone explain to me why coroutine exception handling is treated differently between Job and Deferred? Doesn't initially make sense to me why this is desired: https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/exception-handling.md

Question regarding

kotlinx.coroutines.AwaitKt#awaitAll

. From KDocs:

Awaits for completion of given deferred values without blocking a thread and resumes normally with the list of values when all deferred computations are complete or resumes with the first thrown exception if any of computations complete exceptionally including cancellation.

If I understand that right

resumes with the first thrown exception

. But having this example:

val exceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("exception handler $exception")
    }
    val scope = CoroutineScope(Dispatchers.Default + exceptionHandler)
    scope.launch {
        val firstCoroutine = async {
            delay(300)
            println("crashing first coroutine")
            throw IllegalArgumentException()
        }

        val secondCoroutine = async {
            try {
                delay(700)
                println("second coroutine still alive")
            } catch (e: Exception) {
                println("second coroutine try/catch $e")
            }
            "Done"
        }

        try {
            awaitAll(firstCoroutine, secondCoroutine)
        } catch (e: Exception) {
            println("awaitAll try/catch $e")
        }
    }

I was expecting to see

awaitAll try/catch  java.lang.IllegalArgumentException

but instead I see

awaitAll try/catch kotlinx.coroutines.JobCancellationException: Job is cancelling; job=StandaloneCoroutine{Cancelling}@27e6316a

. Could someone pls explain this behaviour?

Hi! I’m in the process of migrating my coroutines from Kotlin 1.2.x (\o/) I see that the concept of Reference (with

asReference()

) is gone, what is the way to go now? Should I use

WeakReference

instead, rely on the coroutine state, or trust the current CoroutineScope?

withTimeoutOrNull(1000) {
    suspendCancellableCoroutine<Unit> { cont ->
        cont.invokeOnCancellation {
            cont.resumeWithException(CancellationException("Hello!")) // 1
            cont.resumeWithException(RuntimeException("Hello!")) // 2
        }
    }
}

Can't find place in documenation where difference between (1) and (2) described

Is there any way to re-run a coroutine automatically without putting it in a while loop, or will I have to wait for cold streams for something like that? I'm trying to build in some automatic error handling, and if a coroutine errors out due to something like a network exception, a common behavior would be that the user can select that the request would be re-run.

For catching exceptions with coroutines with the usual: catch (exception: Exception) What do people go about lint flagging this as too generic an exception? Just suppress the warning all the time? 🙂

coroutines generally shouldn’t throw exceptions

Hey guys, I've got a question about parent-child coroutines: what do I do if I want to start a coroutine that might not complete: should I set its parent to the caller or not?

//producer function following conventional (?) coroutine parent-child-ing as per Romans Coroutines part II at kotlinconf 2018
fun CoroutineScope.longRunningProducer(): RecieveChannel<Info> { ... }

//then a user
fun someUser(){
  println("started!")
  runBlocking {

    val selfScope: CoroutineScope = this@runBlocking
    val producer: RecieveChannel<Info> = selfScope.longRunningProducer()

    for(item in producer){
      if(businessLogic(item)) {
        //bail!
        break;
      }
      else //...
    } 
    println("almost done!")
  }
  println("done!")
}

if

longRunningProducer

never returns never stops producing values on its returned channel --which is reasonable-- and dispatches a child coroutine that runs forever, then your output will be

started!
almost done!

because the

nestedEventLoop

wont close until its children are done. What I'd like to have happen is for an abandoned

longRunningProducer

coroutine to simply get garbage collected, but I guess that means I gotta be careful with

weakReferences

and such, yeah?

Dispatchers share threads, you run both of those coroutines inside a coroutine that uses Default dispatcher Each of dispatchers has own thread policy, but try to reuse existing thread to avoid context switch More details: https://github.com/Kotlin/kotlinx.coroutines/issues/261

Now in rare conditions line 6 is being executed after I cancelled the job.