Hi oh lovely community Is there something similar to a condi

Question

Hi oh lovely community Is there something similar to a condition variable on coroutines

Dominaezzz · Answer

Hmm `CompletableDeferred` might be what you re looking for

Dominaezzz · Answer

If you outline more of your use case I might be able to recommend something better

540grunkspin · Answer

This is all proprietary stuff so sorry in advance for the vagueness I have a controller object that might come and go I have an interface that aquires an instance of the controller object and has methods that call methods on the controller

540grunkspin · Answer

So what I do today is far from optimal but I use a cond and a threadpool I post a task on the thread pool and wait with a timeout for a controller instance to be ready for use and then I use that one

540grunkspin · Answer

I more or less want the uncertainty of wether or not a controller is currently available to be hidden from the user of the API

Dominaezzz · Answer

So am I correct in saying there s a single controller that multiple threads have to share You use conditions to synchronise access

540grunkspin · Answer

I use conditions to ping the waiting threads about the fact that a controller is ready for use 1 Connect the controller 2 Do something with the still connecting controller 3 Controller comes online an wakes up the waiting threads

Dominaezzz · Answer

Oh I see

540grunkspin · Answer

Now what I actually want coroutines to provide me with is to make the methods suspend so that the user can get notified when a method completes on a controller without having to use a callback

Dominaezzz · Answer

Something like this or ``` This has internal threadpool val api = TODO Get super secret api 1 This suspends api submitTask controller gt Do stuff with connected controller 2 This suspends val controller = api getController Do stuff with connected controller ```

Dominaezzz · Answer

1 or 2

540grunkspin · Answer

More like api sendCommand where api sendCommand suspends

Dominaezzz · Answer

Oh and `sendCommand` will use the controller internally The user won t touch the controller directly

540grunkspin · Answer

Exactly

540grunkspin · Answer

The user will have no idea that the controller exists The controller is provided via a callback that more or less has a `onConnected` and an `onDisconnected` method

540grunkspin · Answer

The callback is also handled internally

Dominaezzz · Answer

I m guessing inside `onConnected` you signal the internal threadpool to stop waiting and use the controller

Dominaezzz · Answer

What do you do in `onDisconnected`

Dominaezzz · Answer

Cancel tasks

Dominaezzz · Answer

Or just pause future tasks until `onConnected` is called again

540grunkspin · Answer

Lock and set to null more or less ``` fun sendCommand lock lock try while controller isConnected cond await controller runCommand finally lock unlock ```

540grunkspin · Answer

That is more or less the code

540grunkspin · Answer

With some timeouts for the await

Dominaezzz · Answer

From what I ve seen you could use a `ConflatedBroadcastChannel`

540grunkspin · Answer

Now I could make the function suspend and wrap it in `suspendCoroutine` so that way the user can use coroutines but internally it is threads

Dominaezzz · Answer

``` fun sendCommand val input = channel openSubscription try input receive controller runCommand finally input cancel ```

540grunkspin · Answer

Will is remember the last used element

540grunkspin · Answer

Or will it only trigger on new events

Dominaezzz · Answer

`ConflatedBroadcastChannel` is designed to remember the last sent element

540grunkspin · Answer

That is awesome

540grunkspin · Answer

So if i send null then it will not receive any new messages

Dominaezzz · Answer

You can t send null

Dominaezzz · Answer

``` fun onConnected channel offer Unit ```

540grunkspin · Answer

Is there a way for me to clear it I was thinking that I could send the actual controller through the channel and then clear it if it goes away

Dominaezzz · Answer

Oh

540grunkspin · Answer

Because otherwise I will probably have to use some sort of mutex anyhow to ensure threadsafety on the controller

Dominaezzz · Answer

You can make the channel `ConflatedBroadcastChannel lt Controller gt ` then yes

540grunkspin · Answer

In that case this is exactly what I was looking for

Dominaezzz · Answer

Oh so you need synchronised access to the controller

540grunkspin · Answer

Yeah that too hehe

Dominaezzz · Answer

Hold on this might change things

Dominaezzz · Answer

I forgot how conditions work

540grunkspin · Answer

I want synchronized access to an object that might be in an unusable state If so I want all tasks to wait for it to get back to a usable state

540grunkspin · Answer

And wake up once it reached the usable state

Dominaezzz · Answer

Okay I have a better idea now but I have one last question

540grunkspin · Answer

Shoot

Dominaezzz · Answer

Why do you use a threadpool if you need synchronisation

540grunkspin · Answer

Because I don t want the methods in the interface to be blocking and they might have to block until the controller is usable I also don t want the risk of spawning an unlimited amount of threads

Dominaezzz · Answer

Okay you don t need the `ConflatedBroadcastChannel` in that case

Dominaezzz · Answer

In `sendCommand` you can pass a some data into a channel

Dominaezzz · Answer

Then have a coroutine run through the channel

Dominaezzz · Answer

I ll try and find an example of it

540grunkspin · Answer

But how do I make the worker coroutine wait if the controller is in an unusable state

Dominaezzz · Answer

Example here <https kotlinlang slack com archives C1CFAFJSK p1563798636010800>

Dominaezzz · Answer

~For that you can use an `AtomicBoolean` to keep track ~

Dominaezzz · Answer

You can use a regular channel with conflation

540grunkspin · Answer

So one channel for tasks and one for conflation

Dominaezzz · Answer

Yes

Dominaezzz · Answer

This way you only have one running thread

540grunkspin · Answer

That is pretty cool actually

540grunkspin · Answer

I will give it a shot

Dominaezzz · Answer

sunglasses

540grunkspin · Answer

Thank you so much for the nice discussion By the way i have had a slight break from android and kotlin but are channels in stable yet or is it still experimental

Dominaezzz · Answer

It s mostly out of experimental

540grunkspin · Answer

So there are some things missing but most of it is available

Dominaezzz · Answer

Some classes like `ConflatedBroadcastChannel` are still experimental but luckily you don t need it anymore slightly smiling face

Dominaezzz · Answer

Basically everything you need for this is not experimental

540grunkspin · Answer

But didn t you say that i should use a regular channel with conflation

Dominaezzz · Answer

Yes you can use `Channel capacity = CONFLATED `

540grunkspin · Answer

Aaah

540grunkspin · Answer

Cool I will for sure give this a go I like it a lot actually

540grunkspin · Answer

Though I think I would like a suspending cond more but that is probably because of braindamage caused by C

Dominaezzz · Answer

Haha you ll recover with Kotlin joy

Dominaezzz · Answer

Forget to mention you can handle timeouts with `withTimeout 1000 api sendCommand `

540grunkspin · Answer

I might be stupid here but how can I clear the channel if my controller disconnects

Dominaezzz · Answer

Which channel

Dominaezzz · Answer

Task channel or controller channel

540grunkspin · Answer

The second channel that indicates if the controller is in a ready state

540grunkspin · Answer

Or should that just be a channel of booleans

Dominaezzz · Answer

Ha you beat me to it

Dominaezzz · Answer

Yeah

Dominaezzz · Answer

Actually maybe not because you still need some way to wait for the channel to become true non null

540grunkspin · Answer

Yeah exactly what i thougt

Dominaezzz · Answer

This is tricky

Dominaezzz · Answer

You can send `CompletableDeferred`s down the channel

540grunkspin · Answer

Not sure How would that help me

Dominaezzz · Answer

Then in `onConnected` call `complete` on the current `CompletableDeferred` and in `onDisconnected` send a new `CompletableDeferred`

540grunkspin · Answer

Maybe I could actually go for the takeIf and use an AtomicBoolean

Dominaezzz · Answer

Then in the processing coroutine you can call await

Dominaezzz · Answer

Or don t use conflation and keep track of the state in the processing coroutine

Dominaezzz · Answer

`AtomicBoolean` won t let you wait

Dominaezzz · Answer

So in the processing coroutine you ll call `poll ` to see if there s a new state change if the new value is `true` then you can continue processing if the new value is `false` you then call `receive ` to wait

540grunkspin · Answer

I was thinking that I do something like ``` val isConnected = AtomicBoolean false eventChannel takeIf isConnected get onReceive event gt try controller handleEvent finally if isConnected get eventChannel send event ```

540grunkspin · Answer

So if the executing of the eventt fails due to disconnection i will just re add the event to the channel

Dominaezzz · Answer

It still doesn t solve the problem of having to wait for connection

540grunkspin · Answer

Aaaah that is very true

540grunkspin · Answer

``` if isConnectedChannel poll = true while isConnectedChannel receive ```

540grunkspin · Answer

Something like that

540grunkspin · Answer

Or could i not just do this ``` while isConnectedChannel receive ```

540grunkspin · Answer

Oh no I can t because the channel is Conflated

Dominaezzz · Answer

Yeah

540grunkspin · Answer

Hopefully this ``` if isConnectedChannel poll = true while isConnectedChannel receive ```

540grunkspin · Answer

Should do the trick right

Dominaezzz · Answer

Yes but only for a single event

Dominaezzz · Answer

You have to remember that the controller is connected for future events

540grunkspin · Answer

``` if isConnectedChannel poll = true while isConnectedChannel receive isConnectedChannel send true ```

540grunkspin · Answer

Hehe

Dominaezzz · Answer

Haha wow

540grunkspin · Answer

Should work I guess

Dominaezzz · Answer

I don t know where but I see a race condition

Dominaezzz · Answer

That will race with the actual `onConnected` and `onDisconnected`

540grunkspin · Answer

Aaah yeah that is true

540grunkspin · Answer

Im starting to feel like it s giving up time I think My current solution is sort of ugly but it works

Dominaezzz · Answer

Give me 5 minutes grin I m close to something

540grunkspin · Answer

Haha

540grunkspin · Answer

Love the enthusiasm I guess I will go and make some coffee Sounds like it might be a long night

Dominaezzz · Answer

joy

540grunkspin · Answer

What I actually want sort of is live data An observable data holder

540grunkspin · Answer

That suspends

Dominaezzz · Answer

If you don t mind experimental `Flow` is an option

540grunkspin · Answer

How would it work with Flow

540grunkspin · Answer

Haven t really looked in to it all the much

Dominaezzz · Answer

I haven t needed to use it much but it has some operators that might help express our intentions better Like the conflation Although it would require more info from you end on how to abstract it well

540grunkspin · Answer

Can t it be done with a `combine` and a `takeWhile`

Dominaezzz · Answer

Like how many other callbacks does your controller expose apart from `onConnected` `onDisconnected` etc

Dominaezzz · Answer

Yeah pretty much

540grunkspin · Answer

The controller had connect and disconnect + a sendCommand where the command is a bytebuffer tada

540grunkspin · Answer

Awfully low level stuff that I am now trying to provide a workable API for

Dominaezzz · Answer

Oh okay that should simplify things

540grunkspin · Answer

Do I have to launch a new coroutine just to emit a value

Dominaezzz · Answer

``` callbackFlow lt Boolean gt channel gt val controller = TODO controller onConnected channel offer true controller onDisconnected channel offer false awaitClose controller close ```

540grunkspin · Answer

Aaah

540grunkspin · Answer

Great

Dominaezzz · Answer

I can t figure out how to solve this with `Flow` and the `Channel` solution is getting out of hand The original `ConflatedBroadcastChannel` will do the trick

Dominaezzz · Answer

``` val connectionChannel = ConflatedBroadcastChannel lt Boolean gt GlobalScope launch while isActive if connectionChannel value val channel = connectionChannel openSubscription while channel receive channel cancel try Handle event finally Requeue if necessary ```

540grunkspin · Answer

Cool I have a look tomorrow Had to go home and feed the cats

540grunkspin · Answer

Thank you so much for taking the time to help me heart

Dominaezzz · Answer

No problem

540grunkspin · Answer

Implemented it now and it works wonders Thank you for showing me these awesome things that you can do with coroutines

Dominaezzz · Answer

No problem