> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-rn-guide-message-privately.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Mentions

> Send messages with user mentions, retrieve mentioned users, and filter messages by mention metadata using the CometChat Android SDK.

Mentions let users refer to specific individuals in a conversation using the `<@uid:UID>` format. They're especially useful in group chats for directing messages at particular participants.

## Send Mentioned Messages

To mention a user, embed `<@uid:UID>` in your message text. For example: `"Hello <@uid:cometchat-uid-1>"`. The `sendMessage()` method returns a [`TextMessage`](/sdk/reference/messages#textmessage) object on success.

<Tabs>
  <Tab title="To User">
    <Tabs>
      <Tab title="Kotlin">
        ```kotlin theme={null}
        private val receiverID = "UID"
        private val messageText = "Hello <@uid:cometchat-uid-1>"
        private val receiverType = CometChatConstants.RECEIVER_TYPE_USER

        val textMessage = TextMessage(receiverID, messageText, receiverType)
        CometChat.sendMessage(textMessage, object : CallbackListener<TextMessage>() {
          override fun onSuccess(textMessage: TextMessage) {
              Log.d(TAG, "Message sent successfully: $textMessage")
          }

          override fun onError(e: CometChatException) {
              Log.d(TAG, "Message sending failed with exception: " + e.message)
          }
        })
        ```
      </Tab>

      <Tab title="Java">
        ```java theme={null}
        private String receiverID = "UID";
        private String messageText = "Hello, <@uid:cometchat-uid-1>";
        private String receiverType = CometChatConstants.RECEIVER_TYPE_USER;

        TextMessage textMessage = new TextMessage(receiverID, messageText, receiverType);

        CometChat.sendMessage(textMessage, new CometChat.CallbackListener<TextMessage>() {
          @Override
          public void onSuccess(TextMessage textMessage) {
              Log.d(TAG, "Message sent successfully: " + textMessage.toString());
          }

          @Override
          public void onError(CometChatException e) {
              Log.d(TAG, "Message sending failed with exception: " + e.getMessage());
          }
        });
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="To Group">
    <Tabs>
      <Tab title="Kotlin">
        ```kotlin theme={null}
        private val receiverID = "GUID"
        private val messageText = "Hello <@uid:cometchat-uid-1>"
        private val receiverType = CometChatConstants.RECEIVER_TYPE_GROUP

        val textMessage = TextMessage(receiverID, messageText, receiverType)
        CometChat.sendMessage(textMessage, object : CallbackListener<TextMessage>() {
          override fun onSuccess(textMessage: TextMessage) {
              Log.d(TAG, "Message sent successfully: $textMessage")
          }

          override fun onError(e: CometChatException) {
              Log.d(TAG, "Message sending failed with exception: " + e.message)
          }
        })
        ```
      </Tab>

      <Tab title="Java">
        ```java theme={null}
        private String receiverID = "GUID";
        private String messageText = "Hello <@uid:cometchat-uid-1>";
        private String receiverType = CometChatConstants.RECEIVER_TYPE_GROUP;

        TextMessage textMessage = new TextMessage(receiverID, messageText, receiverType);

        CometChat.sendMessage(textMessage, new CometChat.CallbackListener<TextMessage>() {
          @Override
          public void onSuccess(TextMessage textMessage) {
              Log.d(TAG, "Message sent successfully: " + textMessage.toString());
          }

          @Override
          public void onError(CometChatException e) {
              Log.d(TAG, "Message sending failed with exception: " + e.getMessage());
          }
        });
        ```
      </Tab>
    </Tabs>
  </Tab>
</Tabs>

<Info>
  You can mention user in text message and media messages captions
</Info>

## Mentioned Messages

By default, the SDK will fetch all the messages irrespective of the fact that the logged-in user is mentioned or not in the message. The SDK has other optional filters such as tag info and blocked info. For more filtering options, see [Additional Message Filtering](/sdk/android/additional-message-filtering).

| Setting                                  | Description                                                                                                                                                                    |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `mentionsWithTagInfo(boolean value)`     | If set to `true`, SDK will fetch a list of messages where users are mentioned & will also fetch the tags of the mentioned users. **Default value = false.**                    |
| `mentionsWithBlockedInfo(boolean value)` | If set to `true`, SDK will fetch a list of messages where users are mentioned & will also fetch their blocked relationship with the logged-in user. **Default value = false.** |

## Mentions With Tag Info

To get a list of messages in a conversation where users are mentioned along with the user tags of the mentioned users.

<Tabs>
  <Tab title="To User">
    <Tabs>
      <Tab title="Kotlin">
        ```kotlin theme={null}
        val UID = "cometchat-uid-1"

        val messagesRequest = MessagesRequest.MessagesRequestBuilder()
          .setLimit(50)
          .setUID(UID)
          .mentionsWithTagInfo(true)
          .build()

        messagesRequest.fetchPrevious(object : CometChat.CallbackListener<List<BaseMessage>>() {
          override fun onSuccess(messages: List<BaseMessage>) {
              for (messageObj in messages) {
                  for (user in messageObj.mentionedUsers) {
                      Log.e(TAG, "tag: ${user.tags}")
                  }
              }
          }

          override fun onError(e: CometChatException) {
              Log.e(TAG, "onError: " + e)
          }
        })
        ```
      </Tab>

      <Tab title="Java">
        ```java theme={null}
        String UID = "cometchat-uid-1";

        MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setLimit(50)
        .setUID(UID)
        .mentionsWithTagInfo(true)
        .build();

        messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
          @Override
          public void onSuccess(List<BaseMessage> messages) {
            for (BaseMessage messageObj: messages){
              for (User user: messageObj.getMentionedUsers()){
                Log.e(TAG, "tag: " + user.getTags());
              }
            }
          }

          @Override
          public void onError(CometChatException e) {
            Log.e(TAG, "onError: " + e);
          }
        });
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="To Group">
    <Tabs>
      <Tab title="Kotlin">
        ```kotlin theme={null}
        val GUID = "cometchat-guid-1"

        val messagesRequest = MessagesRequest.MessagesRequestBuilder()
          .setLimit(50)
          .setGUID(GUID)
          .mentionsWithTagInfo(true)
          .build()

        messagesRequest.fetchPrevious(object : CometChat.CallbackListener<List<BaseMessage>>() {
          override fun onSuccess(messages: List<BaseMessage>) {
              for (messageObj in messages) {
                  for (user in messageObj.mentionedUsers) {
                      Log.e(TAG, "tag: ${user.tags}")
                  }
              }
          }

          override fun onError(e: CometChatException) {
              Log.e(TAG, "onError: " + e)
          }
        })
        ```
      </Tab>

      <Tab title="Java">
        ```java theme={null}
        String GUID = "cometchat-guid-1";

        MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setLimit(50)
        .setGUID(GUID)
        .mentionsWithTagInfo(true)
        .build();

        messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
          @Override
          public void onSuccess(List<BaseMessage> messages) {
            for (BaseMessage messageObj: messages){
              for (User user: messageObj.getMentionedUsers()){
                Log.e(TAG, "tag: " + user.getTags());
              }
            }
          }

          @Override
          public void onError(CometChatException e) {
            Log.e(TAG, "onError: " + e);
          }
        });
        ```
      </Tab>
    </Tabs>
  </Tab>
</Tabs>

## Mentions With Blocked Info

To get a list of messages in a conversation where users are mentioned along with the blocked relationship of the mentioned users with the logged-in user.

<Tabs>
  <Tab title="To User">
    <Tabs>
      <Tab title="Kotlin">
        ```kotlin theme={null}
        val UID = "cometchat-uid-1"

        val messagesRequest = MessagesRequest.MessagesRequestBuilder()
          .setLimit(50)
          .setUID(UID)
          .mentionsWithBlockedInfo(true)
          .build()

        messagesRequest.fetchPrevious(object : CometChat.CallbackListener<List<BaseMessage>>() {
          override fun onSuccess(messages: List<BaseMessage>) {
              for (messageObj in messages) {
                  for (user in messageObj.mentionedUsers) {
                      Log.e(TAG, "isBlockedByMe: ${user.isBlockedByMe}")
                      Log.e(TAG, "isHasBlockedMe: ${user.isHasBlockedMe}")
                  }
              }
          }

          override fun onError(e: CometChatException) {
              Log.e(TAG, "onError: " + e)
          }
        })
        ```
      </Tab>

      <Tab title="Java">
        ```java theme={null}
        String UID = "cometchat-uid-1";

        MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setLimit(50)
        .setUID(UID)
        .mentionsWithBlockedInfo(true)
        .build();

        messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
          @Override
          public void onSuccess(List<BaseMessage> messages) {
            for (BaseMessage messageObj: messages){
              for (User user: messageObj.getMentionedUsers()){
                Log.e(TAG, "isBlockedByMe: " + user.isBlockedByMe());
                Log.e(TAG, "isHasBlockedMe: " + user.isHasBlockedMe());
              }
            }
          }

          @Override
          public void onError(CometChatException e) {
            Log.e(TAG, "onError: " + e);
          }
        });
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="To Group">
    <Tabs>
      <Tab title="Kotlin">
        ```kotlin theme={null}
        val GUID = "cometchat-guid-1"

        val messagesRequest = MessagesRequest.MessagesRequestBuilder()
          .setLimit(50)
          .setGUID(GUID)
          .mentionsWithBlockedInfo(true)
          .build()

        messagesRequest.fetchPrevious(object : CometChat.CallbackListener<List<BaseMessage>>() {
          override fun onSuccess(messages: List<BaseMessage>) {
              for (messageObj in messages) {
                  for (user in messageObj.mentionedUsers) {
                      Log.e(TAG, "isBlockedByMe: ${user.isBlockedByMe}")
                      Log.e(TAG, "isHasBlockedMe: ${user.isHasBlockedMe}")
                  }
              }
          }

          override fun onError(e: CometChatException) {
              Log.e(TAG, "onError: " + e)
          }
        })
        ```
      </Tab>

      <Tab title="Java">
        ```java theme={null}
        String GUID = "cometchat-guid-1";

        MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
        .setLimit(50)
        .setGUID(GUID)
        .mentionsWithBlockedInfo(true)
        .build();

        messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
          @Override
          public void onSuccess(List<BaseMessage> messages) {
            for (BaseMessage messageObj: messages){
              for (User user: messageObj.getMentionedUsers()){
                Log.e(TAG, "isBlockedByMe: " + user.isBlockedByMe());
                Log.e(TAG, "isHasBlockedMe: " + user.isHasBlockedMe());
              }
            }
          }

          @Override
          public void onError(CometChatException e) {
            Log.e(TAG, "onError: " + e);
          }
        });
        ```
      </Tab>
    </Tabs>
  </Tab>
</Tabs>

## Get Mentioned Users from a Message

Use `getMentionedUsers()` on any message object to retrieve the list of [`User`](/sdk/reference/entities#user) objects mentioned in it. Returns an empty list if no users were mentioned.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    message.getMentionedUsers()
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    message.mentionedUsers
    ```
  </Tab>
</Tabs>

## Check if Logged-in user has been mentioned

To check if the logged-in user has been mentioned in a particular message we can use the `hasMentionedMe()` method on any [`BaseMessage`](/sdk/reference/messages#basemessage). This method will return a boolean value, `true` if the logged-in user has been mentioned, otherwise `false`.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    message.hasMentionedMe
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    message.hasMentionedMe()
    ```
  </Tab>
</Tabs>

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Send Messages" icon="paper-plane" href="/sdk/android/send-message">
    Learn how to send text, media, and custom messages
  </Card>

  <Card title="Receive Messages" icon="envelope" href="/sdk/android/receive-messages">
    Handle incoming messages with real-time listeners
  </Card>

  <Card title="Interactive Messages" icon="comment" href="/sdk/android/interactive-messages">
    Create messages with embedded forms and interactive elements
  </Card>

  <Card title="Retrieve Users" icon="users" href="/sdk/android/retrieve-users">
    Fetch user lists to enable mention autocomplete
  </Card>
</CardGroup>