Events

Listen to UI Kit events for user actions, group changes, messages, and call lifecycle updates using CometChatEvents SharedFlow.

AI Integration Quick Reference

Field	Value
Kotlin (XML Views)	com.cometchat:chatuikit-kotlin-android
Jetpack Compose	com.cometchat:chatuikit-compose-android
Import	com.cometchat.uikit.core.events.CometChatEvents
Event flows	CometChatEvents.messageEvents, CometChatEvents.callEvents, CometChatEvents.conversationEvents, CometChatEvents.groupEvents, CometChatEvents.userEvents, CometChatEvents.uiEvents
Pattern	Kotlin SharedFlow with sealed class event types — collect in viewModelScope or lifecycleScope
Purpose	Decoupled communication between UI Kit components — subscribe to event flows to react to changes without direct component references

Events enable a decoupled, flexible architecture in the CometChat UI Kit. Components emit events via the CometChatEvents singleton, and other parts of your application collect these SharedFlow streams to react without direct references between components.

When to use this

• You need to update your UI when a user is blocked or unblocked.
• You need to respond to group actions such as member joins, kicks, bans, or ownership transfers.
• You need to track conversation deletions or updates in real time.
• You need to react to messages being sent, edited, deleted, or read.
• You need to handle call lifecycle events (outgoing, accepted, rejected, ended).
• You need to respond to UI-level events such as panel visibility changes or active chat changes.

Prerequisites

• The com.cometchat:chatuikit-kotlin-android or com.cometchat:chatuikit-compose-android dependency added to your project.
• CometChatUIKit.init() called and completed successfully.
• A logged-in CometChat user (call CometChatUIKit.login() before collecting events).

CometChatEvents Singleton

All events are accessed through the CometChatEvents singleton in chatuikit-core. Each domain has a dedicated SharedFlow that emits sealed class event types:

import com.cometchat.uikit.core.events.CometChatEvents

Flow	Sealed Class	Description
CometChatEvents.messageEvents	MessageEvent	Message sent, edited, deleted, read, reactions
CometChatEvents.callEvents	CallEvent	Call initiated, accepted, rejected, ended
CometChatEvents.conversationEvents	ConversationEvent	Conversation deleted, updated
CometChatEvents.groupEvents	GroupEvent	Group created, deleted, member changes
CometChatEvents.userEvents	UserEvent	User blocked, unblocked
CometChatEvents.uiEvents	UIEvent	Panel visibility, active chat changes

API reference

Message Events

CometChatEvents.messageEvents emits MessageEvent sealed class instances when messages are sent, edited, deleted, or read.

Event types:

Event	Description
MessageEvent.Sent(message, status)	Triggered when a message is sent. Status can be inProgress or sent.
MessageEvent.Edited(message, status)	Triggered when a message is edited. Status can be inProgress or sent.
MessageEvent.Deleted(message)	Triggered when a message is deleted.
MessageEvent.Read(message)	Triggered when a message is read.
MessageEvent.LiveReaction(icon)	Triggered when a live reaction is sent.
MessageEvent.FormReceived(message)	Triggered when a form message is received.
MessageEvent.CardReceived(message)	Triggered when a card message is received.
MessageEvent.CustomInteractiveReceived(message)	Triggered when a custom interactive message is received.
MessageEvent.InteractionGoalCompleted(message)	Triggered when an interaction goal is completed.
MessageEvent.SchedulerReceived(message)	Triggered when a scheduler message is received.

Collecting events:

Kotlin (XML Views)

// In an Activity or Fragment — use lifecycleScope
lifecycleScope.launch {
    CometChatEvents.messageEvents.collect { event ->
        when (event) {
            is MessageEvent.Sent -> {
                val message = event.message
                val status = event.status
                // Update UI when message is sent
            }
            is MessageEvent.Edited -> {
                val message = event.message
                // Update UI when message is edited
            }
            is MessageEvent.Deleted -> {
                val message = event.message
                // Remove message from UI
            }
            is MessageEvent.Read -> {
                val message = event.message
                // Update read receipts
            }
            is MessageEvent.LiveReaction -> {
                val icon = event.icon
                // Show live reaction animation
            }
            is MessageEvent.FormReceived -> { /* Handle form message */ }
            is MessageEvent.CardReceived -> { /* Handle card message */ }
            is MessageEvent.CustomInteractiveReceived -> { /* Handle custom interactive */ }
            is MessageEvent.InteractionGoalCompleted -> { /* Handle goal completion */ }
            is MessageEvent.SchedulerReceived -> { /* Handle scheduler message */ }
        }
    }
}

Jetpack Compose

@Composable
fun MessageEventsHandler() {
    LaunchedEffect(Unit) {
        CometChatEvents.messageEvents.collect { event ->
            when (event) {
                is MessageEvent.Sent -> {
                    val message = event.message
                    val status = event.status
                    // Update UI when message is sent
                }
                is MessageEvent.Edited -> {
                    val message = event.message
                    // Update UI when message is edited
                }
                is MessageEvent.Deleted -> {
                    val message = event.message
                    // Remove message from UI
                }
                is MessageEvent.Read -> {
                    val message = event.message
                    // Update read receipts
                }
                is MessageEvent.LiveReaction -> {
                    val icon = event.icon
                    // Show live reaction animation
                }
                is MessageEvent.FormReceived -> { /* Handle form message */ }
                is MessageEvent.CardReceived -> { /* Handle card message */ }
                is MessageEvent.CustomInteractiveReceived -> { /* Handle custom interactive */ }
                is MessageEvent.InteractionGoalCompleted -> { /* Handle goal completion */ }
                is MessageEvent.SchedulerReceived -> { /* Handle scheduler message */ }
            }
        }
    }
}

What this does: Collects the messageEvents SharedFlow and pattern-matches on the sealed class to handle each message lifecycle event.

---

Call Events

CometChatEvents.callEvents emits CallEvent sealed class instances for call lifecycle changes.

Event types:

Event	Description
CallEvent.OutgoingCall(call)	Triggered when the logged-in user initiates an outgoing call.
CallEvent.Accepted(call)	Triggered when a call is accepted.
CallEvent.Rejected(call)	Triggered when a call is rejected.
CallEvent.Ended(call)	Triggered when a call is ended.

Collecting events:

Kotlin (XML Views)

lifecycleScope.launch {
    CometChatEvents.callEvents.collect { event ->
        when (event) {
            is CallEvent.OutgoingCall -> {
                val call = event.call
                // Handle outgoing call initiated
            }
            is CallEvent.Accepted -> {
                val call = event.call
                // Handle call accepted
            }
            is CallEvent.Rejected -> {
                val call = event.call
                // Handle call rejected
            }
            is CallEvent.Ended -> {
                val call = event.call
                // Handle call ended
            }
        }
    }
}

Jetpack Compose

@Composable
fun CallEventsHandler() {
    LaunchedEffect(Unit) {
        CometChatEvents.callEvents.collect { event ->
            when (event) {
                is CallEvent.OutgoingCall -> {
                    // Handle outgoing call initiated
                }
                is CallEvent.Accepted -> {
                    // Handle call accepted
                }
                is CallEvent.Rejected -> {
                    // Handle call rejected
                }
                is CallEvent.Ended -> {
                    // Handle call ended
                }
            }
        }
    }
}

---

Conversation Events

CometChatEvents.conversationEvents emits ConversationEvent sealed class instances when conversations are deleted or updated.

Event types:

Event	Description
ConversationEvent.Deleted(conversation)	Triggered when the logged-in user deletes a conversation.
ConversationEvent.Updated(conversation)	Triggered when there is an update in the conversation.

Collecting events:

Kotlin (XML Views)

lifecycleScope.launch {
    CometChatEvents.conversationEvents.collect { event ->
        when (event) {
            is ConversationEvent.Deleted -> {
                val conversation = event.conversation
                // Remove conversation from UI
            }
            is ConversationEvent.Updated -> {
                val conversation = event.conversation
                // Update conversation in UI
            }
        }
    }
}

Jetpack Compose

@Composable
fun ConversationEventsHandler() {
    LaunchedEffect(Unit) {
        CometChatEvents.conversationEvents.collect { event ->
            when (event) {
                is ConversationEvent.Deleted -> {
                    // Remove conversation from UI
                }
                is ConversationEvent.Updated -> {
                    // Update conversation in UI
                }
            }
        }
    }
}

---

Group Events

CometChatEvents.groupEvents emits GroupEvent sealed class instances when the logged-in user performs group-related actions.

Event types:

Event	Description
GroupEvent.Created(group)	Triggered when the logged-in user creates a group.
GroupEvent.Deleted(group)	Triggered when the logged-in user deletes a group.
GroupEvent.Left(actionMessage, leftUser, leftGroup)	Triggered when the logged-in user leaves a group.
GroupEvent.MemberScopeChanged(actionMessage, updatedUser, scopeChangedTo, scopeChangedFrom, group)	Triggered when a member’s scope is changed.
GroupEvent.MemberBanned(actionMessage, bannedUser, bannedBy, bannedFrom)	Triggered when a member is banned from a group.
GroupEvent.MemberKicked(actionMessage, kickedUser, kickedBy, kickedFrom)	Triggered when a member is kicked from a group.
GroupEvent.MemberUnBanned(actionMessage, unbannedUser, unBannedBy, unBannedFrom)	Triggered when a member is unbanned from a group.
GroupEvent.MemberJoined(joinedUser, joinedGroup)	Triggered when the logged-in user joins a group.
GroupEvent.MemberAdded(actionMessages, usersAdded, userAddedIn, addedBy)	Triggered when members are added to a group.
GroupEvent.OwnershipChanged(group, newOwner)	Triggered when group ownership is transferred.

Collecting events:

Kotlin (XML Views)

lifecycleScope.launch {
    CometChatEvents.groupEvents.collect { event ->
        when (event) {
            is GroupEvent.Created -> {
                val group = event.group
                // Add new group to UI
            }
            is GroupEvent.Deleted -> {
                val group = event.group
                // Remove group from UI
            }
            is GroupEvent.Left -> {
                val leftUser = event.leftUser
                val leftGroup = event.leftGroup
                // Handle user leaving group
            }
            is GroupEvent.MemberScopeChanged -> {
                val updatedUser = event.updatedUser
                val newScope = event.scopeChangedTo
                // Update member scope in UI
            }
            is GroupEvent.MemberBanned -> {
                val bannedUser = event.bannedUser
                // Remove banned user from member list
            }
            is GroupEvent.MemberKicked -> {
                val kickedUser = event.kickedUser
                // Remove kicked user from member list
            }
            is GroupEvent.MemberUnBanned -> {
                val unbannedUser = event.unbannedUser
                // Handle unbanned user
            }
            is GroupEvent.MemberJoined -> {
                val joinedUser = event.joinedUser
                // Add user to member list
            }
            is GroupEvent.MemberAdded -> {
                val usersAdded = event.usersAdded
                // Add users to member list
            }
            is GroupEvent.OwnershipChanged -> {
                val newOwner = event.newOwner
                // Update group owner in UI
            }
        }
    }
}

Jetpack Compose

@Composable
fun GroupEventsHandler() {
    LaunchedEffect(Unit) {
        CometChatEvents.groupEvents.collect { event ->
            when (event) {
                is GroupEvent.Created -> { /* Add new group to UI */ }
                is GroupEvent.Deleted -> { /* Remove group from UI */ }
                is GroupEvent.Left -> { /* Handle user leaving group */ }
                is GroupEvent.MemberScopeChanged -> { /* Update member scope */ }
                is GroupEvent.MemberBanned -> { /* Remove banned user */ }
                is GroupEvent.MemberKicked -> { /* Remove kicked user */ }
                is GroupEvent.MemberUnBanned -> { /* Handle unbanned user */ }
                is GroupEvent.MemberJoined -> { /* Add user to member list */ }
                is GroupEvent.MemberAdded -> { /* Add users to member list */ }
                is GroupEvent.OwnershipChanged -> { /* Update group owner */ }
            }
        }
    }
}

---

User Events

CometChatEvents.userEvents emits UserEvent sealed class instances when the logged-in user blocks or unblocks another user.

Event types:

Event	Description
UserEvent.Blocked(user)	Triggered when the logged-in user blocks another user.
UserEvent.Unblocked(user)	Triggered when the logged-in user unblocks another user.

Collecting events:

Kotlin (XML Views)

lifecycleScope.launch {
    CometChatEvents.userEvents.collect { event ->
        when (event) {
            is UserEvent.Blocked -> {
                val user = event.user
                // Update UI to reflect blocked user
            }
            is UserEvent.Unblocked -> {
                val user = event.user
                // Update UI to reflect unblocked user
            }
        }
    }
}

Jetpack Compose

@Composable
fun UserEventsHandler() {
    LaunchedEffect(Unit) {
        CometChatEvents.userEvents.collect { event ->
            when (event) {
                is UserEvent.Blocked -> {
                    // Update UI to reflect blocked user
                }
                is UserEvent.Unblocked -> {
                    // Update UI to reflect unblocked user
                }
            }
        }
    }
}

---

UI Events

CometChatEvents.uiEvents emits UIEvent sealed class instances for UI-level actions such as panel visibility and active chat changes.

Event types:

Event	Description
UIEvent.ShowPanel(id, alignment, view)	Triggered to show an additional UI panel with custom elements.
UIEvent.HidePanel(id, alignment)	Triggered to hide a previously shown UI panel.
UIEvent.ActiveChatChanged(id, message, user, group)	Triggered when the active chat changes.
UIEvent.OpenChat(user, group)	Triggered to open a chat with a specific user or group.

Collecting events:

Kotlin (XML Views)

lifecycleScope.launch {
    CometChatEvents.uiEvents.collect { event ->
        when (event) {
            is UIEvent.ShowPanel -> {
                val alignment = event.alignment
                // Show custom UI panel
            }
            is UIEvent.HidePanel -> {
                val alignment = event.alignment
                // Hide custom UI panel
            }
            is UIEvent.ActiveChatChanged -> {
                val user = event.user
                val group = event.group
                // React to active chat change
            }
            is UIEvent.OpenChat -> {
                val user = event.user
                val group = event.group
                // Navigate to chat with user or group
            }
        }
    }
}

Jetpack Compose

@Composable
fun UIEventsHandler() {
    LaunchedEffect(Unit) {
        CometChatEvents.uiEvents.collect { event ->
            when (event) {
                is UIEvent.ShowPanel -> { /* Show custom UI panel */ }
                is UIEvent.HidePanel -> { /* Hide custom UI panel */ }
                is UIEvent.ActiveChatChanged -> { /* React to active chat change */ }
                is UIEvent.OpenChat -> { /* Navigate to chat */ }
            }
        }
    }
}

---

Lifecycle Management

Since SharedFlow collection is coroutine-based, lifecycle management is handled automatically:

• In XML Views, use lifecycleScope.launch — the coroutine is cancelled when the lifecycle owner is destroyed.
• In Jetpack Compose, use LaunchedEffect — the coroutine is cancelled when the composable leaves the composition.

No manual removeListener calls are needed, unlike the old static listener pattern.

---

Next steps

Methods Reference

UI Kit wrapper methods for initialization, authentication, and sending messages

Conversations

Display and manage the conversation list, which reacts to conversation events

Message List

Display messages in a chat, which reacts to message events