Hello, I'm wondering where is it best on Android to launch a coroutine for a simple post to a server. Let's say I have a button on a Fragment that call a function in a Viewmodel that call a function in a Repository. Should I launch the coroutine in the Fragment, the Viewmodel or the Repository?

Does anyone know of some good articles where a suspending function is written that deals with something like IO? I want to learn about composing a suspending function from resources which aren't suspending

Hi there. I have a suspend function in which a resource is opened and later closed in a finally block. Upon cancellation I would expect to receive a CancellationException. But I don't receive any und the finally block is not executed. Does anyone know why?

Seems like I should be able to wrap a ReceiveChannel in a Sequence to pass it to another library.

Hello, I've run into a problem throwing an exception from inside

runBlocking

block. I have a test in which I mock an external service integration throwing an exception. Via

runBlocking

I call the suspending function, which in turn creates a new CoroutineScope using

CoroutineScope(coroutineContext + <http://Dispatchers.IO|Dispatchers.IO>)

and creates many deferred calls using

async

to the mocked external service, then uses

awaitAll()

to get their results. Surrounding this code is a try/catch block, which handles the exception. I've stepped in and all of this is working fine. The problem is when the suspending function returns, the surrounding block declares it exited exceptionally and throws an exception from the runBlocking call. Since I'm handling the exception, what's the right way to prevent the context from picking up the exception?

Hi. I have an issue with

async

,

coroutineScope

and exception handling. When

coroutineScope

is moved into separate function, I am able to catch exception inside coroutine. When

coroutineScope

is declared inside coroutine, I am not able to catch exception. This code works fine:

suspend fun doWork(): Deferred<String> = coroutineScope {
        async(<http://Dispatchers.IO|Dispatchers.IO>) {
            throw IllegalArgumentException()
        }
    }

    // works fine
    fun loadData() = scope.launch {
        try {
            doWork().await()
        } catch (e: Exception) {
            // exception is caught here
        }
    }

This doesn’t.

// crash FATAL EXCEPTION: DefaultDispatcher-worker-3 @coroutine#1
fun loadData() = scope.launch {
    try {
        val deferred = coroutineScope {
            scope.async(<http://Dispatchers.IO|Dispatchers.IO>) {
                throw IllegalArgumentException()
            }
        }
        deferred.await()
    } catch (e: Exception) {
        // exception is NOT caught here
    }
}

What do you think about the naming of the

close

method on

SendChannel

? IMO it’s a bit confusing, because it brings up the idea of a

Closeable

, which is very different (especially since there are plenty of channels which don’t need to be closed because they send indefinitely). The documentation leads me to suggest something like

sendLast

, which I think would convey the intent better.

Anyone has a gist or any suggestions on how to implement a

sample

operator from RX on a

Channel

? I need to discard items from the channel if they come at the higher rate than I specify.

👋 Hi all! Say I want something like

suspend fun request(url: URL): MyDataClass

, but I want to cache the HTTP results so I don’t make requests twice. Anyone know a good example of how to do that? @elizarov’s excellent post https://medium.com/@elizarov/deadlocks-in-non-hierarchical-csp-e5910d137cc has a nice example, but the only way I can think to wrap the channels in a suspend function is using `Deferred`’s. Is that the way to do it? It feels clunky.

Hi all! What is the difference between Job and SupervisorJob in case of Exception Handling?

class Presenter() : CoroutineScope {
        private val job = Job()

        override val coroutineContext: CoroutineContext
            get() = job + Dispatchers.Main

        override fun onDestroy() {
            job.cancel()
        }

        fun loadData() {
            launch {
                try {
                    //loadData().async()
                } catch (e: Exception) {
                    //handle exception
                }
            }

        }
    }

class Presenter() : CoroutineScope {
        private val job = SupervisorJob()

        override val coroutineContext: CoroutineContext
            get() = job + Dispatchers.Main

        override fun onDestroy() {
            job.cancel()
        }

        fun loadData() {
            launch {
                try {
                    //loadData().async()
                } catch (e: Exception) {
                    //handle exception
                }
            }

        }
    }

Correct me if I'm wrong, but usage of

fun CoroutineScope.foo()

basically kills the usage of Mockito in my project, right? It has some support for suspended functions, but not extensions. So,

mockk

is the only answer or there are workarounds? That's quite a change for a big codebase...

What’s the idiomatic way of canceling

runBlocking

? I’m bridging a blocking API that gives me a

CancelationSignal

that can notify when canceled

no more need for proguard-rules and it shrinks to even more than proguard

If I'm adapting some I/O (

HttpURLConnection

, reading an

InputStream

) to a coroutine, it seems like I'd want to do something to suspend the coroutine while waiting on the network or disk. Is there a good example of this?

encapsulate all the work and run it with

async(IO) { .. }

async

is only for parallelization. I avoid recommending it unless you need it because I saw a lot of misuse regarding it that broke structured concurrency and throwables handling.

still, don't use Future. it's like top 3 worst JDK types

Have you ever seen some analytic of launching some jobs in different Dispatchers (Main, Default, IO)? I know the difference between these dispatchers. I'm just interested in comparable data.

Would it seem reasonable to add

object InactiveScope

the standard library, which would be a

CoroutineScope

instance with an job always in a cancelled state? I think this would be useful in cases when we have a scope var which isn’t initialized at object creation, so we could use this object as a placeholder rather than using a null value. I’m thinking about scopes tied to Android activity states, i.e.

activityCreatedScope

,

activityStartedScope

,

activityResumedScope

. Currently the solutions are to use

lateinit

or nullable

var

.

Hello can anyone explain the differences between kotlin coroutines and java NIO ?

Can anyone explain why this coroutine doesn't just emit values forever? Instead count gets to ~20, and then I stop receiving values on the BroadcastChannel. Either this is a bug, or I'm misunderstanding a core concept of how coroutines cancel.

It seems like if an exception is raised in some background thread from Java code and passed through the coroutines funnel, you get useless stuff like this:

Fatal Exception: java.net.SocketTimeoutException: timeout
       at okio.Okio$4.newTimeoutException(Okio.java:232)
       at okio.AsyncTimeout.exit(AsyncTimeout.java:275)
       at okio.AsyncTimeout$2.read(AsyncTimeout.java:243)
       at okio.RealBufferedSource.indexOf(RealBufferedSource.java:354)
       at okio.RealBufferedSource.readUtf8LineStrict(RealBufferedSource.java:226)
       at okhttp3.internal.http1.Http1Codec.readHeaderLine(Http1Codec.java:215)
       at okhttp3.internal.http1.Http1Codec.readResponseHeaders(Http1Codec.java:189)
       at okhttp3.internal.http.CallServerInterceptor.intercept(CallServerInterceptor.java:88)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:147)
       at okhttp3.internal.connection.ConnectInterceptor.intercept(ConnectInterceptor.java:45)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:147)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:121)
       at okhttp3.internal.cache.CacheInterceptor.intercept(CacheInterceptor.java:93)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:147)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:121)
       at okhttp3.internal.http.BridgeInterceptor.intercept(BridgeInterceptor.java:93)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:147)
       at okhttp3.internal.http.RetryAndFollowUpInterceptor.intercept(RetryAndFollowUpInterceptor.java:126)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:147)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:121)
       at support.bymason.magicwand.core.data.PlatformRequestsKt$client$1.intercept(PlatformRequests.kt:18)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:147)
       at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.java:121)
       at okhttp3.RealCall$AsyncCall.execute(RealCall.java:2254)
       at okhttp3.internal.NamedRunnable.run(NamedRunnable.java:32)
       at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1113)
       at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:588)
       at java.lang.Thread.run(Thread.java:818)

Any tips for the kind of breadcrumbs I could be tossing around?

Hi, i have confusion when using

CoroutineScope.cancel()

and

CoroutineScope.job.cancel()

. Here is the CoroutineScope:

val scope = object : CoroutineScope {
        val parentJob = Job()
        override val coroutineContext: CoroutineContext
            get() = parentJob + <http://Dispatchers.IO|Dispatchers.IO> 
}

Observation 1: when Job of CoroutineScope is cancelled, both seemed not active:

scope.launch {
        withContext(Dispatchers.Default) {
            println("result")
        }
        scope.parentJob.cancel()
        println("isActive:$isActive, job.isActive:${scope.parentJob.isActive}")

        // PRINTS isActive:false, job.isActive:false
}

Observation 2: when CoroutineScope is cancelled, only CoroutineScope.isActive seems false. Job.isActive is true

scope.launch {
        withContext(Dispatchers.Default) {
            println("result")
        }
        cancel()
        println("isActive:$isActive, job.isActive:${scope.parentJob.isActive}")

        // PRINTS isActive:false, job.isActive:true
}

Observation 3 (CoroutineScope for Android Fragment):

protected lateinit var job: Job
override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job

launch {
    val result = withContext(Dispatchers.Default) {
          // ...
    }
    this@Fragment.job.cancel()
    // Log.d("$isActive ${this@Fragment.job.isActive}")
    // PRINTS true, false
}

Question: when looking at source code,

CoroutineScope.cancel

and

CoroutineScope.isActive

calls methods of its Job. But in above code,

CoroutineScope.cancel

does not return

Job.isActive

or vice versa. Why this behavior? Is

withContext

changing something?

is there a better way to remove the

if(carId.isNullOrEmpty())

statement here as it looks duplicated code to me.

deferredCarIdResult.await()

can return an empty string like this "" so I return CarNotFound("not found") but when the coroutines timeout I also return CarNotFound("not found")

val carId = runBlocking {
                    withTimeoutOrNull(10000L) {
                        deferredCarIdResult.await()
                    }
                } ?: return CarNotFound("not found")
                
                if(carId.isNullOrEmpty()){
                    return CarNotFound("not found")
                }

When testing coroutines, is there a way to get notified on each context switch?

Hello, http clients that utilize

java NIO

already have asynchronous nature for example Jetty Http Client, asynchttpclient, apache async http client, and etc is it necessary to wrap it with coroutines to do parallel http call ?

Is there any http client library that adopt NIO similar to

java NIO

but using coroutines (or another lightweight thread) instead of native thread ?

So I gave a talk about Kotlin/Native and I was under the impression that there was no

runBlocking

on K/N because I could never successfully get it to import. But @russhwolf pointed out that it is definitely there. I looked in my local

kotlinx-coroutines-core-1.1.1

and lo and behold, there it is. What am I missing about getting it to import in a

common

framework?