I'm trying to start cancellable(synchroniously) async operation inside a suspend function(without

CoroutineScope

receiver). Is there a better way? Sample in a thread.

Hi, I’ve got mqttclient which in current implementation sends messages to Channel. Would flow be something I would benefit from, or should I stay with Channels, since mqttclient is hot source in nature?

I have implemented a job queue using Rx https://github.com/ypujante/jamba-quickstart-server/blob/master/src/jvmMain/kotlin/org/pongasoft/jamba/quickstart/server/be/services/JobQueue.kt and TBH was kind of a pain (error handling, etc..)... was wondering if coroutines/channels would be easier?

Is there a better way to implement suspending

while

loop instead of this?

while (condition) {
   ...
   delay(1)
}

use a normal loop and invoke

doSomething()

directly

Is there a flow replacement for

<T> Observable<T> merge(Iterable<? extends ObservableSource<? extends T>> sources)

?

what the difference from the programmer perspective will be between coroutines coming from the project loom compared to kotlin coroutines?

What coroutine scope do you use to launch coroutines in classes that don’t have a lifecycle? I’m creating a NotificationManager class in an Android application, and I need to use coroutines for taking some database related tasks off the main thread. This class will be used as a singleton in the project via dependency injection. Should I implement the

Coroutine Scope

interface in it? There will be no lifecycle callback to cancel the running coroutines in this scope, though. Since a single instance of this class will be shared with the entire application, any coroutines launched in this scope will be equivalent to launching them in the global scope. So should I just avoid the ceremony and use GlobalScope in this class?

I have a event bus type of stream/Flow, where Events have id. I need to replay last item of a chosen id to subscriber on subscription. If I only use replay(1) and filter { it == id } at subscriber, then only totally last item is replayed, so susbscribers who filter a different id, wont get their respective replays. I need a replay per id. (Alternative is to emit a map of all events and filter that down, but I hope this can be done more cleanly) Thanks

I've implemented a class that extends CoroutineScope and does batching with flows like timeoutbuffer in reactor and not sure if I am doing the error detection correctly. It is working but can someone please look at it provide feedback and or just their opinion on what is right and wrong about it? Actually I'm not sure how to handle errors or restart the flows. Advice is appreciated, code in the thread...

Does anybody have a project with a guava event bus on it and suspending/async-ing subscribers? I would very much like to have

@guava.Subscribe suspend fun handle(event: MyEvent)

functions, but by default guava has no idea how to handle that. I've tried: 1. switching my tests to invoke handlers directly. This works for tests but has trouble with some of our components 2. adding an obnoxious inheritance system to try and keep a

List<Job>

on the event itself, that gets appended to by subscribers. This is not great. I'd be willing to take a fork of evenBus just for support for concurrent & synchronous event publication, especially if I can get it without retrofitting existing blocking java code.

In the testing documentation: https://github.com/Kotlin/kotlinx.coroutines/tree/master/kotlinx-coroutines-test It's recommended to pass the scope through the constructor:

class Subject(val scope: CoroutineScope) {
    fun foo() {
        scope.launch {
            // launch uses the testScope injected in setup
        }
    }
}

But what do I actually pass in production code here?

Hello everyone, I’ve been struggling with how Coroutines really deal with handling exceptions… I wrote up my findings in a blog-post. Hope you like it 🙂 https://medium.com/the-kotlin-chronicle/coroutine-exceptions-3378f51a7d33?source=friends_link&sk=9b069dd9a4de5542712496a10b5a29c9

Hello, what is the proper way to handle error/success responses with new Retrofit coroutines? Back then we did it with custom adapter. But now it seems that it's not possible with corourines.

I have a question about

SupervisorJob

. This code

CoroutineScope(SupervisorJob()).launch {
    launch { 
        println("Launched Child 1")
        delay(500)
        println("Child 1 crashed")
        throw SillyException()
    }

    launch {
        println("Launched Child 2")
        delay(1000)
        println("Child 2 is still running")
        delay(500)
    }

    delay(1000)
    println("Parent is still running")
}

Thread.sleep(2000)

prints out this:

Launched Child 1
Launched Child 2
Child 1 crashed
Exception in thread "DefaultDispatcher-worker-2 @coroutine#3" launch_exceptions.SillyException: Silly
	at launch_exceptions.FileKt$main$1$1.invokeSuspend(File.kt:20)
        ...

I expected only “Child 1” to crash/stop, due to the parent being a Supervisor-Job . However, I expected “Child 2" launch and the parent to continue running… especially since

MainScope()

is defined in a similar way…

I need a way to do this in view model with coroutines.

Observable.interval(0, 1, TimeUnit.MINUTES)

When I leave the page, the task should be dismissed. Any suggestions?

Is anyone using

Flow

instead of

LiveData

? I'd like to use flow for everything but I don't know of any catches that Flow may have since I'm pretty inexperienced with it.

is there a set of extension functions for

Sequence

that work for

suspend

contexts? IE i have a sequence and I want to

map

on it in a

suspend

caller

May be a silly question, but can a

Job

join()

asynchronously? I’d like to append coroutines to a job dynamically and then have it complete when it runs out of running coroutines

AS says

Channel operators are deprecated in favour of Flow and will be removed in 1.4

But if my channel source is hot (network traffic), how/where should I introduce Flow? The articles I've read so far make the distinction between hot and cold data streams and claim Flow is for cold streams

Is there a timeline to when Flow will reach stable

This message was deleted.

Whats the equivalent coroutine code in 1.3 for this code..

return async {
            val newConsent = consent.copy(createdAt = getConsent()?.createdAt)
            val uniqueId = getUniqueId().await()

            val consentFromApi = userServiceApi.consentApiClient.putConsent(uniqueId, newConsent).await()

            localStorageService.setConsent(consentFromApi)
        }

Which should return a Deferred<Unit>

Hey guys, how do I build the correct way the following scenario with

flow

. I want to listen to text changes from an input field. The classic way would be to add a listener to the input field and respond to text changes in the callback. Now I want to get a

flow

which emits the current text on every text change. Do I need to use a

channel

that sends the text on every text change and then create a flow from the channel? I saw that there are some APIs for that on the flow documentation pages.

How do I wrap some callback inside an async or suspend function so I can return my own value. This is what I'm trying ....

When I add the

suspend

modifier to a function that I know it will take long to compute, intellij bugs me with the

Redundant 'suspend' modifier

inspection. Am I doing something wrong? All I want is to force this function to be called from a coroutine scope...

I have a question about coroutines. What is the fastest way to restrict access to a shared resource? I've checked this article: https://kotlinlang.org/docs/reference/coroutines/shared-mutable-state-and-concurrency.html but it doesn't detail the performance characteristics of the solutions

Anyone can an article that deep dives into delays, ticker, and other timing related functions with coroutines. Not sure how efficient they are. I know they don't block a thread but how do they know when the delay is over and put you back on the same thread especially when you have many and maybe that thread is now busy? Does it have some sort of event loop that keeps checking the current time with a list of functions that are suspend?