Reactions

Add, remove, and fetch message reactions in real-time using the CometChat Android SDK. Includes listener events and helper methods for updating UI.

Reactions let users respond to messages with emoji. You can add or remove reactions, fetch all reactions on a message, listen for reaction events in real time, and update your UI when reactions change.

Add a Reaction

Users can add a reaction to a message by calling addReaction with the message ID and the reaction emoji. On success, returns a BaseMessage object with updated reactions.

Java

int messageId = 1;
String emoji = "😊";

CometChat.addReaction(messageId, emoji, new CometChat.CallbackListener<BaseMessage>() {
  @Override
  public void onSuccess(BaseMessage message) {
      Log.e(TAG, "Reaction added: " + message.getReactions());
  }

  @Override
  public void onError(CometChatException e) {
      Log.e(TAG, "Failed to add reaction: " + e.getMessage());
  }
});

Kotlin

val messageId = 1
val emoji = "😊"

CometChat.addReaction(messageId, emoji, object : CometChat.CallbackListener<BaseMessage>() {
  override fun onSuccess(message: BaseMessage?) {
      Log.e(TAG, "Reaction added: ${message.reactions}")
  }

  override fun onError(e: CometChatException?) {
      Log.e(TAG, "Failed to add reaction: ${e?.message}")
  }
})

You can react on Text, Media and Custom messages. For more details on message types, see Message Structure & Hierarchy.

Remove a Reaction

Removing a reaction from a message can be done using the removeReaction method.

Java

int messageId = 1;
String emoji = "😊";

CometChat.removeReaction(messageId, emoji, new CometChat.CallbackListener<BaseMessage>() {
  @Override
  public void onSuccess(BaseMessage message) {
      Log.e(TAG, "Reaction removed: " + message.getReactions());
  }

  @Override
  public void onError(CometChatException e) {
      Log.e(TAG, "Failed to remove reaction: " + e.getMessage());
  }
});

Kotlin

val messageId = 1
val emoji = "😊"

CometChat.removeReaction(messageId, emoji, object : CometChat.CallbackListener<BaseMessage>() {
  override fun onSuccess(message: BaseMessage?) {
      Log.e(TAG, "Reaction removed: ${message.reactions}")
  }

  override fun onError(e: CometChatException?) {
      Log.e(TAG, "Failed to remove reaction: ${e?.message}")
  }
})

Fetch Reactions for a Message

To get all reactions for a specific message, first create a ReactionRequest using ReactionRequestBuilder. You can specify the number of reactions to fetch with setLimit with max limit 20. For this, you will require the ID of the message. This ID needs to be passed to the setMessageId() method of the builder class. The setReaction() will allow you to fetch details for specific reaction or emoji.

Setting	Description
setMessageId(int value)	Specifies the unique identifier of the message for which you want to fetch reactions. This parameter is mandatory as it tells the SDK which message’s reactions are being requested.
setReaction(String value)	Filters the reactions fetched by the specified reaction type (e.g., ”😊”, ”😂”, ”👍”). When set, this method will cause the ReactionRequest to only retrieve details of the provided reaction for the given message.

Fetch Next

The fetchNext() method fetches the next set of reactions for the message.

Java

int limit = 30;
int messageId = 1;

ReactionsRequest reactionRequest = new ReactionsRequest.ReactionsRequestBuilder()
      .setLimit(30)
      .setMessageId(1)
      .build();

reactionRequest.fetchNext(new CometChat.CallbackListener<List<Reaction>>() {
  @Override
  public void onSuccess(List<Reaction> reactions) {
      Log.e(TAG, "Total Reactions: " + reactions.size());
      for (Reaction reaction : reactions) {
          Log.e(TAG, "Reaction: " + reaction.getReaction());
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.e(TAG, "Reaction fetch error: " + e.getMessage());
  }
});

Kotlin

val limit = 30
val messageId = 1

val reactionRequest = ReactionsRequest.ReactionsRequestBuilder()
      .setLimit(limit)
      .setMessageId(messageId)
      .build()

reactionRequest.fetchNext(object : CometChat.CallbackListener<List<Reaction>>() {
  override fun onSuccess(reactions: List<Reaction>?) {
      Log.e(TAG, "Total Reactions: ${reactions?.size}")
      reactions?.forEach { reaction ->
          Log.e(TAG, "Reaction: ${reaction.reaction}")
      }
  }

  override fun onError(e: CometChatException?) {
      Log.e(TAG, "Reaction fetch error: ${e?.message}")
  }
})

Fetch Previous

The fetchPrevious() method fetches the previous set of reactions for the message.

Java

int limit = 30;
int messageId = 1;

ReactionsRequest reactionRequest = new ReactionsRequest.ReactionsRequestBuilder()
      .setLimit(30)
      .setMessageId(1)
      .build();

reactionRequest.fetchPrevious(new CometChat.CallbackListener<List<Reaction>>() {
  @Override
  public void onSuccess(List<Reaction> reactions) {
      Log.e(TAG, "Total Reactions: " + reactions.size());
      for (Reaction reaction : reactions) {
          Log.e(TAG, "Reaction: " + reaction.getReaction());
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.e(TAG, "Reaction fetch error: " + e.getMessage());
  }
}); 

Kotlin

val limit = 30
val messageId = 1

val reactionRequest = ReactionsRequest.ReactionsRequestBuilder()
      .setLimit(limit)
      .setMessageId(messageId)
      .build()

reactionRequest.fetchPrevious(object : CometChat.CallbackListener<List<Reaction>>() {
  override fun onSuccess(reactions: List<Reaction>?) {
      Log.e(TAG, "Total Reactions: ${reactions?.size}")
      reactions?.forEach { reaction ->
          Log.e(TAG, "Reaction: ${reaction.reaction}")
      }
  }

  override fun onError(e: CometChatException?) {
      Log.e(TAG, "Reaction fetch error: ${e?.message}")
  }
})

Real-time Reaction Events

Keep the chat interactive with real-time updates for reactions. Register a listener for these events and make your UI responsive. For more information on listeners, see Real-Time Listeners.

Java

private String listenerID = "UNIQUE_LISTENER_ID";

CometChat.addMessageListener(listenerID, new CometChat.MessageListener() {
  @Override
  public void onMessageReactionAdded(ReactionEvent reactionEvent) {
      Log.e(TAG, "Reaction added");
  }

  @Override
  public void onMessageReactionRemoved(ReactionEvent reactionEvent) {
      Log.e(TAG, "Reaction removed");
  }
});

Kotlin

val listenerID = "UNIQUE_LISTENER_ID"

CometChat.addMessageListener(listenerID, object : CometChat.MessageListener() {
  override fun onMessageReactionAdded(reactionEvent: ReactionEvent?) {
      Log.e(TAG, "Reaction added")
  }

  override fun onMessageReactionRemoved(reactionEvent: ReactionEvent?) {
      Log.e(TAG, "Reaction removed")
  }
})

Removing a Reaction Listener

To stop listening for reaction events, remove the listener as follows:

Java

private String listenerID = "UNIQUE_LISTENER_ID";

CometChat.removeMessageListener(listenerID);

Kotlin

val listenerID = "UNIQUE_LISTENER_ID"

CometChat.removeMessageListener(listenerID)   

Always remove listeners when they’re no longer needed (e.g., in onDestroy() or when navigating away). Failing to remove listeners can cause memory leaks and duplicate event handling.

Get Reactions List

To retrieve the list of reactions reacted on particular message, you can use the message.getReactions() method. This method will return an array containing the reactions, or an empty array if no one reacted on the message.

Java

message.getReactions()

Kotlin

message.reactions 

Check if Logged-in User has Reacted on Message

To check if the logged-in user has reacted on a particular message or not, You can use the getReactedByMe() method on any ReactionCount object instance. This method will return a boolean value, true if the logged-in user has reacted on that message, otherwise false.

Java

for (ReactionCount reactionCount : message.getReactions()) {
  Log.e(TAG, "isReactedByMe" + reactionCount.getReactedByMe()); //Return true is logged-in user reacted on that message, otherwise false
}

Kotlin

for (reactionCount in message.reactions) {
  Log.e(TAG, "isReactedByMe" + reactionCount.reactedByMe) //Return true is logged-in user reacted on that message, otherwise false
}

Update Message With Reaction Info

When a user adds or removes a reaction, you will receive a real-time event. Once you receive the real time event you would want to update the message with the latest reaction information. To do so you can use the updateMessageWithReactionInfo() method.

The updateMessageWithReactionInfo() method provides a seamless way to update the reactions on a message instance (BaseMessage) in real-time. This method ensures that when a reaction is added or removed from a message, the BaseMessage object’s getReactions() property reflects this change immediately.

When you receive a real-time reaction event (ReactionEvent), call the updateMessageWithReactionInfo() method, passing the BaseMessage instance (message), the inner Reaction from the event (for example reactionEvent.getReaction()), and the reaction event action type (CometChatConstants.REACTION_ADDED or CometChatConstants.REACTION_REMOVED) that corresponds to the message being reacted to.

Java

// The message to which the reaction is related
BaseMessage message = ...;

// The reaction event data received in real-time
Reaction messageReaction = ...;

// The received reaction event real-time action type. Can be CometChatConstants.REACTION_ADDED or CometChatConstants.REACTION_REMOVED
String action = CometChatConstants.REACTION_ADDED;

BaseMessage modifiedBaseMessage = CometChatHelper.updateMessageWithReactionInfo(
baseMessage, 
messageReaction, 
action
);

Kotlin

// The message to which the reaction is related
val message: BaseMessage = ...

// The reaction event data received in real-time
val messageReaction: Reaction = ...

// The received reaction event real-time action type. Can be CometChatConstants.REACTION_ADDED or CometChatConstants.REACTION_REMOVED
val action = CometChatConstants.REACTION_ADDED

// Update the BaseMessage instance with the new reaction information
val modifiedBaseMessage: BaseMessage = CometChatHelper.updateMessageWithReactionInfo(
  message, 
  messageReaction, 
  action
)

After calling this method, the message instance’s reactions are updated. You can then use message.getReactions() to get the latest reactions and refresh your UI accordingly.

Reaction Payload Structure

Reaction Object

When fetching reactions for a message, each Reaction object contains the following fields:

Parameter	Type	Description
id	String	Unique reaction identifier
messageId	long	ID of the message that was reacted to
reaction	String	The reaction emoji
uid	String	UID of the user who reacted
reactedAt	long	Unix timestamp when reaction was added
reactedBy	User	User who added the reaction

Sample Reaction Object:

{
  "id": "reaction_123",
  "messageId": 12345,
  "reaction": "👍",
  "uid": "user_123",
  "reactedAt": 1699900000,
  "reactedBy": {
    "uid": "user_123",
    "name": "John Doe",
    "avatar": "https://example.com/avatar.png",
    "status": "online",
    "role": "default",
    "tags": ["premium", "verified"]
  }
}

User Object (Reactions)

The nested User object in reactedBy contains:

Parameter	Type	Description
uid	String	Unique identifier of the user
name	String	Display name of the user
avatar	String	URL to user’s profile picture
link	String	URL to user’s profile page
role	String	User role for access control
metadata	JSONObject	Custom data set by developer
status	String	User online status. Values: "online", "offline"
statusMessage	String	Custom status message
lastActiveAt	long	Unix timestamp of last activity
hasBlockedMe	boolean	Whether this user has blocked the logged-in user
blockedByMe	boolean	Whether the logged-in user has blocked this user
tags	Array<String>	List of tags for user identification
deactivatedAt	long	Unix timestamp when user was deactivated (0 if active)

ReactionCount Object

When accessing reactions on a message via message.getReactions(), each ReactionCount object contains:

Parameter	Type	Description
reaction	String	The reaction emoji
count	int	Total count of this reaction
reactedByMe	boolean	Whether the logged-in user has reacted with this emoji

Sample ReactionCount Object:

{
  "reaction": "👍",
  "count": 5,
  "reactedByMe": true
}

---

Next Steps

Send Messages

Learn how to send text, media, and custom messages

Receive Messages

Handle real-time message events with listeners

Threaded Messages

Organize conversations with message threads

Mentions

Tag users in messages with @mentions