Hi. I’m getting

w: Experimental API marker kotlinx.coroutines.FlowPreview is unresolved. Please make sure it's present in the module dependencies

. I’m using

allWarningsAsErrors = true

so this stops my build. Is there any way to suppress this warning with compiler flag?

Hello all, quite simple question, I’m experimenting a bit with coroutines, and I wonder what is the best approach to handle multiple endpoints inside single

UseCase

, I guess

flow

should be used?

I have test which pass successfully (expectation would be that it fails).

@Test
    fun someTest() = runBlockingTest {
        Dispatchers.setMain(coroutineContext[ContinuationInterceptor] as CoroutineDispatcher)

        val viewModel = arrange()

        viewModel.viewModelScope.launch {
            throw IllegalStateException("mm")
        }
    }

From my understanding problem is

viewModelScope

extension which creates

SupervisorJob

at https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:lifecycle/lifecycle-viewmodel-ktx/src/main/java/androidx/lifecycle/ViewModel.kt;l=42;drc=9f40e609cef60d1889e2b13d48ba1dbb8aa345e3 What would be appropriate way to make such test method fail?

Coroutine/KMPP question: what are my options if I want to send to the ConflatedBroadcastChannel from swift? Usecase: on button click in UI I want to send this click to the channel. But

send

is a suspending function and as such not usable from Swift/ObjC. Are there docs about this which I've missed? I see a lot of tutorials for iOS concurrency, but a little about this kind of interop. Not sure if this is the right channel as it is both about #coroutines and #multiplatform

I'm working on a codebase with both Java and Kotlin code, i introduced Kotlin coroutines to help in running background tasks, however i have a function in my repository marked with the keyword suspend and i call it from an Intent Service that is written in java to sync local db with remote. However i can only call a suspend function from another suspend function or a coroutine builder. I three options in mind: Option 1 Use GlobalScope.launch(Dispatchers.IO) on the function so that i can call it from the Intent Service. However GloablScope is not highly recommended in the android context. Option 2 Make my repository extend Coroutine Scope, create a public function called onCleared that cancels job, then call this function when the service onDestroyed method is called or when the view model onCleared method is called. This option is to try and cancel any running operations. Option 3 Use the viewmodel scope to launch the coroutine in the repository, then call the viewmodel from the service, however the viewmodel should only be limited to an activity or fragment. Option 4 Refactor the intent service to Kotlin and use coroutines

BroadcastChannel

drops items if there are no subscribers. Is there a way to not drop but buffer? Looking for something with

UnicastSubject

behaviour.

Hi, how do you add

kotlinx-coroutines-io

as a dependency to the

commonMain

sourceset in a MPP project?

Does

BroadcastChannel#openSubscription.consumeAsFlow()

completes when collected? If not how do I go about cancelling subscription? I was trying to do this in my class so that client does not have to worry about cancelling the subscription

private fun getResponseChannel(): Flow<ContentResponse> {
        val channel = responseChannel.openSubscription()
        return channel
            .consumeAsFlow()
            .onCompletion {
                Timber.d("Cancelled")
                channel.cancel()
            }
    }

But it seems that

onCompletion

never gets called

is it possible to check if there are active jobs within a coroutineScope ?

If I have a class that implements CoroutineContext, how would I go about to perform a graceful shutdown? A graceful shutdown in this case meaning wait for any ongoing child to finish (so joinAll() on any child-coroutine spawned) It seems CouroutineConext.cancel() is quite aggressive and does cancel instead of join (which the name kinda indicates as well :P)

Is it okay for a Service in android to extend Coroutine Scope?

What is the best way to handle

Flow

on device rotation in Android if you are only using

Flow

(without

LiveData

)? I see that Dropbox Store library caches the latest and provides when it is requested again. https://github.com/dropbox/Store

The first time you call to suspend store.get(key), the response will be stored in an in-memory cache and in the persister, if provided. All subsequent calls to store.get(key) with the same Key will retrieve the cached version of the data, minimizing unnecessary data calls.

Since the Flow is cold it is going to be collected evertime.

This message was deleted.

Hi! Coroutine + Multiplatform question. I have this code on Linux, using Kotlin/Native:

class MyClass : CoroutineScope by MainScope() {
  fun execute() = launch {
    delay(1000)
    println("finished")
  }
}

fun main() = runBlocking {
  val clazz = MyClass()
  clazz.execute()
}

This throws an exception:

kotlin.IllegalStateException: There is no event loop. Use runBlocking { ... } to start one.

What do I do wrong? • If MyClass is external and I can't modify it, how to solve this? • For some reason if I run the code from the

main()

function in Android Activity (which doesn't even have any CouroutineScope), it runs perfectly well. Why?

basically, it's a timeout for flow, it closes after timedOut

How do I get the ---last--- element of a

Flow

without having to use

toList().last()

...?

What is generally stylistically preferred:

class CoroutineJob {
    suspend fun doWork() {
          // do stuff in coroutine context
    }
}
// elsewhere:
scope.launch { 
    CoroutineJob().doWork()
)

or

class CoroutineJob(val scope: CoroutineScope) {
    fun launchWork() {
        scope.launch {
            // do stuff in coroutine context (possibly calling another suspend fun member?)
        }
    }
}
// elsewhere:
CoroutineJob(scope).launchWork()

or something else?

Hello, I would appreciate if someone could bring some light on this problem I'm having. I would like to get the result of a suspend function called using the invoke method inside a java Proxy's InvocationHandler. I reduced the problem to to a test, but I am still not able to figure out how to intercept the result inside the InvocationHandler's code. https://gist.github.com/hiperbou/283e6531fb2b71b324d5064f820df889

what are the benefits for using Flow from a Room query in Android as oppose to using Livedata?

If I have a conflated

BroadcastChannel

and I send something before using

asFlow()

on it, will I receive what was sent?

Hi there. Need an advice. Inside a

ViewModel

, I had a basic MVI-inspired state machine implemented in the following way:

/**
 * State machine for this view model consisting of [Interactor], [State], [Event] and [Reducer]
 * It reduces [Event] to the immutable [State] by applying [Reducer] fuction.
 * This [State] then will be rendered.
 */
class Interactor(
        private val scope: CoroutineScope,
        private val reducer: Reducer = Reducer(),
        private val channel: Channel<Event> = Channel(),
        private val events: Flow<Event> = channel.consumeAsFlow()
    ) {
        fun onEvent(event: Event) = scope.launch { channel.send(event) }
        fun state(): Flow<State> = events.scan(State.init(), reducer.function)
    }

interface StateReducer<STATE, EVENT> {
    val function: suspend (STATE, EVENT) -> STATE
    suspend fun reduce(state: STATE, event: EVENT): STATE
}

But then I was unable to get current state, I could only observe it as a

Flow<State>

, so I re-implemented it in the following manner:

class Interactor(
        private val scope: CoroutineScope,
        private val reducer: Reducer = Reducer(),
        private val channel: Channel<Event> = Channel(),
        private val events: Flow<Event> = channel.consumeAsFlow()
    ) {
        
       val state = ConflatedBroadcastChannel<State>()

        init {
            scope.launch {
                events.scan(State.init(), reducer.function).collect { state.send(it) }
            }
        }

        fun onEvent(event: Event) = scope.launch { channel.send(event) }
        fun state(): Flow<State> = state.asFlow()
    }

I guess it could be improved. Are there any inherent problems to this implementation? Thanks a lot, in advance 💥.

does

Channel.offer

on a

RendezvousChannel

always return false? Or will it return true if a receiver is already waiting for the next value?

what is the shortest code to follow the

same thread enforcement

of a library? i need to store what thread something was created on and then switch back to it whenever interacting with it i just nee the right keyword to look for, not even sure what to look for

coroutines-android question: https://kotlinlang.slack.com/archives/C0B8M7BUY/p1581192521336600

Is having a reentrant readwrite lock an anitpattern in a reactive stack? Does it make sense to wrap it into a coroutines?

I'm trying to use ktor for many simultaneous of TCP connections on JVM. Each connection is tcp client to different ip/port, and amount of data would be quite low. Any suggestions of should there be single thread or multiple, pools, etc?

Is there any reason that

channelFlow

doesn't expose something like

fun channelFlow(buffer: Int = ...)

And instead we have to call

.buffer

downstream?

I also don't know the performance implications of that since we're creating an extra channel and flow to wrap the one upstream

IS the corotuines team open to community PRs? I have a rx operator analog for flow that is missing