What causes the IDE to recommend using

withContext(Dispatchers.Default)

over

async

? Is

withContext

more optimal, somehow?

kotlinx.coroutines doesn’t seem to have a version out that’s binary compatible with the latest kotlin/native compiler. When can we expect to see such a release?

According to a recent article on /r/AndroidDev by Sean McQuillan, all suspending functions should be main safe and use

withContext(...)

depending on what they’re doing. If

withContext(<http://Dispatchers.IO|Dispatchers.IO>)

always runs on a background thread, how can we ensure single threading for testing purposes? Even

runBlocking()

doesn’t affect this.

What’s the best way to cleanup things that you create in a coroutine? I’m especially worried about removing created resources when being cancelled.

myScope.launch {
    // If the job is canceled before createResourceSync() returns the resource is lost in transit
    val resource = withContext(Dispatchers.default) { createResourceSync() }
    try {
    } finally {
      resource.delete()
    }
}

If you create a class that implements CoroutineScope and keeps a local property to a

Job

, is the job cancelled if that object and the job are collected?

Is there sth

concatWith

for Flow?

Hey guys, I’m trying to await a result of a callback from the Amazon LWA sdk but it’s a bit advanced and confusing for me. This is their method:

AuthorizationManager.getToken(context, SCOPES, tokenListener)

I want to wait for it to get the result in the listener and then continue on with my code but I can’t figure out if it’s at all possible.

Can anyone explain to me the benefit of a

CoroutineScope

being provided in AndroidX LifeCycle as an extension

viewModelScope

versus just having viewmodel implement

CorutineScope

?

How to convert

fun myFun(): LiveData<MyClass>

to a suspend function that returns as soon as the LiveData value is set (i.e. the first time since LiveData created)? Note - the actual scenario is Room where I sometimes want LiveData<List> and othertimes just want the List of results, but don’t want to specify the SQL annotation twice. The best I have so far is:

suspend fun mySuspendFun() = suspendCoroutine<List<MyClass>> { cont ->
        val live = myFun()
        live.observeForever(object: Observer<List<MyClass>> {
            override fun onChanged(it: List<MyClass>) {
                live.removeObserver(this)
                cont.resume(it)
            }
        })
    }

Hello, I have trouble with

Dispatchers.Main

on Android. Here are my dependencies:

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.1")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.2.1")

And on my activity, a simple launch would do nothing when ran on

Dispatchers.Main

, whereas it works on `Dispatchers.IO`:

GlobalScope.launch(Dispatchers.Main) { // Works with <http://Dispatchers.IO|Dispatchers.IO>
            Timber.d("Current thread: ${Thread.currentThread().name}")
        }

In debug, I can access

Dispatchers.Main

which is correctly plugged to the android handler. Any idea what I'm doing wrong?

I have an espresso test which fails because at the start of my fragment, I call

launch(Dispatchers.Main) { ... withTimeoutOrNull(1000) }

When I set that timeout to

0

, the tests passes because the views are ready. Now I thought, that in my tests I can set the main dispatcher for advancing the time automatically (so that the timout is thrown immediately and don't need to adjust the production code for my tests):

Dispatchers.setMain(TestCoroutineDispatcher())

. However that doesn't work. Has someone and idea why and how I can fix it?

Hello everyone, is it ok to use

CoroutineScope.rxObservable

in production to gradually migrate Rx code into coroutines? Or since it's experimental should wait a little bit and find a different strategy for migration?

Not sure if this is the best place to post, but I thought

Flow

could use a

chunked

method, just like

List

has:

fun <T> Flow<T>.chunked(size: Int) = flow {
	val list = mutableListOf<T>()
	collect {
		list.add(it)
		
		if (list.size == size) {
			emit(list.toList())
			list.clear()
		}
	}
	
	if (list.isNotEmpty())
		emit(list)
}

Might be good to include in the standard library. Loving the API 👍🏻

Anyone got any video tutorials that explains how

Flow

works? I cant seem to find anything on YouTube

Is there any support for priority by coroutines?

Developers are recommended to use non-suspend

fun CoroutineScope.xxxAsync()

for functions that launch something and return immediately, and

suspend fun xxx()

for functions that suspend/block until all of their execution completes. Much of the kotlinx.coroutines API uses lambdas that are suspend and have a

CoroutineScope

receiver. The

CoroutineScope

allows developers to write coroutines with cancellability in mind - by checking

isActive

. What's the best way to get access to this in a

suspend fun

?

I have a situation where collect emits in the cancelled state:

launch {
      state.collect {
        Timber.i("isActive=$isActive, job=$Job")
        render(it)
      }
    }

It prints

isActive=false

. How is that possible?

Quick question, and hopefully a quick answer 🙂 : How does one terminate a

Flow<T>

(successfully or with an error)? The

FlowCollector<T>

only has an

emit

method.

@elizarov Any news as to when we're going to see anything for Kotlin/native `Channel`'s?

I want to run multiple async tasks that doesn't affect each other neither their parent. Eg. something like:

(0..4)
	.map { async { .... } }
	.forEach {
		try  { 
			it.await()...process
		} catch() {}
	}

Which coroutine scope builder I should use? Using

coroutineScope {}

or

supervisorScope {}

would cancel the parent or siblings respectively.

if i have two blocking operations that I want to run in

withContext

, am I able to run these in parallel rather then serially?

i’m thinking of this:

GlobalScope.async {
  CallA() {
  if (it.success) {
   GlobalScope.async { CallB( it.value) }
 else { LogError() }
} }

Frankly, I'm wondering if

GlobalScope

should not be made experimental with something like

@WhyGlobalThingsAreBad

with some details on that special coroutines case of structured concurrency that should not be broken…

Is there a way to check whether coroutine (scope) was canceled from a suspend function (that function not being extension of the scope)?

Any ideas of how to convert this ValueCallback into suspend? evaluateJavascript needs to be called from the main thread failing to do so throws an exception ( All WebView methods must be called on the same thread. (Expected Looper Looper (main, tid 2) {3acde0b} called on null, FYI main Looper is Looper (main, tid 2) {3acde0b}))

return suspendCoroutine { cont ->
            webView.evaluateJavascript( string ) { result ->
                cont.resume( result )
            }
        }

How can we use the result of a first routing to call the 2nd one (reformulating my previous question)

What’s the reasoning that

Channel<T>

and

Flow<T>

don’t share the same backing interface? It seems unfortunate that the two won’t be able to share the same operators

Sorry if I sound a bit like a broken record 🙂 but I’m struggling with handling exceptions when using `CoroutineScope.launch`: https://github.com/Kotlin/kotlinx.coroutines/issues/1157 I think there is either something wrong or I don’t understand the exception handling correctly. Could someone help me understand what’s going on? Thanks!

Is it in any way possible to clean up resources from within a coroutine when a SIGINT signal is received (without using a shutdown hook)? I'm trying to do this in a multiplatform project, and it seems like the program is just ignoring anything I put in a

finally

block because coroutines don't block the program from exiting.