Is it okay when you pass coroutine scope in the constructor parameters for classes without lifecycles?For example a paged list data source then, use factory class to add the parameters to the data source class, then handle the lifecycle of the coroutine in a view model or fragment/activity

Hello, I have a question. I want to perform a simple background job using coroutines. Currently I have an

object

that does stuff and writes to a status object that I can then read to know the state of the job (like how many items are processed etc). This is obviously crap because I currently block the entire server. I now want to redo this the right way. I use

launch

since the job doesnt return anything, it just does stuff. I know I can ask that job

isActive()

and stuff like that but how can I ask access that jobs memory, like shared memory? I just want to ask how many items it has processed etc so I can show that in my frontend.

I found the current one pretty hard to grasp when I looked up how to do 4 things in parallel and collect their results

Yes, it should be improved. It is hard to get started using existing documentation. You basically need to understand all of it (a lot) to get a good grasp of various patterns and practices. However, it is not that straightforward on how exactly to improve it. The current docs assumes you have have thread/async programming experience and builds upon that (for example,

GlobalScope.launch

is what you typically do nowadays), showing how to improve your code with structured concurrency a bit later. If we jump right away into the structured concurrency, as you suggest, then there is a risk it’ll look totally like magic for readers, so that people with a prior threads/async experience will have no way to bridge it to their existing knowledge.

I wrote a Coroutines intro a couple of months ago if that’s of any help https://antonis.me/2018/12/12/an-introduction-to-kotlin-coroutines/ Part of this was inspired by @elizarov talk on kotlin conf last year

Hi, what is the recommended way on Android to handle exceptions that occur inside

GlobalScope.launch

? A

CoroutineExceptionHandler

?

Hi, I want to wrap a legacy listener that fires multiple times into a

Channel

. However I'm a bit lost here. Here's the simplified pseudo code:

suspend fun Query.onSnapshotAsync(scope: CoroutineScope) =
    scope.produce {
        addSnapshotListener { snapshot ->
            send(snapshot.documents)
        }
    }

however at

send()

it gives me the error

suspension functions can be called only within coroutine body

. Usually I wrap legacy callbacks with

suspendCoroutine

but in this case this is not possible since the listener fires multiple times but a Continuation can only be resumed once. What is the best practice here?

What is the recommanded way to test suspending functions that are members of a class ? In the code below my test function is suspended indefinitely and the

assertThat

statement is never reached. Why ?

What happened to GlobalScope.future{} ? I thought that was the way to interop w/ Java so Java can call a coroutine?

I am still struggling with some basic concepts of coroutines. What is the purpose of having CoroutineScope when there is already CoroutineContext?

Is there a coroutine-flavored equivalent of a j.u.c.semaphore? I have a known amount of work to send over the network, and it can only be handled of batches of at most 10, so I’d like to simply spawn a zillion coroutines, each of which will handle 10 items, but to avoid overwhelming the other end I’d like to limit the concurrency ala a semaphore.

can you guys advise what’s an idiomatic way of handling a suspending initialization? Let’s say my class exposes a

search

function and this function depends on a series of initialization steps that the instance has to perform before being able to actually search and return results. How would you handle this using coroutines? Would you have an

initialize

function that returns a

Job

or would you simply mark

search

as

suspend

and “hide” the suspension as an implementation detail waiting internally for the initialization job to complete? Or would you tackle this issue in a completely different way?

I am just trying to learn Kotlin coroutine. This is what I have so far. I am trying to load several data using Kotlin to speed things up. However, I am not sure whether this is the right approach or not in terms of error handling. Does it leaks memory if any of the coroutine fails? Is there a better way to do this?

Hi. I have some questions about the coroutine scope. What is the difference between the scope created with

coroutineScope()

and the scope created with

launch()

or

async()

? Both

coroutineScope()

and

launch()

create new instance of CoroutineScope (maybe AbstractCoroutine), the both do create new coroutine scope, right? If the coroutine throws an error, the parent coroutine will be canceled too. But if the coroutine inside of the scope created by

coroutineScope()

throws an error, the coroutine that called the

coroutineScope()

will not be canceled. Why? Is it that the coroutine created by

coroutineScope()

is not a child of the coroutine that did call

coroutineScope()

? Or there is something different between the two scopes? This very confuses me to understand what the coroutine scope is.

Has anyone had troubles with ProGuard after adding Coroutines? After adding the Coroutines dependency I am getting this ProGuard error message when building:

Shrinking...

Removing unused program classes and class elements...
  Original number of program classes: 9596
  Final number of program classes:    9596

Obfuscating...

Printing mapping to [/Users/jenkins/Public/workspace/Android-App_ck_ANDROID-313/app/build/outputs/mapping/playStore/release/mapping.txt]...

Warning: Exception while processing task java.io.IOException: java.util.EmptyStackException
Thread(Tasks limiter_1): destruction

> Task :app:transformClassesAndResourcesWithProguardForPlayStoreRelease FAILED
FAILURE: Build failed with an exception.

Is there documentation on how to handle errors properly with channels? https://kotlinlang.org/docs/reference/coroutines/exception-handling.html doesn’t mention channels, and Channel docs has nothing on error handling

Hey guys, do you know any library that provide coroutine friendly (or async) high level api for file system operations, like copy file, save file. Something like an async version of apache

commons-io

?

Other than the obvious of passing it in as a parameter?

Is there some sort of

dispatch_once

in the Kotlin Coroutine world?

Hey I am getting

JobCancellationException

and I am not sure what is the reason. My only hypothesis is that I am starting and canceling multiple times function that is in suspended state 🤔 but honestly I am not sure… Can somebody throw more light on this? What is the reason for throwing this exception?

I have a function that divide and conquers a CPU-intensive task using coroutines. I want to test that it actually runs concurrently in a unit test. If I were using threads, I would have called the function tasks that awaited a common

CyclicBarrier

. How can I achieve something similar with coroutines?

I've setup Coroutine Scopes inside our Presenter class, where every child coroutine has one of 2 parent coroutines. I'm seeing some really odd behavior around `CoroutineExceptionHandler`s, where after we receive a single exception, every child coroutine immediately fails with the same exception again. Code snippets on thread.

What’s the best way of spawning children coroutines that do not propagate cancellation upwards. I don’t want to wait for completion and don’t care about canceling either. a) use a dummy Supervisor b) use GlobalScope.launch c) register a CoroutineExceptionHandler on the launch builder

Is it possible to set multiple CompletionHandler on a job?

Can a project that uses stable coroutines (

1.1.1

) include a library that uses experimental coroutines (

0.30.2

)?

How concerned should I be because of this? https://www.reddit.com/r/Kotlin/comments/ar29yj/coroutines_cause_memory_leaks/

I want to register some information to flow along a chain of suspending method calls. Kind of like putting something in thread local storage when using a thread request e.g. tls["workingOn"] = "transforming quote #102345 to order". we've used something like this with nodejs before (https://github.com/vicanso/async-local-storage)