All Real Time Listeners - CometChat Docs

AI Integration Quick Reference

Field	Value
Package	`@cometchat/chat-sdk-react-native`
Import	`import { CometChat } from "@cometchat/chat-sdk-react-native";`
Key Methods	`addCallListener()`, `addGroupListener()`, `addMessageListener()`, `addUserListener()`, `removeCallListener()`, `removeGroupListener()`, `removeMessageListener()`, `removeUserListener()`
Key Classes	`Action`, `BaseMessage`, `Call`, `CallListener`, `CardMessage`, `CustomMessage`
Prerequisites	SDK initialized via `CometChat.init()` and a logged-in user via `CometChat.login()`
Primary output	Every `addListener()` / `removeListener()` returns `void` — events arrive on the callbacks you register, never as a return value
Constraints	Every `addListener()` needs a matching `removeListener()` with the same listener ID — unremoved listeners leak and fire after unmount. Listener IDs are global — reusing one silently replaces the earlier listener.
Related	Receive Messages · Connection Status · User Presence
Full reference	`BaseMessage` · `User` · `Group` · `CometChatException`

// User Listener — online/offline presence
CometChat.addUserListener("ID", new CometChat.UserListener({
  onUserOnline: (user) => { },
  onUserOffline: (user) => { }
}));

// Message Listener — messages, typing, receipts, reactions
CometChat.addMessageListener("ID", new CometChat.MessageListener({
  onTextMessageReceived: (msg) => { },
  onMediaMessageReceived: (msg) => { },
  onTypingStarted: (indicator) => { },
  onMessagesRead: (receipt) => { }
}));

// Group Listener — member join/leave/kick/ban/scope changes
CometChat.addGroupListener("ID", new CometChat.GroupListener({
  onGroupMemberJoined: (action, joinedUser, joinedGroup) => { },
  onGroupMemberLeft: (action, leftUser, leftGroup) => { }
}));

// Call Listener — incoming/outgoing call events
CometChat.addCallListener("ID", new CometChat.CallListener({
  onIncomingCallReceived: (call) => { },
  onOutgoingCallAccepted: (call) => { }
}));

// Always clean up
CometChat.removeUserListener("ID");
CometChat.removeMessageListener("ID");
CometChat.removeGroupListener("ID");
CometChat.removeCallListener("ID");

Real-time listeners let you receive live events — messages, presence changes, group updates, and call signals — as they happen. The pattern is the same for all four listener types:

Register a listener with a unique ID using addXListener()
Handle events in the callback methods
Remove the listener with removeXListener() when it’s no longer needed

Each listener ID must be unique. Re-registering with the same ID replaces the previous listener. Always remove listeners on component unmount to prevent memory leaks.

Always remove listeners when they’re no longer needed (e.g., on component unmount). Failing to remove listeners can cause memory leaks and duplicate event handling. For React Native, use useEffect cleanup functions to handle listener removal automatically.

CometChat provides 4 listeners viz.

With offline support enabled, four more listeners report what the SDK does on the device; see Offline listeners.

User Listener

Receive online/offline presence events for users.

Method	Information
onUserOnline(user: CometChat.User)	This method is triggered when a user comes online and is available to chat. The details of the user can be obtained from the user object received as the method parameter.
onUserOffline(user: CometChat.User)	This method is triggered when a user goes offline. The details of the user can be obtained from the User object received as the parameter.

To add the UserListener:

TypeScript
JavaScript

const listenerID: string = "UNIQUE_LISTENER_ID";
CometChat.addUserListener(
  listenerID,
  new CometChat.UserListener({
    onUserOnline: (onlineUser: CometChat.User) => {
      console.log("On User Online:", { onlineUser });
    },
    onUserOffline: (offlineUser: CometChat.User) => {
      console.log("On User Offline:", { offlineUser });
    },
  })
);

const listenerID = "UNIQUE_LISTENER_ID";
CometChat.addUserListener(
  listenerID,
  new CometChat.UserListener({
    onUserOnline: (onlineUser) => {
      console.log("On User Online:", { onlineUser });
    },
    onUserOffline: (offlineUser) => {
      console.log("On User Offline:", { offlineUser });
    },
  })
);

Remove the listener when no longer needed:

TypeScript
JavaScript

let listenerID: string = "UNIQUE_LISTENER_ID";
CometChat.removeUserListener(listenerID);

let listenerID = "UNIQUE_LISTENER_ID";
CometChat.removeUserListener(listenerID);

Group Listener

Receive events when group members join, leave, are kicked/banned, or have their scope changed.

Method	Information
onGroupMemberJoined(action: CometChat.Action, joinedUser: CometChat.User, joinedGroup: CometChat.Group)	This method is triggered when a user joins any group. All the members present in the group will receive this event.
onGroupMemberLeft(action: CometChat.Action, leftUser: CometChat.User, leftGroup: CometChat.Group)	This method is triggered when a user who was a member of any group leaves the group. All the members of the group receive this event.
onGroupMemberKicked(action: CometChat.Action, kickedUser: CometChat.User, kickedBy: CometChat.User, kickedFrom: CometChat.Group)	This method is triggered when a user is kicked from a group. All the members including the user receive this event
onGroupMemberBanned(action: CometChat.Action, bannedUser: CometChat.User, bannedBy: CometChat.User, bannedFrom: CometChat.Group)	This method is triggered when a user is banned from a group. All the members including the user receive this event
onGroupMemberUnbanned(action: CometChat.Action, unbannedUser: CometChat.User, unbannedBy: CometChat.User, unbannedFrom: CometChat.Group)	This method is triggered when a user is unbanned from a group. All the members of the group receive this event.
onGroupMemberScopeChanged(action: CometChat.Action, changedUser: CometChat.User, newScope: string, oldScope: string, changedGroup: CometChat.Group)	This method is triggered when the scope of any Group Member has been changed. All the members that are a part of that group receive this event
onMemberAddedToGroup(action: CometChat.Action, userAdded: CometChat.User, addedBy: CometChat.User, addedTo: CometChat.Group)	This method is triggered when a user is added to any group. All the members including the user himself receive this event.

To add the GroupListener:

TypeScript
JavaScript

CometChat.addGroupListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.GroupListener({
    onGroupMemberJoined: (
      message: CometChat.Action,
      joinedUser: CometChat.User,
      joinedGroup: CometChat.Group
    ) => {
      console.log("onGroupMemberJoined", { message, joinedUser, joinedGroup });
    },
    onGroupMemberLeft: (
      message: CometChat.Action,
      leftUser: CometChat.User,
      leftGroup: CometChat.Group
    ) => {
      console.log("onGroupMemberLeft", { message, leftUser, leftGroup });
    },
    onGroupMemberKicked: (
      message: CometChat.Action,
      kickedUser: CometChat.User,
      kickedBy: CometChat.User,
      kickedFrom: CometChat.Group
    ) => {
      console.log("onGroupMemberKicked", {
        message,
        kickedUser,
        kickedBy,
        kickedFrom,
      });
    },
    onGroupMemberBanned: (
      message: CometChat.Action,
      bannedUser: CometChat.User,
      bannedBy: CometChat.User,
      bannedFrom: CometChat.Group
    ) => {
      console.log("onGroupMemberBanned", {
        message,
        bannedUser,
        bannedBy,
        bannedFrom,
      });
    },
    onGroupMemberUnbanned: (
      message: CometChat.Action,
      unbannedUser: CometChat.User,
      unbannedBy: CometChat.User,
      unbannedFrom: CometChat.Group
    ) => {
      console.log("onGroupMemberUnbanned", {
        message,
        unbannedUser,
        unbannedBy,
        unbannedFrom,
      });
    },
    onGroupMemberScopeChanged: (
      message: CometChat.Action,
      changedUser: CometChat.User,
      newScope: string,
      oldScope: string,
      changedGroup: CometChat.Group
    ) => {
      console.log("onGroupMemberScopeChanged", {
        message,
        changedUser,
        newScope,
        oldScope,
        changedGroup,
      });
    },
    onMemberAddedToGroup: (
      message: CometChat.Action,
      userAdded: CometChat.User,
      addedby: CometChat.User,
      addedTo: CometChat.Group
    ) => {
      console.log("onMemberAddedToGroup", {
        message,
        userAdded,
        addedby,
        addedTo,
      });
    },
  })
);

CometChat.addGroupListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.GroupListener({
    onGroupMemberJoined: (message, joinedUser, joinedGroup) => {
      console.log("onGroupMemberJoined", { message, joinedUser, joinedGroup });
    },
    onGroupMemberLeft: (message, leftUser, leftGroup) => {
      console.log("onGroupMemberLeft", { message, leftUser, leftGroup });
    },
    onGroupMemberKicked: (message, kickedUser, kickedBy, kickedFrom) => {
      console.log("onGroupMemberKicked", {
        message,
        kickedUser,
        kickedBy,
        kickedFrom,
      });
    },
    onGroupMemberBanned: (message, bannedUser, bannedBy, bannedFrom) => {
      console.log("onGroupMemberBanned", {
        message,
        bannedUser,
        bannedBy,
        bannedFrom,
      });
    },
    onGroupMemberUnbanned: (
      message,
      unbannedUser,
      unbannedBy,
      unbannedFrom
    ) => {
      console.log("onGroupMemberUnbanned", {
        message,
        unbannedUser,
        unbannedBy,
        unbannedFrom,
      });
    },
    onGroupMemberScopeChanged: (
      message,
      changedUser,
      newScope,
      oldScope,
      changedGroup
    ) => {
      console.log("onGroupMemberScopeChanged", {
        message,
        changedUser,
        newScope,
        oldScope,
        changedGroup,
      });
    },
    onMemberAddedToGroup: (message, userAdded, addedby, addedTo) => {
      console.log("onMemberAddedToGroup", {
        message,
        userAdded,
        addedby,
        addedTo,
      });
    },
  })
);

Remove the listener when no longer needed:

TypeScript
JavaScript

let listenerID: string = "UNIQUE_LISTENER_ID";
CometChat.removeGroupListener(listenerID);

let listenerID = "UNIQUE_LISTENER_ID";
CometChat.removeGroupListener(listenerID);

Message Listener

Receive events for incoming messages, typing indicators, read/delivery receipts, message edits/deletes, reactions, and interactive messages.

With offline support enabled, MessageListener also receives onMessagesSynced after the SDK catches up on reconnect. It carries only updates to already-cached messages that changed while offline (reactions, edits, deletes and receipts). Messages that arrived while offline still come through the typed callbacks such as onTextMessageReceived. See Stay in Sync.

Method	Information
onTextMessageReceived(message: CometChat.TextMessage)	This event is triggered when a Text Message is received.
onMediaMessageReceived(message: CometChat.MediaMessage)	This event is triggered when a Media Message is received.
onCustomMessageReceived(message: CometChat.CustomMessage)	This event is triggered when a Custom Message is received.
onTypingStarted(typingIndicator: CometChat.TypingIndicator)	This event is triggered when a user starts typing in a user/group conversation
onTypingEnded(typingIndicator: CometChat.TypingIndicator)	This event is triggered when a user stops typing in a user/group conversation.
onMessagesDelivered(messageReceipt: CometChat.MessageReceipt)	This event is triggered when a set of messages are marked as delivered for any particular conversation.
onMessagesRead(messageReceipt: CometChat.MessageReceipt)	This event is triggered when a set of messages are marked as read for any particular conversation.
onMessageEdited(message: CometChat.BaseMessage)	This method is triggered when a particular message has been edited in a user/group conversation.
onMessageDeleted(message: CometChat.BaseMessage)	This event is triggered when a particular message is deleted in a user/group conversation.
onInteractiveMessageReceived(message: CometChat.InteractiveMessage)	This event is triggered when an Interactive Message is received.
onInteractionGoalCompleted(receipt: CometChat.InteractionReceipt)	This event is triggered when an interaction Goal is achieved.
onTransientMessageReceived(receipt: CometChat.TransientMessage)	This event is triggered when a Transient Message is received.
onMessageReactionAdded(receipt: CometChat.ReactionEvent)	This event is triggered when a reaction is added to a message in a user/group conversation.
onMessageReactionRemoved(receipt: CometChat.ReactionEvent)	This event is triggered when a reaction is removed from a message in a user/group conversation.
onCardMessageReceived(message: CometChat.CardMessage)	This event is triggered when a card message (`category: "card"`) is received. See Campaigns → Card Messages.
onMessagePinned(message: CometChat.BaseMessage)	This event is triggered when a message is pinned in a user/group conversation. Broadcast to everyone in that conversation.
onMessageUnpinned(message: CometChat.BaseMessage)	This event is triggered when a message is unpinned in a user/group conversation.
onMessageSaved(message: CometChat.BaseMessage)	This event is triggered when the logged-in user saves a message. Private and delivered to that user’s other devices only.
onMessageUnsaved(message: CometChat.BaseMessage)	This event is triggered when the logged-in user unsaves a message.

To add the MessageListener:

TypeScript
JavaScript

CometChat.addMessageListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.MessageListener({
    onTextMessageReceived: (textMessage: CometChat.TextMessage) => {
      console.log("Text message received successfully", textMessage);
    },
    onMediaMessageReceived: (mediaMessage: CometChat.MediaMessage) => {
      console.log("Media message received successfully", mediaMessage);
    },
    onCustomMessageReceived: (customMessage: CometChat.CustomMessage) => {
      console.log("Custom message received successfully", customMessage);
    },
    onMessagesDelivered: (messageReceipt: CometChat.MessageReceipt) => {
      console.log("Message Delivered", messageReceipt);
    },
    onMessagesRead: (messageReceipt: CometChat.MessageReceipt) => {
      console.log("Message Read", messageReceipt);
    },
    onTypingStarted: (typingIndicator: CometChat.TypingIndicator) => {
      console.log("Typing Started", typingIndicator);
    },
    onTypingEnded: (typingIndicator: CometChat.TypingIndicator) => {
      console.log("Typing Ended", typingIndicator);
    },
    onMessageDeleted: (message: CometChat.BaseMessage) => {
      console.log("Message Deleted", message);
    },
    onMessageEdited: (message: CometChat.BaseMessage) => {
      console.log("Message Edited", message);
    },
    onInteractiveMessageReceived: (message: CometChat.InteractiveMessage) => {
      console.log("Interactive Message received", message);
    },
    onInteractionGoalCompleted: (receipt: CometChat.InteractionReceipt) => {
      console.log("Interaction goal completed", receipt);
    },
    onTransientMessageReceived: (message: CometChat.TransientMessage) => {
      console.log("Transient Message received", message);
    },
    onMessageReactionAdded: (reaction: CometChat.ReactionEvent) => {
      console.log("Message Reaction added", reaction);
    },
    onMessageReactionRemoved: (reaction: CometChat.ReactionEvent) => {
      console.log("Message Reaction removed", reaction);
    },
    onCardMessageReceived: (cardMessage: CometChat.CardMessage) => {
      console.log("Card message received", cardMessage);
    },
    onMessagePinned: (message: CometChat.BaseMessage) => {
      console.log("Message pinned", message);
    },
    onMessageUnpinned: (message: CometChat.BaseMessage) => {
      console.log("Message unpinned", message);
    },
    onMessageSaved: (message: CometChat.BaseMessage) => {
      console.log("Message saved", message);
    },
    onMessageUnsaved: (message: CometChat.BaseMessage) => {
      console.log("Message unsaved", message);
    },
  })
);

CometChat.addMessageListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.MessageListener({
    onTextMessageReceived: (textMessage) => {
      console.log("Text message received successfully", textMessage);
    },
    onMediaMessageReceived: (mediaMessage) => {
      console.log("Media message received successfully", mediaMessage);
    },
    onCustomMessageReceived: (customMessage) => {
      console.log("Custom message received successfully", customMessage);
    },
    onMessagesDelivered: (messageReceipt) => {
      console.log("Message Delivered", messageReceipt);
    },
    onMessagesRead: (messageReceipt) => {
      console.log("Message Read", messageReceipt);
    },
    onTypingStarted: (typingIndicator) => {
      console.log("Typing Started", typingIndicator);
    },
    onTypingEnded: (typingIndicator) => {
      console.log("Typing Ended", typingIndicator);
    },
    onMessageDeleted: (message) => {
      console.log("Message Deleted", message);
    },
    onMessageEdited: (message) => {
      console.log("Message Edited", message);
    },
    onInteractiveMessageReceived: (message) => {
      console.log("Interactive Message received", message);
    },
    onInteractionGoalCompleted: (receipt) => {
      console.log("Interaction goal completed", receipt);
    },
    onTransientMessageReceived: (message) => {
      console.log("Transient Message received", message);
    },
    onMessageReactionAdded: (reaction) => {
      console.log("Message Reaction added", reaction);
    },
    onMessageReactionRemoved: (reaction) => {
      console.log("Message Reaction removed", reaction);
    },
    onCardMessageReceived: (cardMessage) => {
      console.log("Card message received", cardMessage);
    },
    onMessagePinned: (message) => {
      console.log("Message pinned", message);
    },
    onMessageUnpinned: (message) => {
      console.log("Message unpinned", message);
    },
    onMessageSaved: (message) => {
      console.log("Message saved", message);
    },
    onMessageUnsaved: (message) => {
      console.log("Message unsaved", message);
    },
  })
);

Remove the listener when no longer needed:

TypeScript
JavaScript

let listenerID: string = "UNIQUE_LISTENER_ID";
CometChat.removeMessageListener(listenerID);

let listenerID = "UNIQUE_LISTENER_ID";
CometChat.removeMessageListener(listenerID);

Pin and unpin are conversation-wide — every participant receives them. Save and unsave are private multi-device: they reach the saving user’s other sessions, not the device that performed the save, which already has the message resolved from the saveMessage() promise. Each callback carries the full updated message, so getPinnedAt() / getSavedAt() are readable without a further fetch. See Pin A Message and Save A Message.

Conversation pins use a separate ConversationListener, with onConversationPinned and onConversationUnpinned. It fires on the user’s other devices and for admin pins, not on the device that pinned. See Pin A Conversation.

Call Listener

Receive events for incoming and outgoing call state changes.

Method	Information
onIncomingCallReceived(call: CometChat.Call)	This event is triggered when the logged-in user receives an incoming call. The details of the call can be obtained from the Call object received as the method parameter.
onOutgoingCallAccepted(call: CometChat.Call)	This event is triggered when the call initiated by the logged-in user is accepted by the recipient. The details of the call can be obtained from the Call object received as the method parameter.
onOutgoingCallRejected(call: CometChat.Call)	This event is triggered when the call initiated by the logged-in user is rejected by the recipient. The details of the call can be obtained from the Call object received as the method parameter
onIncomingCallCancelled(call: CometChat.Call)	This event is triggered when an incoming call is canceled by the initiator of the call. The details of the call can be obtained from the Call object received as the method parameter

To add the CallListener:

TypeScript
JavaScript

CometChat.addCallListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.CallListener({
    onIncomingCallReceived: (call: CometChat.Call) => {
      console.log("Incoming call:", call);
    },
    onOutgoingCallAccepted: (call: CometChat.Call) => {
      console.log("Outgoing call accepted:", call);
    },
    onOutgoingCallRejected: (call: CometChat.Call) => {
      console.log("Outgoing call rejected:", call);
    },
    onIncomingCallCancelled: (call: CometChat.Call) => {
      console.log("Incoming call canceled:", call);
    },
  })
);

CometChat.addCallListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.CallListener({
    onIncomingCallReceived(call) {
      console.log("Incoming call:", call);
    },
    onOutgoingCallAccepted(call) {
      console.log("Outgoing call accepted:", call);
    },
    onOutgoingCallRejected(call) {
      console.log("Outgoing call rejected:", call);
    },
    onIncomingCallCancelled(call) {
      console.log("Incoming call canceled:", call);
    },
  })
);

Remove the listener when no longer needed:

TypeScript
JavaScript

let listenerID: string = "UNIQUE_LISTENER_ID";
CometChat.removeCallListener(listenerID);

let listenerID = "UNIQUE_LISTENER_ID";
CometChat.removeCallListener(listenerID);

Offline listeners

With offline support enabled (SDK 4.2.0 or newer), these listeners report what the SDK does on the device rather than events from the server. Each is documented with examples on its own page.

Listener	What it reports	Details
`OfflineMessageListener`	Every outbox transition, app-wide: a message queued, sent or failed	Send While Offline
`SyncListener`	Progress and outcome of each catch-up sync	Stay in Sync
`OfflineCacheResetListener`	The on-device cache was rebuilt, for example after the encryption key was lost	Encrypt the Cache
`MediaDownloadListener`	A background media download finished or failed	Media Caching

Next Steps

User Presence

Track when users come online or go offline

Receive Messages

Handle incoming messages in real time

Typing Indicators

Show when users are typing

Connection Status

Monitor SDK connection state changes

​User Listener

​Group Listener

​Message Listener

​Call Listener

​Offline listeners

​Next Steps

User Presence

Receive Messages

Typing Indicators

Connection Status

User Listener

Group Listener

Message Listener

Call Listener

Offline listeners

Next Steps