> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-rn-guide-message-privately.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Events

> Handle CometChat Android UI Kit events for users, groups, messages, conversations, calls, and UI-level interactions.

<Accordion title="AI Integration Quick Reference">
  | Field               | Value                                                                                                                                                                                                                    |
  | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
  | Package             | `com.cometchat:chat-uikit-android`                                                                                                                                                                                       |
  | Conversation events | `ccConversationDeleted`                                                                                                                                                                                                  |
  | User events         | `ccUserBlocked`, `ccUserUnblocked`                                                                                                                                                                                       |
  | Group events        | `ccGroupCreated`, `ccGroupDeleted`, `ccGroupLeft`, `ccGroupMemberScopeChanged`, `ccGroupMemberKicked`, `ccGroupMemberBanned`, `ccGroupMemberUnBanned`, `ccGroupMemberJoined`, `ccGroupMemberAdded`, `ccOwnershipChanged` |
  | Message events      | `ccMessageSent`, `ccMessageEdited`, `ccMessageDeleted`, `ccMessageRead`, `ccLiveReaction`                                                                                                                                |
  | Call events         | `ccOutgoingCall`, `ccCallAccepted`, `ccCallRejected`, `ccCallEnded`                                                                                                                                                      |
  | Purpose             | Decoupled communication between UI Kit components — subscribe to events to react to changes without direct component references                                                                                          |
</Accordion>

Events enable a decoupled, flexible architecture in the CometChat UI Kit. Components and Composite Components emit events in response to user interactions or state changes, allowing other parts of your application 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 `cometchat-chat-uikit-android` dependency added to your project.
* `CometChatUIKit.init()` called and completed successfully.
* A logged-in CometChat user (call `CometChatUIKit.login()` before registering listeners).

## API reference

### User Events

`CometChatUserEvents` emits events when the logged-in user executes actions on another user. This class provides methods to add and remove listeners for user events, as well as methods to handle specific user actions such as blocking and unblocking users.

**Events:**

| Event             | Description                                              |
| ----------------- | -------------------------------------------------------- |
| `ccUserBlocked`   | Triggered when the logged-in user blocks another user.   |
| `ccUserUnblocked` | Triggered when the logged-in user unblocks another user. |

**Listener registration:**

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    CometChatUserEvents.addUserListener(LISTENERS_TAG, object : CometChatUserEvents() {
        override fun ccUserBlocked(user: User) {
            // Perform action when user is blocked
        }

        override fun ccUserUnblocked(user: User) {
            // Perform action when user is unblocked
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatUserEvents.addUserListener(LISTENERS_TAG, new CometChatUserEvents() {
        @Override
        public void ccUserBlocked(User user) {
            // Perform action when user is blocked
        }

        @Override
        public void ccUserUnblocked(User user) {
            // Perform action when user is unblocked
        }
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Registers a listener on `CometChatUserEvents` using a unique `LISTENERS_TAG`. The `ccUserBlocked` callback fires when the logged-in user blocks another user, and `ccUserUnblocked` fires when the logged-in user unblocks another user.

***

### Group Events

`CometChatGroupEvents` emits events when the logged-in user performs actions related to groups. This class provides methods to listen to various group-related events and handle them.

**Events:**

| Event                       | Description                                                                                                                                                   |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ccGroupCreated`            | Triggered when the logged-in user creates a group.                                                                                                            |
| `ccGroupDeleted`            | Triggered when the logged-in user deletes a group.                                                                                                            |
| `ccGroupLeft`               | Triggered when the logged-in user leaves a group. Provides the action message, the user who left, and the group.                                              |
| `ccGroupMemberScopeChanged` | Triggered when the logged-in user changes the scope of another group member. Provides the action message, updated user, new scope, previous scope, and group. |
| `ccGroupMemberBanned`       | Triggered when the logged-in user bans a group member from the group. Provides the action message, banned user, who banned them, and the group.               |
| `ccGroupMemberKicked`       | Triggered when the logged-in user kicks another group member from the group. Provides the action message, kicked user, who kicked them, and the group.        |
| `ccGroupMemberUnBanned`     | Triggered when the logged-in user unbans a user banned from the group. Provides the action message, unbanned user, who unbanned them, and the group.          |
| `ccGroupMemberJoined`       | Triggered when the logged-in user joins a group. Provides the joined user and the group.                                                                      |
| `ccGroupMemberAdded`        | Triggered when the logged-in user adds new members to the group. Provides action messages, added users, the group, and who added them.                        |
| `ccOwnershipChanged`        | Triggered when the logged-in user transfers the ownership of their group to some other member. Provides the group and the new owner (as `GroupMember`).       |

**Listener registration:**

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    CometChatGroupEvents.addGroupListener(LISTENERS_TAG, object : CometChatGroupEvents() {
        override fun ccGroupCreated(group: Group) {
            // Perform action when group is created
        }

        override fun ccGroupDeleted(group: Group) {
            // Perform action when group is deleted
        }

        override fun ccGroupLeft(actionMessage: Action, leftUser: User, leftGroup: Group) {
            // Perform action when user leaves group
        }

        override fun ccGroupMemberScopeChanged(actionMessage: Action, updatedUser: User, scopeChangedTo: String, scopeChangedFrom: String, group: Group) {
            // Perform action when group member scope is changed
        }

        override fun ccGroupMemberBanned(actionMessage: Action, bannedUser: User, bannedBy: User, bannedFrom: Group) {
            // Perform action when user is banned from group
        }

        override fun ccGroupMemberKicked(actionMessage: Action, kickedUser: User, kickedBy: User, kickedFrom: Group) {
            // Perform action when user is kicked from group
        }

        override fun ccGroupMemberUnBanned(actionMessage: Action, unbannedUser: User, unBannedBy: User, unBannedFrom: Group) {
            // Perform action when user is unbanned from group
        }

        override fun ccGroupMemberJoined(joinedUser: User, joinedGroup: Group) {
            // Perform action when user joins group
        }

        override fun ccGroupMemberAdded(actionMessages: List<Action>, usersAdded: List<User>, userAddedIn: Group, addedBy: User) {
            // Perform action when members are added to group
        }

        override fun ccOwnershipChanged(group: Group, newOwner: GroupMember) {
            // Perform action when group ownership is changed
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatGroupEvents.addGroupListener(LISTENERS_TAG, new CometChatGroupEvents() {
        @Override
        public void ccGroupCreated(Group group) {
            // Perform action when group is created
        }

        @Override
        public void ccGroupDeleted(Group group) {
            // Perform action when group is deleted
        }

        @Override
        public void ccGroupLeft(Action actionMessage, User leftUser, Group leftGroup) {
            // Perform action when user leaves group
        }

        @Override
        public void ccGroupMemberScopeChanged(Action actionMessage, User updatedUser, String scopeChangedTo, String scopeChangedFrom, Group group) {
            // Perform action when group member scope is changed
        }

        @Override
        public void ccGroupMemberBanned(Action actionMessage, User bannedUser, User bannedBy, Group bannedFrom) {
            // Perform action when user is banned from group
        }

        @Override
        public void ccGroupMemberKicked(Action actionMessage, User kickedUser, User kickedBy, Group kickedFrom) {
            // Perform action when user is kicked from group
        }

        @Override
        public void ccGroupMemberUnBanned(Action actionMessage, User unbannedUser, User unBannedBy, Group unBannedFrom) {
            // Perform action when user is unbanned from group
        }

        @Override
        public void ccGroupMemberJoined(User joinedUser, Group joinedGroup) {
            // Perform action when user joins group
        }

        @Override
        public void ccGroupMemberAdded(List<Action> actionMessages, List<User> usersAdded, Group userAddedIn, User addedBy) {
            // Perform action when members are added to group
        }

        @Override
        public void ccOwnershipChanged(Group group, GroupMember newOwner) {
            // Perform action when group ownership is changed
        }
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Registers a listener on `CometChatGroupEvents` using a unique `LISTENERS_TAG`. Each callback fires when the logged-in user performs the corresponding group action — creating, deleting, leaving a group, or managing members (scope change, ban, kick, unban, join, add, ownership transfer).

***

### Conversation Events

`CometChatConversationEvents` emits events when the logged-in user performs actions related to conversations. This allows the UI to be updated when conversations change.

**Events:**

| Event                   | Description                                               |
| ----------------------- | --------------------------------------------------------- |
| `ccConversationDeleted` | Triggered when the logged-in user deletes a conversation. |
| `ccUpdateConversation`  | Triggered when there is an update in the conversation.    |

**Listener registration:**

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    CometChatConversationEvents.addListener("LISTENERS_TAG", object : CometChatConversationEvents() {
        override fun ccConversationDeleted(conversation: Conversation) {
            // Perform action when conversation is deleted
        }

        override fun ccUpdateConversation(conversation: Conversation) {
            // Perform action when conversation is updated
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatConversationEvents.addListener("LISTENERS_TAG", new CometChatConversationEvents() {
        @Override
        public void ccConversationDeleted(Conversation conversation) {
            // Perform action when conversation is deleted
        }

        @Override
        public void ccUpdateConversation(Conversation conversation) {
            // Perform action when conversation is updated
        }
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Registers a listener on `CometChatConversationEvents` using a unique listener tag. The `ccConversationDeleted` callback fires when the logged-in user deletes a conversation, and `ccUpdateConversation` fires when a conversation is updated.

***

### Message Events

`CometChatMessageEvents` emits events when various actions are performed on messages within the application. These events facilitate updating the UI when messages change.

**Events:**

| Event                                | Description                                                                                                                       |
| ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| `ccMessageSent`                      | Triggered whenever a logged-in user sends any message. It can have two states: `inProgress` and `sent`.                           |
| `ccMessageEdited`                    | Triggered whenever a logged-in user edits any message from the list of messages. It can have two states: `inProgress` and `sent`. |
| `ccMessageDeleted`                   | Triggered whenever a logged-in user deletes any message from the list of messages.                                                |
| `ccMessageRead`                      | Triggered whenever a logged-in user reads any message.                                                                            |
| `ccLiveReaction`                     | Triggered whenever a logged-in user clicks on live reaction.                                                                      |
| `onFormMessageReceived`              | Triggered when a form message is received.                                                                                        |
| `onCardMessageReceived`              | Triggered when a card message is received.                                                                                        |
| `onCustomInteractiveMessageReceived` | Triggered when a custom interactive message is received.                                                                          |
| `onInteractionGoalCompleted`         | Triggered when an interaction goal is completed.                                                                                  |
| `onSchedulerMessageReceived`         | Triggered when a scheduler message is received.                                                                                   |

**Listener registration:**

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    CometChatMessageEvents.addListener("UNIQUE_ID", object : CometChatMessageEvents() {
        override fun ccMessageSent(baseMessage: BaseMessage?, status: Int) {
            // Perform action when message is sent
        }

        override fun ccMessageEdited(baseMessage: BaseMessage?, status: Int) {
            // Perform action when message is edited
        }

        override fun ccMessageDeleted(baseMessage: BaseMessage?) {
            // Perform action when message is deleted
        }

        override fun ccMessageRead(baseMessage: BaseMessage?) {
            // Perform action when message is read
        }

        override fun ccLiveReaction(icon: Int) {
            // Perform action on live reaction
        }

        // Other overridden methods for handling specific message types and actions
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatMessageEvents.addListener("UNIQUE_ID", new CometChatMessageEvents() {
        @Override
        public void ccMessageSent(BaseMessage baseMessage, int status) {
            // Perform action when message is sent
        }

        @Override
        public void ccMessageEdited(BaseMessage baseMessage, int status) {
            // Perform action when message is edited
        }

        @Override
        public void ccMessageDeleted(BaseMessage baseMessage) {
            // Perform action when message is deleted
        }

        @Override
        public void ccMessageRead(BaseMessage baseMessage) {
            // Perform action when message is read
        }

        @Override
        public void ccLiveReaction(int icon) {
            // Perform action on live reaction
        }

        // Other overridden methods for handling specific message types and actions
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Registers a listener on `CometChatMessageEvents` using a unique ID string. The callbacks fire for message lifecycle events — sending, editing, deleting, reading messages, and reacting with live reactions. Additional overrides handle interactive message types (`onFormMessageReceived`, `onCardMessageReceived`, `onCustomInteractiveMessageReceived`, `onInteractionGoalCompleted`, `onSchedulerMessageReceived`).

***

### Call Events

`CometChatCallEvents` emits events related to calls within the application. This class provides methods to listen to call-related events and handle them.

**Events:**

| Event            | Description                                                   |
| ---------------- | ------------------------------------------------------------- |
| `ccOutgoingCall` | Triggered when the logged-in user initiates an outgoing call. |
| `ccCallAccepted` | Triggered when a call is accepted.                            |
| `ccCallRejected` | Triggered when a call is rejected.                            |
| `ccCallEnded`    | Triggered when a call is ended.                               |

**Listener registration:**

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    CometChatCallEvents.addListener("ListenerID", object : CometChatCallEvents() {
        override fun ccOutgoingCall(call: Call) {
            // Perform action when outgoing call is initiated
        }

        override fun ccCallAccepted(call: Call) {
            // Perform action when call is accepted
        }

        override fun ccCallRejected(call: Call) {
            // Perform action when call is rejected
        }

        override fun ccCallEnded(call: Call) {
            // Perform action when call is ended
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatCallEvents.addListener("ListenerID", new CometChatCallEvents() {
        @Override
        public void ccOutgoingCall(Call call) {
            // Perform action when outgoing call is initiated
        }

        @Override
        public void ccCallAccepted(Call call) {
            // Perform action when call is accepted
        }

        @Override
        public void ccCallRejected(Call call) {
            // Perform action when call is rejected
        }

        @Override
        public void ccCallEnded(Call call) {
            // Perform action when call is ended
        }
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Registers a listener on `CometChatCallEvents` using a unique `"ListenerID"`. The callbacks fire for each stage of the call lifecycle — initiating an outgoing call, accepting, rejecting, and ending a call.

***

### UI Events

`CometChatUIEvents` emits events related to UI components within the CometChat UI Kit. This class provides methods to listen to UI-related events and handle them.

**Events:**

| Event                 | Description                                                                                               |
| --------------------- | --------------------------------------------------------------------------------------------------------- |
| `showPanel`           | Triggered to show an additional UI panel with custom elements.                                            |
| `hidePanel`           | Triggered to hide a previously shown UI panel.                                                            |
| `ccActiveChatChanged` | Triggered when the active chat changes, providing information about the current message, user, and group. |
| `ccOpenChat`          | Triggered to open a chat with a specific user or group.                                                   |

**Listener registration:**

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    CometChatUIEvents.addListener("UNIQUE_ID", object : CometChatUIEvents() {
        override fun showPanel(id: HashMap<String, String>, alignment: UIKitConstants.CustomUIPosition, view: Function1<Context, View>) {
            // Perform action to show UI panel with custom elements
        }

        override fun hidePanel(id: HashMap<String, String>, alignment: UIKitConstants.CustomUIPosition) {
            // Perform action to hide UI panel
        }

        override fun ccActiveChatChanged(id: HashMap<String, String>, message: BaseMessage, user: User, group: Group) {
            // Perform action when active chat changes
        }

        override fun ccOpenChat(user: User, group: Group) {
            // Perform action to open a chat with a specific user or group
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatUIEvents.addListener("UNIQUE_ID", new CometChatUIEvents() {
        @Override
        public void showPanel(HashMap<String, String> id, UIKitConstants.CustomUIPosition alignment, Function1<Context, View> view) {
            // Perform action to show UI panel with custom elements
        }

        @Override
        public void hidePanel(HashMap<String, String> id, UIKitConstants.CustomUIPosition alignment) {
            // Perform action to hide UI panel
        }

        @Override
        public void ccActiveChatChanged(HashMap<String, String> id, BaseMessage message, User user, Group group) {
            // Perform action when active chat changes
        }

        @Override
        public void ccOpenChat(User user, Group group) {
            // Perform action to open a chat with a specific user or group
        }
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Registers a listener on `CometChatUIEvents` using a unique ID string. The callbacks fire for UI-level actions — showing or hiding custom panels, reacting to active chat changes, and opening a chat with a specific user or group.

***

## Removing event listeners

Each event listener class provides methods to add and remove listeners. If you register a listener, remove it when the component or activity is destroyed to prevent memory leaks. Use the same tag or ID string you passed during registration.

***

## Next steps

<CardGroup cols={2}>
  <Card title="Methods Reference" icon="code" href="/ui-kit/android/methods">
    UI Kit wrapper methods for initialization, authentication, and sending messages
  </Card>

  <Card title="Conversations" icon="comments" href="/ui-kit/android/conversations">
    Display and manage the conversation list, which reacts to conversation events
  </Card>

  <Card title="Message List" icon="messages" href="/ui-kit/android/message-list">
    Display messages in a chat, which reacts to message events
  </Card>
</CardGroup>