Are these two code snippets equivalent?

val job = SupervisorJob()
val lifecycleScope = CoroutineScope(Dispatchers.Main + job)

lifecycleScope.launch { }

val job = SupervisorJob()
val lifecycleScope = CoroutineScope(job)

lifecycleScope.launch(Dispatchers.Main) { }

I'm trying to use Channels to make a DirectByteBufferPool but I have been experiencing a lot of issues ByteBufferPool: https://github.com/camdenorrb/Netlius/blob/master/src/main/kotlin/me/camdenorrb/netlius/net/DirectByteBufferPool.kt Testing file: https://github.com/camdenorrb/Netlius/blob/master/src/main/kotlin/me/camdenorrb/netlius/Main.kt It refuses to go higher than the specified BUFFER_COUNT when I would ideally like to support thousands of clients at once. For some reason Channel doesn't seem to be queuing up all the receivers like expected or something. I'm not fully sure on what is exactly wrong with this one and I have been struggling to do anything about it. Any help is much appreciated.

fun main() = runBlocking {
    test()
}

suspend fun test() {
    val job = coroutineScope {
        launch {
            delay(5000)
        }
    }
    println("job = $job")
}

I need to have a reference to the job when it’s running. But the print doesn’t seem to execute until 5 sec later. What would be the correct way to achieve this?

Hello guys, first of all my apologies for my bad English :) I have an exception in my code, probably I need to do it in a better way but I dont know how yet. I want to call a bunch of listeners of a library as a sequence, so I added a continuation in every callback The code is more less like this:

fun method(){
    viewModelScope.launch {
        val result1 = getSomeData1()
        val result2 = getSomeData2()
        val result3=  getSomeData3()
        ...
    }
}

suspend fun getSomeData1() : String? = suspendCoroutine { continuation ->
    someInstance.addListener(SomeListener {
                continuation.resume(data)
            })
}
...

First time works well, but sometimes I need to execute again and I get the next exception:

IllegalStateException : Already resumed

this occurs in in the

continuation.resume

Is sharedFlow, out on RC yet?

Upgraded to kotlin 1.4-rc but I'm getting file wide red lines in intellij. As a last shot I want to update

org.jetbrains.kotlinx:kotlinx-coroutines-core

but I don't see an 1.4-rc artifact on jfrog. Am I missing something?

Hi to you, how can I call the emit method in the body of a lambda? Is that a good approach to the code on capture ?

fun main() {
  val apiRequest = 1
  var apiResponse = ""
  runBlocking {
    apiResponse = withContext(<http://Dispatchers.IO|Dispatchers.IO>) { someApiCallThatReturns(apiRequest) }
  }
}

is ‘returning responses’/‘sending arguments’ responses from one thread/coroutines on different didspatchers to another like this safe to do?

i have to use a rather terrible java api thats basically 1. set callback 2. call function and the callback gives me the return value how can i wrap such a structure in a

suspend fun

?

withContext(EmptyCoroutineContext) { .. }

basically does nothing right?

Can anyone explain why the

doSomething()

in this snippet prevents the outer

run()

loop from continuing? You’ll notice that

"Continuing to run"

is printed after

"doSomething with $hello done"

which is the opposite pattern I’m looking for.

Why

suspendCancellableCoroutine

is experiment but

suspendCoroutine

is not?

If I have a

List<A>

and a fn

suspend (A) -> B

, how can I apply this fn on the list in parallel?

Are there any valid use cases for passing your own

Job()

object to

launch

or

async

? For most use cases, its better to launch them in another scope or use

superVisorScope{}

if you want to use

SupervisorJob

, right?

What is equivalent to RxJava PublishSubject in coroutine channels?

Hello all, so I am seeing a new keyword (

coroutines-native-mt

) being passed around. May someone please explain to me what it is and its difference to

coroutines-native

?

Didn’t think before posting in #general, but this seems more appropriate to ask here.

Hi, am new to coroutines and flows and facing an issue with usage of Flows. Below is the code

DeviceDao{
@Query("SELECT * FROM devices")
    abstract fun getAllDevices(): Flow<List<Device>>
}

Repository layer

fun getAllDevices() = database.deviceDao().getAllDevices()

This repository method called form view model as below and every thing works fine

viewModelScope.launch {
            homes = homeRepository.homes.asLiveData()
            devices = deviceRepository.getAllDevices().asLiveData()
        }

Issue I am facing: Added another method at repository layer like below

private suspend fun deleteDevicesNotInLambdaResponse(deviceJsonList: List<Device>) {

    var localDevices = emptyList<Device>()
    database.deviceDao().getAllDevices().collect {
        localDevices = it
      }


//. the below code never executes

        val localDeviceIds = localDevices.map { it.deviceId }
        val remoteDeviceIds = deviceJsonList.map { it.deviceId }

        val localDevicesNotInLambdaResponse = localDeviceIds.filterNot {     remoteDeviceIds.contains(it) }
        database.deviceDao().deleteDevices(localDevicesNotInLambdaResponse)
    
}

Basically, here I want to get all local devices and find out which are not in API response and delete those devices from local data base As commented above, the code below the comment

the below code never executes

got never executed. Looks like I am missing some thing about how the Flow operator works Please suggest me how to fix this issue

Are there any good use cases for launching coroutines in activities / fragments in the

lifecycleScope

? IMO most (all?) coroutines should be started in

viewModelScope

because then they continue to run on orientation changes.

1. Is it safe to set the

value

of a

MutableStateFlow

from multiple threads? I guess it is, but then it is unknown which of the setters set the last value (which is also the last one collected/got from

value

)? The

StateFlow

docs mention 'All methods of data flow are thread-safe and can be safely invoked from concurrent coroutines without external synchronization', but does this include the

value

setter and getter? Seems unlikely to me.

2. How can I implement a thread-safe

MutableStateFlow.value

read-and-write operation? I mean: first read the current

value

(this is thread-unsafe, because I don't know if another thread will change the value just after I read it), then use it to set it again. I can probably use a

Channel

for this, but how do I do this? And there are probably alternatives?

Hello 👋 Is it correct that state flow will only emit the latest value? Seems I cannot collect every different state and assert the order, except the latest. With live data though you can with observe forever. Is something i can do to test that order of states?

So is there an actual difference (well except the fact of the obvious thats a different tool) to return a mutable state flow as a: • StateFlow • asLiveData() From experimenting today sounds like

mutableStateFlow.asLiveData()

is pretty much best of both worlds as you can have access to the operators privately while exposing a lifecycle aware state? Is there any huge pitfall I haven’t think of?

I am finding myself doing roughly:

combine(one, two, three) { 1, 2, 3 -> Triple(1,2,3) }.flatMapLatest { (1, 2, 3) -> ... }

is there a cleaner way built in to deal with that?

Is there any difference beween calling

.cancel()

on the job of the scope VS calling

.cancel()

on the scope itself? Lots of blogpost recommend to keep a reference to the

job

in order to be able to cancel it, although IMO this is not necessary, as cancelling the scope itself has the exact same effect. Am I correct?

I fetch some data from the server and forward it to via a Flow object. I need to do some accessory work based on the fetched data but I don't need to transform the data which remains as it is. It doesn't look like I would use

map

operator here. Where should I do this accessory work? In the repository before the values are emitted or in the UI where the data is delivered. Or if there is another operator that let's me do such accessory work.

Is it safe to read from an

InputStream

in a

flow { }

builder? Getting warnings from IntelliJ about inappropriate blocking calls.

Does anyone know how to correctly test a channel?

coroutinesTestRule.testDispatcher.runBlockingTest {
            var latestNav: NavEvent? = null
            navChannel.consumeEach {
                latestNav = it }
            vm.handleAction(NearbyListingClicked(nearbyListing))
            assertEquals(latestNav, OpenListing(variant.listing!!.wmid.toString()))
        }

But I'm just getting

java.lang.IllegalStateException: This job has not completed yet

The

Channel.consumeEach

appears to be blocking, which I don't think it should be

Is the new coroutines debugger not available in Android Studio?