> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-agent-in-group-react-v6.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Retrieve Users

> Retrieve Users — CometChat documentation.

## Retrieve Logged In User Details

You can get the details of the logged-in user using the `getLoggedInUser()` method. This method can also be used to check if the user is logged in or not. If the method returns `null`, it indicates that the user is not logged in and you need to log the user into CometChat.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    User user = CometChat.getLoggedInUser();
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val user=CometChat.getLoggedInUser()
    ```
  </Tab>
</Tabs>

This method will return a `User` object containing all the information related to the logged-in user.

## Retrieve List of Users

In order to fetch the list of users, you can use the `UsersRequest` class. To use this class i.e to create an object of the UsersRequest class, you need to use the `UsersRequestBuilder` class. The `UsersRequestBuilder` class allows you to set the parameters based on which the users are to be fetched.

The `UsersRequestBuilder` class allows you to set the below parameters:

### Set Limit

This method sets the limit i.e. the number of users that should be fetched in a single iteration.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
      .setLimit(30)
      .build();
    ```
  </Tab>
</Tabs>

### Set Search Keyword

This method allows you to set the search string based on which the users are to be fetched.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .setSearchKeyword("abc")
    .build();
    ```
  </Tab>
</Tabs>

### Set Status

The status based on which the users are to be fetched. The status parameter can contain one of the below two values:

* CometChat.USER\_STATUS.ONLINE - will return the list of only online users.
* CometChat.USER\_STATUS.OFFLINE - will return the list of only offline users.

If this parameter is not set, will return all the available users.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .setUserStatus(UsersRequest.USER_STATUS_ONLINE)
    .build();
    ```
  </Tab>
</Tabs>

If this parameter is not set, will return all users.

### Hide Blocked Users

This method is used to determine if the blocked users should be returned as a part of the user list. If set to `true`, the user list will not contain the users blocked by the logged-in user.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .hideBlockedUsers(true)
    .build();
    ```
  </Tab>
</Tabs>

### Set Roles

This method allows you to fetch the users based on multiple roles.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    List<String> roles = new ArrayList<>();
    roles.add("role1");
    roles.add("role2");
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .setRoles(roles)
    .build();
    ```
  </Tab>
</Tabs>

### Friends Only

This property when set to true will return only the friends of the logged-in user.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .friendsOnly(true)
    .build();
    ```
  </Tab>
</Tabs>

### Set Tags

This method accepts a list of tags based on which the list of users is to be fetched. The list fetched will only contain the users that have been tagged with the specified tags.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    List<String> tags = new ArrayList<>();
    tags.add("tag1");
    tags.add("tag2");
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .setTags(tags)
    .build();
    ```
  </Tab>
</Tabs>

### With Tags

This property when set to true will fetch tags data along with the list of users.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .withTags(true)
    .build();
    ```
  </Tab>
</Tabs>

### Set UIDs

This method accepts a list of UIDs based on which the list of users is fetched. A maximum of 25 users can be fetched.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    List<String> uids = new ArrayList<>();
    uids.add("cometchat-uid-1");
    uids.add("cometchat-uid-2");
    UsersRequest usersRequest = new UsersRequest.UsersRequestBuilder()
    .setLimit(limit)
    .setUIDs(uids)
    .build();
    ```
  </Tab>
</Tabs>

Finally, once all the parameters are set to the builder class, you need to call the `build()` method to get the object of the `UsersRequest` class.

Once you have the object of the `UsersRequest` class, you need to call the `fetchNext()` method. Calling this method will return a list of `User` objects containing X number of users depending on the limit set.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    private UsersRequest usersRequest = null;
    private int limit = 30;

    usersRequest = new UsersRequest.UsersRequestBuilder().setLimit(limit).build();

    usersRequest.fetchNext(new CometChat.CallbackListener<List<User>>() {
      @Override
      public void onSuccess(List <User> list) {
        Log.d(TAG, "User list received: " + list.size());
      }
      @Override
      public void onError(CometChatException e) {
        Log.d(TAG, "User list fetching failed with exception: " + e.getMessage());
      }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    var usersRequest:UsersRequest?=null
    val limit:Int=30

    usersRequest=UsersRequest.UsersRequestBuilder().setLimit(limit).build()
        
         usersRequest?.fetchNext(object :CometChat.CallbackListener<List<User>>(){
           override fun onSuccess(p0: List<User>?) {
             Log.d(TAG, "User list received: " + p0?.size)
           }

           override fun onError(p0: CometChatException?) {
             Log.d(TAG, "User list fetching failed with exception: " + p0?.message)
           }
         })
    ```
  </Tab>
</Tabs>

## Retrieve Particular User Details

To get the information of a user, you can use the `getUser()` method.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    private String UID = "UID";

    CometChat.getUser(UID, new CometChat.CallbackListener<User>() {
      @Override
      public void onSuccess(User user) {
        Log.d(TAG, "User details fetched for user: " + user.toString());
      }
      @Override
      public void onError(CometChatException e) {
        Log.d(TAG, "User details fetching failed with exception: " + e.getMessage());
      }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val UID:String="UID"

    CometChat.getUser(UID,object :CometChat.CallbackListener<User>(){
      override fun onSuccess(p0: User?) {
        Log.d(TAG, "User details fetched for user: " + p0?.toString())
      }

      override fun onError(p0: CometChatException?) {
        Log.d(TAG, "User details fetching failed with exception: " + p0?.message)
      }
    })
    ```
  </Tab>
</Tabs>

The `getUser()` method takes the following parameters:

| Parameter | Description                                                |
| --------- | ---------------------------------------------------------- |
| `UID`     | The UID of the user for whom the details are to be fetched |

On success, the `User` object containing the details of the user is returned.