Reactions

Enhance user engagement in your chat application with message reactions.

Enhance user engagement in your chat application with message reactions. Users can express their emotions using reactions to messages. This feature allows users to add or remove reactions, and to fetch all reactions on a message. You can also listen to reaction events in real-time. Let’s see how to work with reactions in CometChat’s Android SDK.

​

Add a Reaction

Users can add a reaction to a message by calling addReaction with the message ID and the reaction emoji.

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.

​

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 ReactionsRequest using ReactionsRequestBuilder. You can specify the number of reactions to fetch with setLimit (default 10, maximum 1000). 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 ReactionsRequest 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.

Starting with v5.1.0, the CallbackListener overload of `fetchNext()` / `fetchPrevious()` is deprecated. Use `ReactionFetchListener` instead; it requires SDK 5.1.0 or later, so on 5.0.x keep using CallbackListener. With offline support off, it behaves exactly like the old callback: onError is unchanged, and the server result arrives in the onServer… callback instead of onSuccess. With offline support on, it also delivers the cached result first; the old overload keeps working but receives only the server result. See Show Cached Data.

Java

int limit = 30;
int messageId = 1;

ReactionsRequest reactionsRequest = new ReactionsRequest.ReactionsRequestBuilder()
      .setLimit(limit)
      .setMessageId(messageId)
      .build();

reactionsRequest.fetchNext(new CometChat.ReactionFetchListener() {
  @Override
  public void onCachedReactions(List<Reaction> reactions) {
      // Cached page: fires first (even when empty). Render immediately.
      Log.e(TAG, "Cached reactions: " + reactions.size());
  }

  @Override
  public void onServerReactions(List<Reaction> reactions) {
      // Server page: reconcile your displayed list, keyed by reaction id.
      Log.e(TAG, "Server reactions: " + reactions.size());
  }

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

Kotlin

val limit = 30
val messageId = 1

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

reactionsRequest.fetchNext(object : CometChat.ReactionFetchListener() {
  override fun onCachedReactions(reactions: List<Reaction>) {
      // Cached page: fires first (even when empty). Render immediately.
      Log.e(TAG, "Cached reactions: ${reactions.size}")
  }

  override fun onServerReactions(reactions: List<Reaction>) {
      // Server page: reconcile your displayed list, keyed by reaction id.
      Log.e(TAG, "Server reactions: ${reactions.size}")
  }

  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 reactionsRequest = new ReactionsRequest.ReactionsRequestBuilder()
      .setLimit(limit)
      .setMessageId(messageId)
      .build();

reactionsRequest.fetchPrevious(new CometChat.ReactionFetchListener() {
  @Override
  public void onCachedReactions(List<Reaction> reactions) {
      // Cached page: fires first (even when empty). Render immediately.
      Log.e(TAG, "Cached reactions: " + reactions.size());
  }

  @Override
  public void onServerReactions(List<Reaction> reactions) {
      // Server page: reconcile your displayed list, keyed by reaction id.
      Log.e(TAG, "Server reactions: " + reactions.size());
  }

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

Kotlin

val limit = 30
val messageId = 1

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

reactionsRequest.fetchPrevious(object : CometChat.ReactionFetchListener() {
  override fun onCachedReactions(reactions: List<Reaction>) {
      // Cached page: fires first (even when empty). Render immediately.
      Log.e(TAG, "Cached reactions: ${reactions.size}")
  }

  override fun onServerReactions(reactions: List<Reaction>) {
      // Server page: reconcile your displayed list, keyed by reaction id.
      Log.e(TAG, "Server reactions: ${reactions.size}")
  }

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

​

Offline Behaviour

With offline support enabled, ReactionsRequest.fetchNext() and fetchPrevious() on a ReactionFetchListener first deliver onCachedReactions from the device (empty when nothing was recorded), then onServerReactions with the live page to reconcile by reaction id. A request object caches only the first direction it fetches, so use a separate ReactionsRequest for each direction. Offline, a read ends with onError with code ERROR_INTERNET_UNAVAILABLE after the cached page. See Show Cached Data.

Builder method	Offline
setLimit	Cached
setMessageId	Cached
setReaction	Cached

The cached phase replays the page this request last received from the server online, in the same direction; it does not re-run these settings as a query against the cache.

​

Real-time Reaction Events

Keep the chat interactive with real-time updates for reactions. Reaction events arrive on the MessageListener: override onMessageReactionAdded() and onMessageReactionRemoved(). Each receives a ReactionEvent, whose getReaction() returns the Reaction and whose getReceiverId(), getReceiverType(), getConversationId() and getParentMessageId() identify where it happened.

Java

private String listenerID = "UNIQUE_LISTENER_ID";

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

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

Kotlin

val listenerID = "UNIQUE_LISTENER_ID"

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

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

​

Removing a Reaction Listener

To stop listening for reaction events, remove the listener with the same listener ID:

Java

CometChat.removeMessageListener(listenerID);

Kotlin

CometChat.removeMessageListener(listenerID)

​

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 it, you would want to update the message with the latest reaction information. To do so, use CometChatHelper.updateMessageWithReactionInfo().

Pass the BaseMessage the reaction belongs to, the Reaction from the event (reactionEvent.getReaction()), and the action: CometChatConstants.REACTION_ADDED from onMessageReactionAdded() or CometChatConstants.REACTION_REMOVED from onMessageReactionRemoved(). It returns the message with its getReactions() updated.

Java

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

// The reaction from the real-time ReactionEvent
Reaction reaction = reactionEvent.getReaction();

// CometChatConstants.REACTION_ADDED or CometChatConstants.REACTION_REMOVED
String action = CometChatConstants.REACTION_ADDED;

BaseMessage modifiedBaseMessage = CometChatHelper.updateMessageWithReactionInfo(
  message,
  reaction,
  action
);

Kotlin

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

// The reaction from the real-time ReactionEvent
val reaction: Reaction = reactionEvent.reaction

// CometChatConstants.REACTION_ADDED or CometChatConstants.REACTION_REMOVED
val action = CometChatConstants.REACTION_ADDED

val modifiedBaseMessage: BaseMessage = CometChatHelper.updateMessageWithReactionInfo(
  message,
  reaction,
  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.