Threaded Messages

Messages that are started from a particular message are called Threaded messages or simply threads.

Messages that are started from a particular message are called Threaded messages or simply threads. Each Thread is attached to a message which is the Parent message for that thread.

​

Send Message in a Thread

As mentioned in the Send a Message section, you can send a message to a User or a Group by mentioning the receiver (uid/guid) and receiverType(user/group).

A message can be categorized as:

1. Text Message
2. Media Message
3. Custom Message.

Any of the above messages can be sent in a thread. As a thread is identified with a parent message, the parentMessageId must be set for the message. This will indicate that the message to be sent has to be a part of the thread of the message with the specified parentMessageId.

This can be achieved using the setParentMessageId() method provided by the object of the TextMessage, MediaMessage and CustomMessage class. The id specified in the setParentMessageId() method maps the message sent to the particular thread.

Example to Send a Text Message in a thread in a user conversation.

Starting with v5.1.0, the CallbackListener overloads of `sendMessage()` are deprecated. Use MessageSentListener instead; it requires SDK 5.1.0 or later. On 5.0.x, keep using CallbackListener and handle the sent message in onSuccess where these examples use onMessageSent. With offline support off, it behaves exactly like the old callback: onError is unchanged, and the sent message arrives in onMessageSent instead of onSuccess. With offline support on, onMessagePending fires first. A message sent without a connection stays PENDING and is sent when the connection returns: onError fires with code ERROR_INTERNET_UNAVAILABLE as a not-connected notice, and onMessageSent follows once the message is sent. In onError, check the message’s getStatus(): PENDING means queued, FAILED means it failed. The old CallbackListener overloads are never queued; offline, they end with onError. See Send While Offline.

Java

TextMessage textMessage = new TextMessage(UID, "Hello", CometChatConstants.RECEIVER_TYPE_USER);
textMessage.setParentMessageId(100);

CometChat.sendMessage(textMessage, new CometChat.MessageSentListener() {
  @Override
    public void onMessagePending(BaseMessage message) {
    Log.d(TAG, "Text Message queued");
  }

  @Override
    public void onMessageSent(BaseMessage message) {
    Log.d(TAG, "Text Message Sent successfully");
  }

  @Override
    public void onError(CometChatException e) {
    Log.d(TAG, "Text Message Failed : " + e.getMessage());
  }
}); 

Kotlin

val textMessage = TextMessage(UID, "Hello", CometChatConstants.RECEIVER_TYPE_USER)
textMessage.parentMessageId = 100

CometChat.sendMessage(textMessage, object : CometChat.MessageSentListener() {
  override fun onMessagePending(message: BaseMessage?) {
    Log.d(TAG, "Text Message queued")
  }

  override fun onMessageSent(message: BaseMessage?) {
    Log.d(TAG, "Text Message Sent successfully")
  }

  override fun onError(e: CometChatException) {
    Log.d(TAG, "Text Message Failed : " + e.message)
  }
})

The above snippet shows how a message with the text “Hello” can be sent in the thread with parentMessageId 100.

Similarly, using the setparentMessageId() method, Media and Custom Messages can be sent in threads too.

​

Receiving Real-Time Messages

The procedure to receive real-time messages is exactly the same as mentioned in the Receive Messages. This can be achieved using the MessageListener class provided by the SDK. To add a MessageListener, you can use the addMessageListener() method of the SDK. The only thing that needs to be checked is if the received message belongs to the active thread. This can be done using parentMessageId field of the message object.

Java

private String listenerID = "UNIQUE_LISTENER_ID";
private int activeThreadId = 100;

CometChat.addMessageListener(listenerID, new CometChat.MessageListener() {
  @Override
  public void onTextMessageReceived(TextMessage textMessage) {
    if(message.getParentMessageId() == activeThreadId) {
      Log.d(TAG,"Text Message Received for active thread");
    }
  }

  @Override
  public void onMediaMessageReceived(MediaMessage mediaMessage) {
    if(message.getParentMessageId() == activeThreadId) {
      Log.d(TAG,"Media Message Received for active thread");
    }
  }

  @Override
    public void onCustomMessageReceived(CustomMessage customMessage) {
    if(message.getParentMessageId() == activeThreadId) {
        Log.d(TAG,"Custome Message Received for active thread");
    }
  }
});

Kotlin

val listenerID = "UNIQUE_LISTENER_ID"
val activeThreadId = 100

CometChat.addMessageListener(listenerID, object : MessageListener() {
    override fun onTextMessageReceived(textMessage: TextMessage) {
        if (message!!.parentMessageId === activeThreadId) {
            Log.d(TAG, "Text Message Received for active thread")
        }
    }

    override fun onMediaMessageReceived(mediaMessage: MediaMessage) {
        if (message!!.parentMessageId === activeThreadId) {
            Log.d(TAG, "Media Message Received for active thread")
        }
    }

    override fun onCustomMessageReceived(customMessage: CustomMessage) {
        if (message!!.parentMessageId === activeThreadId) {
            Log.d(TAG, "Custome Message Received for active thread")
        }
    }
})

​

Fetch all the messages for any particular thread.

You can fetch all the messages belonging to a particular thread by using the MessagesRequest class.

The MessageRequestBuilder builds the MessageRequest object using the following functions:

1. setParentMessageId(): Takes the parentId of the message as argument whose thread needs to be requested.
2. build(): returns the MessageRequest object.

Once you have the MessagesRequest object, you can call the fetchPrevious() method to get the latest messages in the thread. In one iteration, a maximum of 100 messages can be fetched. If you wish to fetch the next set of messages, you need to call the fetchPrevious() method again on the same object.

Starting with v5.1.0, the CallbackListener overload of `fetchPrevious()` / `fetchNext()` is deprecated. Use `MessageFetchListener` 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

MessagesRequest messagesRequest = neMessagesRequest.MessagesRequestBuilder()
  .setLimit(30)
  .setParentMessageId(100)
  .build();
      
messagesRequest.fetchPrevious(new CometChat.MessageFetchListener() {
  @Override
    public void onCachedMessages(List<BaseMessage> messages) {
    // Render the cached page immediately.
  }

  @Override
    public void onServerMessages(List<BaseMessage> messages) {
    Log.d(TAG, "Messages for thread fetched successfully");        
  }

  @Override
    public void onError(CometChatException e) {
    Log.d(TAG, "Message Fetching failed : "+ e.getMessage());
  }
});

Kotlin

val messagesRequest: MessagesRequest = neMessagesRequest.MessagesRequestBuilder()
  .setLimit(30)
  .setParentMessageId(100)
  .build()

messagesRequest.fetchPrevious(object : CometChat.MessageFetchListener() {
  override fun onCachedMessages(messages: List<BaseMessage>) {
    // Render the cached page immediately.
  }

  override fun onServerMessages(messages: List<BaseMessage>) {
    Log.d(TAG, "Messages for thread fetched successfully")
  }

  override fun onError(e: CometChatException) {
    Log.d(TAG, "Message Fetching failed : " + e.message)
  }
})

​

Avoid Threaded Messages in User/Group Conversations

While fetching messages for normal user/group conversations using the MessagesRequest, the threaded messages by default will be a part of the list of messages received. In order to exclude the threaded messages from the list of user/group messages, you need to use the hideReplies() method of the MessagesRequestBuilder class. This method takes a boolean argument which when set to true excludes the messages belonging to threads from the list of messages.

Java

MessagesRequest messagesRequest = neMessagesRequest.MessagesRequestBuilder()
  .setLimit(30)
  .setUID("cometchat-uid-1")
  .hideReplies(true)
  .build();
      
messagesRequest.fetchPrevious(new CometChat.MessageFetchListener() {
  @Override
    public void onCachedMessages(List<BaseMessage> messages) {
    // Render the cached page immediately.
  }

  @Override
    public void onServerMessages(List<BaseMessage> messages) {
    Log.d(TAG, "Messages for thread fetched successfully");        
  }

  @Override
    public void onError(CometChatException e) {
    Log.d(TAG, "Message Fetching failed : "+ e.getMessage());
  }
});

Kotlin

val messagesRequest: MessagesRequest = neMessagesRequest.MessagesRequestBuilder()
  .setLimit(30)
  .setUID("cometchat-uid-1")
  .hideReplies(true)
  .build()

messagesRequest.fetchPrevious(object : CometChat.MessageFetchListener() {
  override fun onCachedMessages(messages: List<BaseMessage>) {
    // Render the cached page immediately.
  }

  override fun onServerMessages(messages: List<BaseMessage>) {
    Log.d(TAG, "Messages for thread fetched successfully")
  }

  override fun onError(e: CometChatException) {
    Log.d(TAG, "Message Fetching failed : " + e.message)
  }
}) 

The above snippet will return messages between the logged in user and cometchat-uid-1 excluding all the threaded messages belonging to the same conversation.

​

Offline Behaviour

With offline support enabled, thread fetches run in two phases: onCachedMessages delivers the cached thread page first (even when empty), then onServerMessages delivers the reconciled server copy. Offline, the fetch ends with onError with code ERROR_INTERNET_UNAVAILABLE after the cached page. A thread read is answered from the cache even when both setUID and setGUID are set; unlike a non-thread read, that pairing is not server-only here. See Show Cached Data.

Builder method	Offline behaviour
setParentMessageId(long)	Cached
hideReplies(boolean)	Cached

​

Subscribe to a Thread

Users can subscribe to or unsubscribe from a thread to control whether they are notified about its replies, and you can fetch the list of threads a user participates in to build a thread inbox. See Thread Subscription.