gpeal/BroadcastReceiver.kt

This would be nicer as a flow. Also passing coroutine scope makes it seems its somehow coroutine related, which it is not, just used to unsubscriber

@ursusursus funny enough, we added this recently as well:

fun Context.registerReceiverAsFlow(
    vararg intentFilterActions: String,
): Flow<Intent> = callbackFlow<Intent> {
    val receiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            sendBlocking(intent)
        }
    }
    val intentFilter = IntentFilter()
    intentFilterActions.forEach { intentFilter.addAction(it) }
    registerReceiver(receiver, intentFilter)
    awaitClose {
        unregisterReceiver(receiver)
    }
}.buffer(capacity = Channel.UNLIMITED)

great minds think alike lol

class EventBus private constructor(val scope: CoroutineScope) {

private val _bus = MutableSharedFlow<T>(replay = 1)
val bus: SharedFlow<T> = _bus.asSharedFlow()

fun post(event: T) {
    scope.launch(Dispatchers.IO) {
        _bus.emit(event)
    }
}

inline fun <reified E : T> subscribe(
    dispatcher: CoroutineDispatcher = Dispatchers.Main,
    crossinline action: (event: E) -> Unit
): Job {
    val job = SupervisorJob(scope.coroutineContext[Job])

    return scope.launch(dispatcher + job) {
        bus.filterIsInstance<E>().collect {
            action(it)
        }
    }
}

companion object {
    private lateinit var instance: EventBus<*>

    fun <T> initialize(scope: CoroutineScope): EventBus<T> {
        instance = EventBus<T>(scope)
        return instance as EventBus<T>
    }

    @Suppress("UNCHECKED_CAST")
    fun <T> get(): EventBus<T> = instance as EventBus<T>
}

}

will this code opt this ?