Receive Messages - CometChat Docs

Receiving messages with CometChat has two parts:

Adding a listener to receive Real-time Messages when your app is running
Calling a method to retrieve Missed Messages when your app was not running

Real-time Messages

In other words, as a recipient, how do I receive messages when my app is running? For every activity or fragment you wish to receive messages in, you need to register the MessageListener using the addMessageListener() method. We suggest adding the listener in the onResume() method of the activity or the fragment where you wish to receive these events in.

Java
Kotlin

private String listenerID = "UNIQUE_LISTENER_ID";

CometChat.addMessageListener(listenerID, new CometChat.MessageListener() {
    @Override
    public void onTextMessageReceived(TextMessage textMessage) {
        Log.d(TAG, "Text message received successfully: " + textMessage.toString());
    }

    @Override
    public void onMediaMessageReceived(MediaMessage mediaMessage) {
        Log.d(TAG, "Media message received successfully: " + mediaMessage.toString());
    }

    @Override
    public void onCustomMessageReceived(CustomMessage customMessage) {
        Log.d(TAG, "Custom message received successfully: " + customMessage.toString());
    }
});

val listenerID:String = "UNIQUE_LISTENER_ID"

CometChat.addMessageListener(listenerID, object : MessageListener() {
    override fun onTextMessageReceived(textMessage: TextMessage) {
        Log.d(TAG, "Text message received successfully: $textMessage")
    }

    override fun onMediaMessageReceived(mediaMessage: MediaMessage) {
        Log.d(TAG, "Media message received successfully: $mediaMessage")
    }

    override fun onCustomMessageReceived(customMessage: CustomMessage) {
        Log.d(TAG, "Custom message received successfully: $customMessage")
    }
})

Parameter	Description
`listenerID`	An ID that uniquely identifies that listener. We recommend using the activity or fragment name

We recommend you remove the listener once the activity or fragment is not in use. Typically, this can be added in the onPause() method.

Java
Kotlin

private String listenerID = "UNIQUE_LISTENER_ID";

CometChat.removeMessageListener(listenerID);

val listenerID:String = "UNIQUE_LISTENER_ID"

CometChat.removeMessageListener(listenerID)

As a sender, you will not receive your own message in a real-time message event. However, if a user is logged-in using multiple devices, they will receive an event for their own message in other devices.

Missed Messages

In other words, as a recipient, how do I receive messages that I missed when my app was not running? For most use cases, you will need to add functionality to load missed messages. If you’re building an on-demand or live streaming app, you may choose to skip this and fetch the message history (say, last 100 messages) instead. Using the same MessagesRequest class and the filters provided by the MessagesRequestBuilder class, you can fetch the message that we sent to the logged-in user but were not delivered to them as they were offline. For this, you will require the ID of the last message received. You can either maintain it at your end or use the getLastDeliveredMessageId() method provided by the CometChat class. This ID needs to be passed to the setMessageId() method of the builder class. Now using the fetchNext() method, you can fetch all the messages that were sent to the user when they were offline. Calling the fetchNext() method on the same object repeatedly allows you to fetch all the offline messages for the logged in user in a paginated manner

Fetch Missed Messages of a particular one-on-one conversation

Java
Kotlin

private int limit = 30;
private int latestId = CometChat.getLastDeliveredMessageId();
private String UID = "cometchat-uid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setMessageId(latestId)
        .setLimit(limit)
        .setUID(UID)
        .build();

messagesRequest.fetchNext(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " +
                        ((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " +
                        ((MediaMessage) message).toString());
            }
        }
    }

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

lateinit var messagesRequest: MessagesRequest
val latestId = CometChat.getLastDeliveredMessageId()
val limit: Int = 30
val UID: String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder()
    .setMessageId(latestId)
    .setLimit(limit)
    .setUID(UID)
    .build()

messagesRequest.fetchNext(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(
                    TAG, "Text message received successfully: " +
                            message.toString()
                )
            } else if (message is MediaMessage) {
                Log.d(
                    TAG, "Media message received successfully: " +
                            message.toString()
                )
            }
        }
    }

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

Fetch Missed Messages of a particular group conversation

Java
Kotlin

private int limit = 30;
private int latestId = CometChat.getLastDeliveredMessageId();
private String GUID = "cometchat-guid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setMessageId(latestId)
        .setLimit(limit)
        .setGUID(GUID)
        .build();

messagesRequest.fetchNext(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
            }
        }
    }

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

lateinit var messagesRequest: MessagesReques
val latestId = CometChat.getLastDeliveredMessageId()
val limit: Int = 30
val GUID: String = "cometchat-uid-1"

messagesRequest = MessagesRequestBuilder()
    .setMessageId(latestId)
    .setLimit(limit)
    .setGUID(GUID)
    .build()

messagesRequest.fetchNext(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(
                    TAG, "Text message received successfully: " +
                            message.toString()
                )
            } else if (message is MediaMessage) {
                Log.d(
                    TAG, "Media message received successfully: " +
                            message.toString()
                )
            }
        }
    }

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

Unread Messages

In other words, as a logged-in user, how do I fetch the messages I’ve not read? Using the MessagesRequest class described above, you can fetch the unread messages for the logged-in user. In order to achieve this, you need to set the unread variable in the builder to true using the setUnread() method so that only the unread messages are fetched.

Fetch Unread Messages of a particular one-on-one conversation

Java
Kotlin

String UID = "cometchat-uid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setUnread(true)
        .setLimit(20)
        .setUID(UID)
        .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " +((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " +((MediaMessage) message).toString());
            }
        }
    }

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

val UID:String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder()
    .setUnread(true)
    .setLimit(20)
    .setUID(UID)
    .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(TAG, "Text message received successfully: $message")
            } else if (message is MediaMessage) {
                Log.d(TAG, "Media message received successfully: $message")
            }
        }
    }

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

Fetch Unread Messages of a particular group conversation

Java
Kotlin

String GUID = "cometchat-guid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setUnread(true)
        .setLimit(20)
        .setGUID(GUID)
        .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
            }
        }
    }

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

val GUID:String = "cometchat-guid-1"

val messagesRequest = MessagesRequestBuilder()
    .setUnread(true)
    .setLimit(20)
    .setGUID(GUID)
    .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(TAG, "Text message received successfully: $message")
            } else if (message is MediaMessage) {
                Log.d(TAG, "Media message received successfully: $message")
            }
        }
    }

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

Base MessageThe list of messages received is in the form of objects of BaseMessage class. A BaseMessage can either be an object of the TextMessage, MediaMessage, CustomMessage, Action or Call class. You can use the instanceOf operator to check the type of object.

Message History

In other words, as a logged-in user, how do I fetch the message history for a user or a group conversation?

Fetch Message History of a particular one-on-one conversation

Using the MessagesRequest class and the filters for the MessagesRequestBuilder class as shown in the below code snippet, you can fetch the entire conversation between the logged in user and any particular user. For this use case, it is mandatory to set the UID parameter using the setUID() method of the builder. This UID is the unique id of the user for which the conversation needs to be fetched.

Java
Kotlin

private int limit = 50;
private String UID = "cometchat-uid-1"

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setLimit(limit)
        .setUID(UID)
        .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
            }
        }
    }

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

val limit: Int = 30
val UID: String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder()
    .setLimit(limit)
    .setUID(UID)
    .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(TAG, "Text message received successfully: $message")
            } else if (message is MediaMessage) {
                Log.d(TAG, "Media message received successfully: $message")
            }
        }
    }

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

Calling the fetchPrevious() method on the same object repeatedly allows you to fetch all the previous messages in a paginated way.

Fetch Message History of a particular group conversation

Using the MessagesRequest class and the filters for the MessagesRequestBuilder class as shown in the below code snippet, you can fetch the entire conversation for any group provided you have joined the group. For this use case, it is mandatory to set the GUID parameter using the setGUID() method of the builder. This GUID is the unique identifier of the Group for which the messages are to be fetched.

Java
Kotlin

private int limit = 30;
private String GUID = "cometchat-guid-1"

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setLimit(limit)
        .setGUID(GUID)
        .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
            }
        }
    }

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

val limit: Int = 30
val GUID: String = "cometchat-guid-1"

val messagesRequest = MessagesRequestBuilder()
    .setLimit(limit)
    .setGUID(GUID)
    .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(TAG, "Text message received successfully: $message")
            } else if (message is MediaMessage) {
                Log.d(TAG, "Media message received successfully: $message")
            }
        }
    }

    override fun onError(e: CometChatException) {
        Log.d(TAG, "Message fetching failed with exception: ${e.message}")
    }
})

Calling the fetchPrevious() method on the same object repeatedly allows you to fetch the entire conversation between the logged in user and the specified user. This can be implemented with upward scrolling to display the entire conversation.

Search Messages

Along with the other parameters mentioned above, you can use the setSearchKeyword() method provided by the MessagesRequestBuilder class. This method takes a string as input. This is the string that is to be searched amongst the messages. This can be used to fetch all the messages that contain the string in a paginated way. Calling the fetchPrevious() method on the same object repeatedly allows you to fetch all the messages with the keyword specified in all your conversations.

Search Messages in a particular one-on-one conversation

Java
Kotlin

private int limit = 30;
private String UID = "cometchat-uid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder().setSearchKeyword("Hello").setUID(UID).setLimit(limit).build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
            }
        }
    }

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

val limit: Int = 30
val UID: String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder().setSearchKeyword("Hello").setUID(UID).setLimit(limit).build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(TAG, "Text message received successfully: $message")
            } else if (message is MediaMessage) {
                Log.d(TAG, "Media message received successfully: $message")
            }
        }
    }

    override fun onError(e: CometChatException) {
        Log.d(TAG, "Message fetching failed with exception: ${e.message}")
    }
})

Search Messages in a particular group conversation

Java
Kotlin

private int limit = 30;
private String GUID = "cometchat-guid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder().setSearchKeyword("Hello").setGUID(GUID).setLimit(limit).build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
    @Override
    public void onSuccess(List<BaseMessage> list) {
        for (BaseMessage message : list) {
            if (message instanceof TextMessage) {
                Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
            } else if (message instanceof MediaMessage) {
                Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
            }
        }
    }

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

val limit = 30
val GUID = "cometchat-guid-1"

val messagesRequest = MessagesRequestBuilder().setSearchKeyword("Hello").setGUID(GUID).setLimit(limit).build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
    override fun onSuccess(list: List<BaseMessage?>) {
        for (message in list) {
            if (message is TextMessage) {
                Log.d(TAG, "Text message received successfully: $message")
            } else if (message is MediaMessage) {
                Log.d(TAG, "Media message received successfully: $message")
            }
        }
    }

    override fun onError(e: CometChatException) {
        Log.d(TAG, "Message fetching failed with exception: ${e.message}")
    }
})

Unread Messages Count

In other words, as a logged-in user, how do I find out the number of unread messages that I have?

Fetch Unread Message Count of a particular one-on-one conversation

In other words, how do I find out the number of unread messages I have from a particular user? In order to get the unread message count for a particular user (with respect to the logged-in user), you can use the getUnreadMessageCountForUser(). This method has the two variants:

Java
Kotlin

CometChat.getUnreadMessageCountForUser(String UID, Callbacks);

CometChat.getUnreadMessageCountForUser(UID: String, Callbacks)

If you wish to ignore the messages from blocked users you can use the below syntax setting the boolean parameter to true:

Java
Kotlin

CometChat.getUnreadMessageCountForUser(String UID, boolean hideMessagesFromBlockedUsers, Callbacks);

CometChat.getUnreadMessageCountForUser(UID: String, hideMessagesFromBlockedUsers: Boolean, Callbacks)

Java
Kotlin

private String UID = "cometchat-uid-1"
  
CometChat.getUnreadMessageCountForUser(UID, new CometChat.CallbackListener<HashMap<String, Integer>>() {
    @Override
    public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
        //handle success
    }

    @Override
    public void onError(CometChatException e) {
        //handle error
    }
});

val UID: String = "cometchat-uid-1"
        
CometChat.getUnreadMessageCountForUser(UID, object : CallbackListener<HashMap<String?, Int?>?>() {
    override fun onSuccess(stringIntegerHashMap: HashMap<String?, Int?>?) {
        //handle success
    }

    override fun onError(e: CometChatException) {
        //handle error
    }
})

In the onSuccess() callback, you will receive a Hashmap which will contain the UID of the user as the key and the unread message count as the value.

Fetch Unread Message Count of a particular group conversation

In other words, how do I find out the number of unread messages I have in a single group? In order to get the unread message count for a particular group, you can use the getUnreadMessageCountForGroup(). This method has two variants:

Java
Kotlin

CometChat.getUnreadMessageCountForGroup(String GUID, Callbacks);

CometChat.getUnreadMessageCountForUser(GUID: String, Callbacks)

If you wish to ignore the messages from blocked users you can use the following syntax setting the boolean parameter to true:

Java
Kotlin

CometChat.getUnreadMessageCountForGroup(String GUID, boolean hideMessagesFromBlockedUsers, Callbacks);

CometChat.getUnreadMessageCountForUser(GUID: String, hideMessagesFromBlockedUsers: Boolean, Callbacks)

Java
Kotlin

private String GUID = "cometchat-guid-1"
  
CometChat.getUnreadMessageCountForGroup(GUID, new CometChat.CallbackListener<HashMap<String, Integer>>(){
    @Override
    public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
        //handle success
    }

    @Override
    public void onError(CometChatException e) {
        //handle error
    }
});

val GUID: String = "cometchat-guid-1"

CometChat.getUnreadMessageCountForGroup(GUID, object : CallbackListener<HashMap<String?, Int?>?>() {
        override fun onSuccess(stringIntegerHashMap: HashMap<String?, Int?>?) {
            //handle success
        }

        override fun onError(e: CometChatException) {
            //handle error
        }
    }
)

In the onSuccess() callback, you will receive a Hashmap which will contain the GUID of the group as the key and the unread message count as the value.

Fetch Unread Message Count of all one-on-one & group conversations

In other words, how do I find out the number of unread messages for every one-on-one and group conversation? In order to get all the unread message counts, you can use the getUnreadMessageCount() method. This method has two variants:

Java
Kotlin

CometChat.getUnreadMessageCount(Callbacks);

CometChat.getUnreadMessageCount(Callbacks)

If you wish to ignore the messages from blocked users you can use the following syntax setting the boolean parameter to true:

Java
Kotlin

CometChat.getUnreadMessageCount(boolean hideMessagesFromBlockedUsers, Callbacks);

CometChat.getUnreadMessageCount(hideMessagesFromBlockedUsers: Boolean, Callbacks)

Java
Kotlin

CometChat.getUnreadMessageCount(new CometChat.CallbackListener<HashMap<String, HashMap<String, Integer>>>() {
    @Override
    public void onSuccess(HashMap<String, HashMap<String, Integer>> stringHashMapHashMap) {
        //handle success
    }

    @Override
    public void onError(CometChatException e) {
        //handle error
    }
});

CometChat.getUnreadMessageCount(object : CallbackListener<HashMap<String?, HashMap<String?, Int?>?>?>() {
    override fun onSuccess(stringHashMapHashMap: HashMap<String?, HashMap<String?, Int?>?>?) {
        //handle success
    }

    override fun onError(e: CometChatException) {
        //handle error
    }
})

In the onSuccess() callback, you will receive a hashmap having two keys:

user - The value for this key holds another hashmap that holds the UIDs of users and their corresponding unread message counts.
group - The value for this key holds another hashmap that holds the GUIDs of groups and their corresponding unread message counts.

Fetch Unread Message Count of all one-on-one conversations

In other words, how do I find out the number of unread messages I have for every user? In order to fetch the unread message counts for just the users, you can use the getUnreadMessageCountForAllUsers() method. This method, just like others, has two variants:

Java
Kotlin

CometChat.getUnreadMessageCountForAllUsers(Callbacks);

CometChat.getUnreadMessageCountForAllUsers(Callbacks)

If you wish to ignore the messages from blocked users you can use the following syntax setting the boolean parameter to true:

Java
Kotlin

CometChat.getUnreadMessageCountForAllUsers(boolean hideMessagesFromBlockedUsers, Callbacks);

CometChat.getUnreadMessageCountForAllUsers(hideMessagesFromBlockedUsers: Boolean, Callbacks)

Java
Kotlin

CometChat.getUnreadMessageCountForAllUsers(new CometChat.CallbackListener<HashMap<String, Integer>>() {
  @Override
    public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
    	// Handle Success
  }

  @Override
    public void onError(CometChatException e) {
    	// Handle Error
  }
});

CometChat.getUnreadMessageCountForAllUsers(object : CometChat.CallbackListener<HashMap<String, Int>>() {
  override fun onSuccess(stringIntegerHashMap: HashMap<String, Int>) {
    Log.d(TAG,"onSuccess: ${stringIntegerHashMap.size}")
  }
  
  override fun onError(e: CometChatException) {
    Log.d(TAG,"onError: ${e.message}")
  }
})

In the onSuccess() callback, you will receive a Hashmap that will contain the UIDs of users as the key and the unread message counts as the values.

Fetch Unread Message Count of all group conversations

In other words, how do I find out the number of unread messages for every group? In order to fetch the unread message counts for all groups, you can use the getUnreadMessageCountForAllGroups() method. This method has two variants:

Java
Kotlin

CometChat.getUnreadMessageCountForAllGroups(Callbacks);

CometChat.getUnreadMessageCountForAllGroups(Callbacks)

If you wish to ignore the messages from blocked users you can use the below syntax setting the boolean parameter to true:

Java
Kotlin

CometChat.getUnreadMessageCountForAllGroups(boolean hideMessagesFromBlockedUsers, Callbacks);

CometChat.getUnreadMessageCountForAllGroups(hideMessagesFromBlockedUsers: Boolean, Callbacks)

Java
Kotlin

CometChat.getUnreadMessageCountForAllGroups(new CometChat.CallbackListener<HashMap<String, Integer>>() {
  @Override
    public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
    	//Handle success
  }
  
  @Override
    public void onError(CometChatException e) {
    //Handle Error
  }
});

CometChat.getUnreadMessageCountForAllGroups(object : CometChat.CallbackListener<HashMap<String, Int>>() {
  override fun onSuccess(stringIntegerHashMap: HashMap<String, Int>) {
    Log.d(TAG,"onSuccess: ${stringIntegerHashMap.size}")
  }

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

In the onSuccess() callback, you will receive a hashmap which will contain the GUIDs of the groups as the key and the unread message counts as the values.

​Real-time Messages

​Missed Messages

​Fetch Missed Messages of a particular one-on-one conversation

​Fetch Missed Messages of a particular group conversation

​Unread Messages

​Fetch Unread Messages of a particular one-on-one conversation

​Fetch Unread Messages of a particular group conversation

​Message History

​Fetch Message History of a particular one-on-one conversation

​Fetch Message History of a particular group conversation

​Search Messages

​Search Messages in a particular one-on-one conversation

​Search Messages in a particular group conversation

​Unread Messages Count

​Fetch Unread Message Count of a particular one-on-one conversation

​Fetch Unread Message Count of a particular group conversation

​Fetch Unread Message Count of all one-on-one & group conversations

​Fetch Unread Message Count of all one-on-one conversations

​Fetch Unread Message Count of all group conversations

Real-time Messages

Missed Messages

Fetch Missed Messages of a particular one-on-one conversation

Fetch Missed Messages of a particular group conversation

Unread Messages

Fetch Unread Messages of a particular one-on-one conversation

Fetch Unread Messages of a particular group conversation

Message History

Fetch Message History of a particular one-on-one conversation

Fetch Message History of a particular group conversation

Search Messages

Search Messages in a particular one-on-one conversation

Search Messages in a particular group conversation

Unread Messages Count

Fetch Unread Message Count of a particular one-on-one conversation

Fetch Unread Message Count of a particular group conversation

Fetch Unread Message Count of all one-on-one & group conversations

Fetch Unread Message Count of all one-on-one conversations

Fetch Unread Message Count of all group conversations