With LiveData we could easily reach the same logic, so I would like to know the difference between

LiveData

and

StateFlow

.

class DownloadingModel {

   private val _state = MutableStateFlow<DownloadStatus>(DownloadStatus.NOT_REQUESTED)
   val state: StateFlow<DownloadStatus> get() = _state

   suspend fun download() {
       _state.value = DownloadStatus.INITIALIZED
       initializeConnection()
       processAvailableContent {
               partialData: ByteArray,
               downloadedBytes: Long,
               totalBytes: Long
           ->
           storePartialData(partialData)
           _state = DownloadProgress(downloadedBytes.toDouble() / totalBytes)
       }
       _state.value = DownloadStatus.SUCCESS
   }
}

I have a question about coroutine scopes (or is it contexts?). When I need to launch a new coroutine from a

suspend

function, I usually wrap the

launch

or

async

call with

withContext

(although, it looks like I should be using

coroutineScope

a little more often). This will tie the new coroutines into the structured concurrency of the calling coroutine, which is all fine and dandy. On the other hand, suppose I had something along the lines of

shortLivedScope.launch { 
    // some stuff
    longLivedScope.launch { performSomeTasks() }
    // some stuff
}

What is the relationship between the coroutines I have now launched?

Hi, I have function like this where

Result.UiUpdate.MovieList

is a sealed class. Do you know why I have to add as Result and the compiler want me to remove it?

Just getting started with coroutines here... Given a

val flow = MutableStateFlow<Boolean>(false)

, How to write a function that suspends until the flow value is true for the first time?

suspend fun waitUntilTrue() { ... }

Anyone know how to resolve the kotlin.Result classncast exception issue?

Hi, is there a way to globally attach some code logic to coroutine lifecycle methods?

I went through the documentation of

suspendCancellableCoroutine

. It mentions that this function throws a

CancellationException

if the coroutine is cancelled or completed while suspended. In which case the coroutine is completed while suspended?

If I am seeing

Uncaught Kotlin exception: kotlinx.coroutines.CoroutinesInternalError: Fatal exception in coroutines machinery for DispatchedContinuation[WorkerCoroutineDispatcherImpl@169bc08, Continuation @ $start$lambda-1COROUTINE$34]. Please read KDoc to 'handleFatalException' method and report this incident to maintainers

...

Caused by: kotlin.native.concurrent.InvalidMutabilityException: mutation attempt of frozen dev.williamreed.clique.mobile.WsSession.$start$lambda-1COROUTINE$34@3b34238

is this actually a bug in the library - or is the fault the "caused by" section from something I did?

The doc on 

StateFlow

 contains this statement:

So a slow collector skips fast updates, but always collects the most recently emitted value.

What’s the actual threshold that makes it skip states? Do I need to add a

delay

call if I want to force some State to NOT be skipped?

If I have a multiple call with async await or launch if I don't want to fail if one fails I need to use supervisorScope or supervisorJob? What's the difference between them?

Hello everyone, I got this scenario

fun login(): Flow<LoginState>

sealed class LoginState {
    object Loading : LoginState()
    class ApproveRequestToken(val url: String) : LoginState()
    object Completed : LoginState()
}

When the

LoginState.ApproveRequestToken

is emitted, I have to wait for user interaction ( approve token via web ), then I want the

Flow

to continue, what would be your best approach?

How can a

SingleLiveEvent

(Android pattern when using view models and live data) be modeled using flows? I think that the documentation of

fun <T> ReceiveChannel<T>.receiveAsFlow(): Flow<T>

(https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/receive-as-flow.html) describes this specific use case:

Represents the given receive channel as a hot flow and receives from the channel in fan-out fashion every time this flow is collected. One element will be emitted to one collector only.

So, if I just create a

private val _events = Channel<MyEvent>()

in my

ViewModel

and expose it as

val events = _events.receiveAsFlow()

, would that behave like a single live event? I.e.: one collector only receives the event, all others don't? Or are there additional things to consider? I'm a bit confused about the existence of

(Mutable)SharedFlow

(and the now obsolete

BroadcastChannel

), but I think this will always share emissions between all active collectors (subscribers) and that's precisely what single live event tries to prevent, am I right?

How can you easily assert values emitted by a flow that doesn't complete? Using

TestCoroutineScope

/

-Dispatcher

with

runBlockingTest

, when you

flow.launchIn(testScope)

, then the job would leak unless you remember to cancel the job before the test block ends. How can you verify more easily that a flow emitted certain values? I can think of some solutions: 1. As a side effect, put collected values in some mutable collection. This makes assertion of values easy, but you still have to remember to cancel any collectors of the uncompleted flow. 2. Cancel the source of the flow, i.e. force it to complete, by the end of the test. This should usually also complete collectors. 3. Do not use the test coroutine scope to collect flows that do not complete. This has a downside that you test with multiple scopes, which may be conceptually challenging. Either way it's a bit of test boilerplate 👎 Any ideas?

is there a known bug for

Inappropriate blocking method call

always appearing, even if wrapped in

<http://Dispatchers.IO|Dispatchers.IO>

?

Given function:

fun constructFlow() = flow { for(x in channel) emit(x) }

Is there any practical difference between

val someFlow = constructFlow()

and

val someFlow get() = constructFlow()

? I do realize, that second version will call constructFlow on every access, while first one - only once. But since a flow is only a definition of what should happen after collection - isn`t it always the same?

I am trying to construct the following Flow, but with no luck. I am trying to do something like below, but it obviously doesn't compile (it's pseudo code). As you can see, I am trying to map a

chatConversationsFlow: Flow<List<ChatConversation>>

to a

lastMessagesFlow: Flow<List<String>>

. When the last message of a conversation is sent by me, the result will be of the format

"You: ${chatConversation.lastMessage}"

. But when the last message of a conversation is sent by someone else than me, I first need to get

userFlow: Flow<User>

of the specific user, then the result will be of the format

"${user.name}: ${chatConversation.lastMessage}"

. What would be the best (preferably most idiomatic) approach to achieve this in Flow/Coroutines?

private fun lastMessagesFlow(
    chatConversationsFlow: Flow<List<ChatConversation>>
): Flow<List<String>> = flow {
    emit(listOf("Loading"))

    emitAll(
        chatConversationsFlow.map { chatConversations ->
            chatConversations.map { chatConversation ->
                if (chatConversation.lastMessageSentByUserId == -1) "You: ${chatConversation.lastMessage}"
                else {
                    val userFlow: Flow<User> = userFlow(userId = chatConversation.lastMessageSentByUserId)
                    userFlow.map { user ->
                        "${user.name}: ${chatConversation.lastMessage}"
                    }
                }

            }
        }
    )
}

Hi. Cannot sync recent coroutines native library from jcenter or maven central

> Could not find org.jetbrains.kotlinx:kotlinx-coroutines-core-native:1.4.1.
     Searched in the following locations:
       - <https://dl.google.com/dl/android/maven2/org/jetbrains/kotlinx/kotlinx-coroutines-core-native/1.4.1/kotlinx-coroutines-core-native-1.4.1.pom>
       - <https://jcenter.bintray.com/org/jetbrains/kotlinx/kotlinx-coroutines-core-native/1.4.1/kotlinx-coroutines-core-native-1.4.1.pom>
       - <https://repo.maven.apache.org/maven2/org/jetbrains/kotlinx/kotlinx-coroutines-core-native/1.4.1/kotlinx-coroutines-core-native-1.4.1.pom>

Latest I can sync is

1.3.8

Used remote repositories:

allprojects {
    repositories {
        google()
        jcenter()
        mavenCentral()
    }
}

Is it possible to schedule a task to be executed AFTER current task completes or suspends?

Is there any way to check that a couroutineScope is cancelled? on my Unit test I want to check that my coroutineScope is cancelled at some point. The thing is my CoroutineScope is not a mock so I can not use verify.

With the state of compose as of now, should we expect another ui package for coroutines?, say

kotlinx-coroutines-compose

With dedicated dispatchers for

composables

launching suspending functions?

hey, i was just wondering, is there a way to tell two separate coroutines to wait a specific time before continuing without having to cancelling them and then relaunching once both coroutines are done

Is somebody able to share an explanation for why the test below prints

9a

9b

9c

9d

9e

9f

when it seemingly should be printing

1a

2a

3a

4a

5a

6a

7a

8a

before that?

@Test
    fun example1(): Unit = runBlocking {
        val flowA = flowOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
        val flowB = flowOf("a", "b", "c", "d", "e", "f").onEach { delay(1000) }

        flowA.combine(flowB) { a, b -> "$a$b" }.collect { println(it) }
    }

Is there a way to map a

StateFlow<T>

to a

StateFlow<R>

? I have a

MutableStateFlow<MyEnum>

in a view model, but I want it private to expose publicly a

StateFlow<String>

How do i create a "infinite" flow correctly? I'm trying to create a flow to "infinitely" consume from a messagem bus. For example:

fun receive(interval: Duration) = flow {
    while (true) {
        delay(interval.toMillis())
        val messages = getMessages(interval)
        messages.forEach {
            println("Emitting $it")
            emit(it)
        }
    }
}

I can consume the flow "forever" like this:

receive(Duration.ofSeconds(1))
    .collect {
        println(it)
    }

Or limit the number of messages that i consume:

val amount = 10
receive(Duration.ofSeconds(1))
    .take(amount)
    .collect {
        println(it)
    }

I tested this and the flow "completes", but i do not understand what happens in the second case, do the

while(true)

loop gets suspended forever? Is this a problem?

Is there a

native-mt

variant of coroutines 1.4.1?

This message was deleted.

Is it a bad idea to pass a

CoroutineScope

to a function, instead of making the function suspendable and then call

coroutineScope {}

inside? What I'm going for:

fun connect(
            device: BluetoothDevice,
            connectionScope: CoroutineScope,
    ): StateFlow<BleConnectionState>

I want to have the consumers of this API decide what the lifetime/scope of the BLE connection should be

Hello everyone, tricky coroutine context question, will appreciate any help. I have 2 levels in my app:

Core

:

CoroutineExceptionHandler {...} + SupervisorJob() + Dispatchers.Default

UI

:

coreContext + (several custom elements holding activity reference) + Dispatchers.Main.immediate + SupervisorJob(coreContext[Job])

Let’s say I have

// core level
class CoreModel(coreScope: CoroutineScope) {
  suspend fun operation(): Result {???}
}

// ui level
uiContext.launch { 
  showResultInUi(coreModel.operation())
}

What is the correct way to implement

operation()

to run it on

coreContext with job from current coroutine (to be cancelled when UI context is cancelled) and without custom elements (to prevent activity leaks)

? Ideally core level should know nothing about custom element’s keys.