All Real Time Listeners - CometChat Docs

CometChat provides these real-time listeners:

UserListener
GroupListener
MessageListener
ConversationListener
AIAssistantListener
CallListener

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

User Listener

The UserListener class provides you with live events related to users. Below are the callback methods provided by the UserListener class.

Method	Information
`onUserOnline(User 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 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, you need to use the addUserListener() method provided by the CometChat class.

Java

CometChat.addUserListener(UNIQUE_LISTENER_ID, new CometChat.UserListener() {
  @Override
    public void onUserOnline(User user) {

  }

  @Override
    public void onUserOffline(User user) {

  }
});

where UNIQUE_LISTENER_ID is the unique identifier for the listener. Please make sure that no two listeners are added with the same listener id as this could lead to unexpected behavior resulting in loss of events. Once the activity/fragment where the UserListener is declared is not in use, you need to remove the listener using the removeUserListener() method which takes the id of the listener to be removed as the parameter. We suggest you call this method in the onPause() method of the activity/fragment.

Java

CometChat.removeUserListener(UNIQUE_LISTENER_ID)

Group Listener

The GroupListener class provides you with all the real-time events related to groups. Below are the callback methods provided by the GroupListener class.

Method	Information
`onGroupMemberJoined(Action action, User joinedUser, Group joinedGroup)`	This method is triggered when a user joins any group. All the members present in the group will receive this event.
`onGroupMemberLeft(Action action, User leftUser, Group leftGroup)`	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 action, User kickedUser, User kickedBy, Group kickedFrom)`	This method is triggered when a user is kicked from a group. All the members including the user receive this event
`onGroupMemberBanned(Action action, User bannedUser, User bannedBy, Group bannedFrom)`	This method is triggered when a user is banned from a group. All the members including the user receive this event
`onGroupMemberUnbanned(Action action, User unbannedUser, User unbannedBy, Group unbannedFrom)`	This method is triggered when a user is banned from a group. All the members of the group receive this event.
`onGroupMemberScopeChanged(Action action, User updatedBy, User updatedUser, String scopeChangedTo, String scopeChangedFrom, Group 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 action, User addedby, User userAdded, Group addedTo)`	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, you need to use the addGroupListener() method provided by the CometChat class.

Java
Kotlin

CometChat.addGroupListener("UNIQUE_ID", new CometChat.GroupListener() {
  @Override
  public void onGroupMemberJoined(Action action, User joinedUser, Group joinedGroup) {
  }

  @Override
  public void onGroupMemberLeft(Action action, User leftUser, Group leftGroup) {
  }

  @Override
  public void onGroupMemberKicked(Action action, User kickedUser, User kickedBy, Group kickedFrom) {
  }

  @Override
  public void onGroupMemberBanned(Action action, User bannedUser, User bannedBy, Group bannedFrom) {
  }

  @Override
  public void onGroupMemberUnbanned(Action action, User unbannedUser, User unbannedBy, Group unbannedFrom) {
  }

  @Override
  public void onGroupMemberScopeChanged(Action action, User updatedBy, User updatedUser, String scopeChangedTo, String scopeChangedFrom, Group group) {
  }

  @Override
  public void onMemberAddedToGroup(Action action, User addedby, User userAdded, Group addedTo) {
  }
});

CometChat.addGroupListener("UNIQUE_ID", object : CometChat.GroupListener() {
  override fun onGroupMemberJoined(action: Action, joinedUser: User, joinedGroup: Group) {
  }

  override fun onGroupMemberLeft(action: Action, leftUser: User, leftGroup: Group) {
  }

  override fun onGroupMemberKicked(action: Action, kickedUser: User, kickedBy: User, kickedFrom: Group) {
  }

  override fun onGroupMemberBanned(action: Action, bannedUser: User, bannedBy: User, bannedFrom: Group) {
  }

  override fun onGroupMemberUnbanned(action: Action, unbannedUser: User, unbannedBy: User, unbannedFrom: Group) {
  }

  override fun onGroupMemberScopeChanged(action: Action, updatedBy: User, updatedUser: User, scopeChangedTo: String, scopeChangedFrom: String, group: Group) {
  }

  override fun onMemberAddedToGroup(action: Action, addedby: User, userAdded: User, addedTo: Group) {
  }
})

where UNIQUE_LISTENER_ID is the unique identifier for the listener. Please make sure that no two listeners are added with the same listener id as this could lead to unexpected behavior resulting in loss of events. Once the activity/fragment where the GroupListener is declared is not in use, you need to remove the listener using the removeGroupListener() method which takes the id of the listener to be removed as the parameter. We suggest you call this method in the onPause() method of the activity/fragment.

Java
Kotlin

CometChat.removeGroupListener(UNIQUE_LISTENER_ID);

CometChat.removeGroupListener(UNIQUE_LISTENER_ID)

Message Listener

The MessageListener class provides you with live events related to messages. Below are the callback methods provided by the MessageListener class.

With offline support enabled, MessageListener also receives onMessagesSynced after the SDK catches up on reconnect. It carries 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(TextMessage message)`	This event is triggered when a Text Message is received.
`onMediaMessageReceived(MediaMessage message)`	This event is triggered when a Media Message is received.
`onCustomMessageReceived(CustomMessage message)`	This event is triggered when a Custom Message is received.
`onTypingStarted(TypingIndicator typingIndicator)`	This event is triggered when a user starts typing in a user/group conversation
`onTypingEnded(TypingIndicator typingIndicator)`	This event is triggered when a user stops typing in a user/group conversation.
`onMessagesDelivered(MessageReceipt messageReceipt)`	This event is triggered when a set of messages are marked as delivered for any particular conversation.
`onMessagesRead(MessageReceipt messageReceipt)`	This event is triggered when a set of messages are marked as read for any particular conversation.
`onMessageEdited(BaseMessage message)`	This method is triggered when a particular message has been edited in a user/group conversation.
`onMessageDeleted(BaseMessage message)`	This event is triggered when a particular message is deleted in a user/group conversation.
`onMessagePinned(BaseMessage message)`	This event is triggered when a message is pinned in a user/group conversation.
`onMessageUnpinned(BaseMessage message)`	This event is triggered when a message is unpinned in a user/group conversation.
`onMessageSaved(BaseMessage message)`	This event is triggered when the logged-in user saves a message (private — never delivered to other participants).
`onMessageUnsaved(BaseMessage message)`	This event is triggered when the logged-in user unsaves a message (private — never delivered to other participants).
`onInteractiveMessageReceived(InteractiveMessage message)`	This event is triggered when an Interactive Message is received.
`onInteractionGoalCompleted(InteractionReceipt receipt)`	This event is triggered when an interaction Goal is achieved.
`onTransientMessageReceived(TransientMessage transientMessage)`	This event is triggered when a Transient Message is received.
`onMessageReactionAdded(ReactionEvent reactionEvent)`	This event is triggered when a reaction is added to a message in a user/group conversation.
`onMessageReactionRemoved(ReactionEvent reactionEvent)`	This event is triggered when a reaction is remove from a message in a user/group conversation.
`onAIAssistantMessageReceived(AIAssistantMessage message)`	This event is triggered when a persisted AI Assistant message is received after a run completes.
`onAIToolResultReceived(AIToolResultMessage message)`	This event is triggered when an AI tool result message is received.
`onAIToolArgumentsReceived(AIToolArgumentMessage message)`	This event is triggered when AI tool argument messages are received.
`onCardMessageReceived(CardMessage message)`	This event is triggered when a Card message is received. .

To add the MessageListener, you need to use the addMessageListener() method provided by the CometChat class.

Java
Kotlin

CometChat.addMessageListener(UNIQUE_LISTENER_ID, new CometChat.MessageListener() {
  @Override
  public void onTextMessageReceived(TextMessage message) {

  }

  @Override
  public void onMediaMessageReceived(MediaMessage message) {

  }

  @Override
  public void onCustomMessageReceived(CustomMessage message) {

  }

  @Override
  public void onTypingStarted(TypingIndicator typingIndicator) {

  }

  @Override
  public void onTypingEnded(TypingIndicator typingIndicator) {

  }

  @Override
  public void onMessagesDelivered(MessageReceipt messageReceipt) {

  }

  @Override
  public void onMessagesRead(MessageReceipt messageReceipt) {

  }

  @Override
  public void onMessageEdited(BaseMessage message) {

  }

  @Override
  public void onMessageDeleted(BaseMessage message) {

  }

  @Override
  public void onInteractiveMessageReceived(InteractiveMessage interactiveMessage) {

  }

  @Override
  public void onInteractionGoalCompleted(InteractionReceipt interactionReceipt) {

  }


  @Override
  public void onTransientMessageReceived(TransientMessage transientMessage) {

  }

  @Override
  public void onMessageReactionAdded(ReactionEvent reactionEvent) {

  }

  @Override
  public void onMessageReactionRemoved(ReactionEvent reactionEvent) {

  }
  
  @Override
   public void onAIAssistantMessageReceived(AIAssistantMessage aiAssistantMessage) {
  
   }
  
   @Override
   public void onAIToolResultReceived(AIToolResultMessage aiToolResultMessage) {
  
   }
  
   @Override
   public void onAIToolArgumentsReceived(AIToolArgumentMessage aiToolArgumentMessage) {
  
   }
   
   @Override
   public void onCardMessageReceived(CardMessage cardMessage) {
   
   }
});

CometChat.addMessageListener(UNIQUE_LISTENER_ID, object : CometChat.MessageListener() {
  override fun onTextMessageReceived(message: TextMessage) {
  }

  override fun onMediaMessageReceived(message: MediaMessage) {
  }

  override fun onCustomMessageReceived(message: CustomMessage) {
  }

  override fun onTypingStarted(typingIndicator: TypingIndicator) {
  }

  override fun onTypingEnded(typingIndicator: TypingIndicator) {
  }

  override fun onMessagesDelivered(messageReceipt: MessageReceipt) {
  }

  override fun onMessagesRead(messageReceipt: MessageReceipt) {
  }

  override fun onMessageEdited(message: BaseMessage) {
  }

  override fun onMessageDeleted(message: BaseMessage) {
  }

  override fun onInteractiveMessageReceived(interactiveMessage: InteractiveMessage) {
  }

  override fun onInteractionGoalCompleted(interactionReceipt: InteractionReceipt) {
  }

  override fun onTransientMessageReceived(transientMessage: TransientMessage) {
  }

  override fun onMessageReactionAdded(reactionEvent: ReactionEvent) {
  }

  override fun onMessageReactionRemoved(reactionEvent: ReactionEvent) {
  }
  
  override fun onAIAssistantMessageReceived(aiAssistantMessage: AIAssistantMessage) {
  }
    
  override fun onAIToolResultReceived(aiToolResultMessage: AIToolResultMessage) {
  }
    
  override fun onAIToolArgumentsReceived(aiToolArgumentMessage: AIToolArgumentMessage) {
  }
  
  override fun onCardMessageReceived(cardMessage: CardMessage) {
  }
  
})

where UNIQUE_LISTENER_ID is the unique identifier for the listener. Please make sure that no two listeners are added with the same listener id as this could lead to unexpected behavior resulting in loss of events. Once the activity/fragment where the MessageListener is declared is not in use, you need to remove the listener using the removeMessageListener() method which takes the id of the listener to be removed as the parameter. We suggest you call this method in the onPause() method of the activity/fragment.

Conversation Listener

The ConversationListener class provides you with live events related to conversations. Below are the callback methods provided by the ConversationListener class.

Method	Information
`onConversationPinned(Conversation conversation)`	This event is triggered when a conversation is pinned for the logged-in user.
`onConversationUnpinned(Conversation conversation)`	This event is triggered when a conversation is unpinned for the logged-in user.

To add the ConversationListener, you need to use the addConversationListener() method provided by the CometChat class.

Java
Kotlin

CometChat.addConversationListener(UNIQUE_LISTENER_ID, new CometChat.ConversationListener() {
  @Override
  public void onConversationPinned(Conversation conversation) {

  }

  @Override
  public void onConversationUnpinned(Conversation conversation) {

  }
});

CometChat.addConversationListener(UNIQUE_LISTENER_ID, object : CometChat.ConversationListener() {
  override fun onConversationPinned(conversation: Conversation) {

  }

  override fun onConversationUnpinned(conversation: Conversation) {

  }
})

Once you have successfully registered the listener and no longer wish to receive any events, you need to remove the listener using the removeConversationListener() method with the same UNIQUE_LISTENER_ID.

There is no thread listener. Thread replies are ordinary messages carrying a parent message ID, so they arrive on the MessageListener callbacks above, and a subscribeToThread() / unsubscribeFromThread() callback is the acknowledgement of a subscription change. See Thread Subscription.

AI Assistant Listener

The AIAssistantListener class provides you with real-time streaming events from AI Agent runs. These events are emitted during a run lifecycle and include tool calls, card generation, and text message streaming. For a complete overview of the event lifecycle, see AI Agents.

Method	Information
`onAIAssistantEventReceived(AIAssistantBaseEvent event)`	This event is triggered for every AI assistant streaming event during a run (run start/finish, tool calls, card generation, text streaming).

To add the AIAssistantListener, use the addAIAssistantListener() method provided by the CometChat class.

Java
Kotlin

CometChat.addAIAssistantListener(UNIQUE_LISTENER_ID, new CometChat.AIAssistantListener() {
  @Override
  public void onAIAssistantEventReceived(AIAssistantBaseEvent event) {
      // Handle different event types
      if (event instanceof AIAssistantRunStartedEvent) {
          Log.d(TAG, "Run started: " + event.getId());
      } else if (event instanceof AIAssistantToolStartedEvent) {
          Log.d(TAG, "Tool call started");
      } else if (event instanceof AIAssistantCardStartedEvent) {
          AIAssistantCardStartedEvent cardEvent = (AIAssistantCardStartedEvent) event;
          Log.d(TAG, "Card generation started: " + cardEvent.getCardId());
      } else if (event instanceof AIAssistantCardReceivedEvent) {
          AIAssistantCardReceivedEvent cardEvent = (AIAssistantCardReceivedEvent) event;
          JSONObject cardPayload = cardEvent.getCard();
          Log.d(TAG, "Card received: " + cardEvent.getCardId());
      } else if (event instanceof AIAssistantCardEndedEvent) {
          AIAssistantCardEndedEvent cardEvent = (AIAssistantCardEndedEvent) event;
          Log.d(TAG, "Card ended: " + cardEvent.getCardId());
      } else if (event instanceof AIAssistantContentReceivedEvent) {
          AIAssistantContentReceivedEvent contentEvent = (AIAssistantContentReceivedEvent) event;
          Log.d(TAG, "Streaming content delta: " + contentEvent.getDelta());
      } else if (event instanceof AIAssistantMessageEndedEvent) {
          Log.d(TAG, "Message streaming ended");
      } else if (event instanceof AIAssistantRunFinishedEvent) {
          Log.d(TAG, "Run finished: " + event.getId());
      }
  }
});

CometChat.addAIAssistantListener(UNIQUE_LISTENER_ID, object : CometChat.AIAssistantListener() {
    override fun onAIAssistantEventReceived(event: AIAssistantBaseEvent) {
      // Handle different event types
      when (event) {
          is AIAssistantRunStartedEvent -> Log.d(TAG, "Run started: ${event.id}")
          is AIAssistantToolStartedEvent -> Log.d(TAG, "Tool call started")
          is AIAssistantCardStartedEvent -> Log.d(TAG, "Card generation started: ${event.cardId}")
          is AIAssistantCardReceivedEvent -> {
              val cardPayload = event.card   // JSONObject
              Log.d(TAG, "Card received: ${event.cardId}")
          }
          is AIAssistantCardEndedEvent -> Log.d(TAG, "Card ended: ${event.cardId}")
          is AIAssistantContentReceivedEvent -> Log.d(TAG, "Streaming content delta: ${event.delta}")
          is AIAssistantMessageEndedEvent -> Log.d(TAG, "Message streaming ended")
          is AIAssistantRunFinishedEvent -> Log.d(TAG, "Run finished: ${event.id}")
      }
    }

})

The AIAssistantListener delivers real-time streaming events. After a run completes, persisted agentic messages (AIAssistantMessage, AIToolResultMessage, AIToolArgumentMessage) are delivered via the MessageListener callbacks listed above.

Call Listener

Superseded. CallListener and addCallListener() are no longer the way calls announce themselves, and a coming Chat SDK release marks them deprecated together with the Chat SDK’s other calling methods. Calls now ring through the Push Notifications SDK and announce themselves on the Calls SDK’s CometChatCalls.addIncomingCallListener (onIncomingCallReceived, onIncomingCallEnded(call, reason)), whether the call arrived by push on a killed process or while the app was running. The caller’s “answered” event is ParticipantEventListener.onParticipantJoined on the prepared session. See Ringing and Migrating from Legacy Ringing. The section below is kept for apps still on the legacy flow.

The CallListener class provides you with live events related to calls. Below are the callback methods provided by the CallListener class.

Method	Information
`onIncomingCallReceived(Call 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 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 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 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, you need to use the addCallListener() method provided by the CometChat class.

Java
Kotlin

CometChat.addCallListener(UNIQUE_LISTENER_ID, new CometChat.CallListener() {
  @Override
  public void onIncomingCallReceived(Call call) {

  }

  @Override
  public void onOutgoingCallAccepted(Call call) {

  }

  @Override
  public void onOutgoingCallRejected(Call call) {

  }

  @Override
  public void onIncomingCallCancelled(Call call) {

  }
});

CometChat.addCallListener(UNIQUE_LISTENER_ID, object : CometChat.CallListener() {
  override fun onIncomingCallReceived(call: Call) {

  }

  override fun onOutgoingCallAccepted(call: Call) {

  }

  override fun onOutgoingCallRejected(call: Call) {

  }

  override fun onIncomingCallCancelled(call: Call) {

  }
})

Where UNIQUE_LISTENER_ID is the unique identifier for the listener. Make sure that no two listeners are added with the same listener ID as this could lead to unexpected behavior resulting in loss of events. Once the activity/fragment where the MessageListener is declared is not in use, you need to remove the listener using the removeMessageListener() method which takes the id of the listener to be removed as the parameter. We suggest you call this method in the onPause() method of the activity/fragment.

Offline listeners

With offline support enabled (SDK 5.1.0+), 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

​User Listener

​Group Listener

​Message Listener

​Conversation Listener

​AI Assistant Listener

​Call Listener

​Offline listeners

User Listener

Group Listener

Message Listener

Conversation Listener

AI Assistant Listener

Call Listener

Offline listeners