Coroutine Channels: Building Event Bus and Message Queues

#android #kotlin #compose #tutorial

Kotlin Channels enable efficient communication between coroutines. They're perfect for building event buses and message queues.

Basic Channel Communication

@Composable
fun ChannelExample() {
    val channel = remember { Channel<String>(capacity = Channel.BUFFERED) }

    LaunchedEffect(Unit) {
        launch {
            repeat(5) { index ->
                channel.send("Message $index")
                delay(1000)
            }
        }

        launch {
            for (message in channel) {
                println("Received: $message")
            }
        }
    }
}

Event Bus Implementation

class EventBus {
    private val channel = Channel<Event>(Channel.BUFFERED)

    suspend fun publish(event: Event) {
        channel.send(event)
    }

    fun subscribe(): ReceiveChannel<Event> = channel
}

sealed class Event {
    data class UserLogin(val userId: String) : Event()
    data class DataUpdated(val data: String) : Event()
}

@Composable
fun EventBusScreen(eventBus: EventBus = remember { EventBus() }) {
    LaunchedEffect(Unit) {
        launch {
            for (event in eventBus.subscribe()) {
                when (event) {
                    is Event.UserLogin -> println("User logged in: ${event.userId}")
                    is Event.DataUpdated -> println("Data: ${event.data}")
                }
            }
        }

        eventBus.publish(Event.UserLogin("user123"))
    }
}

SharedFlow for Multiple Subscribers

For multiple consumers:

class EventManager {
    private val _events = MutableSharedFlow<Event>()
    val events = _events.asSharedFlow()

    suspend fun emit(event: Event) {
        _events.emit(event)
    }
}