Is using runBlocking correct way to interface with blocking world when using MutableStateFlow?

class PermissionManager() {
    private val manualTrigger = MutableSharedFlow<Unit>()
    
    ...

    fun notifyPermissionChanged() {
        runBlocking { <---------------------
            manualTrigger.emit(Unit)
        }
    }
}

class Activity {
	override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        permissionManager.notifyPermissionChanged()
    }
}

tryEmit never does anything

You should dispatch it on Dispatchers.IO instead. runBlocking is meant to be used as an entrypoint only

not sure what you mean. that down stream processing will happen on Activity thread? yea im aware

No I'm saying that you should use async(Dispachers.IO) {} instead of runBlocking. Otherwise you risk blocking UI thread

do you mean GlobalScope.async/launch?

You should avoid global scope too. There was an article about that by @elizarov a while ago, but I can't find it for you now.

I'm aware, but creating a scope just to pipe the event in feels contraproductive, I'd rather just block the thread for the 0.1ms it takes.. since im the type which has private scope instances, not injected

If you're ok blocking main thread then go ahead with runBlocking. Nothing wrong with that

I see, thanks! btw any obvious reason tryEmit doesnt work?

Or you can just make that function suspend

which one, the notify?

Yes

I'd rather not, im just trying to bridge blocking to reactive world, hence the mutableflow; and coming from rxjava it catches me offguard that the emit is a suspend function

I personally try to keep my entire app in suspend mode when working with coroutines.

yes, all after the proxy is coroutine/flow world

I think there are rxjava extensions for coroutines to help converting between the two if that helps you at all

not really necessary, its just that flow surfaces the need for backpressure handling of piping in emits into the relay/mutableflow, rx implicitly would block the activity thread if backpressure were to happen, here its obvious via runblocking

async(<http://Dispatchers.IO|Dispatchers.IO>) { ... }

you mean

suspend

+

withContext(<http://Dispatchers.IO|Dispatchers.IO>) { ... }

? I can't find an async function

async is an extension to coroutineScope

but where he is using runBlocking it isn't a suspend fun so he has no scope there

Thus me mentioning workarounds around GlobalScope

@Adam Powell says no? rather to GlobalScope.launch it?

use a buffer or reconsider whether multicast events are the right tool here

tryEmit will fail if there are no subscribers to the flow. You can use the

extraBufferCapacity

parameter to ensure the flow will accept your value

I don't think I follow. I'm trying to turn android callback into reactive events, but since it's Activity callback for the permissions, I can only imperatively proxy the events via MutableSharedFlow, no? What else is there to be done? I cannot wrap it cold-ly as I would with BroadcastReceiver and CallbackFlow for example

As Francesc said, what you are looking for is:

val manualTrigger = MutableSharedFlow<Unit>(extraBufferCapacity = 1)

it will let you use

MutableSharedFlow.tryEmit

. You can read more about why you need this here: https://itnext.io/mutablesharedflow-is-kind-of-complicated-61af68011eae

oh that's some footgun