> ## 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.

# Block/Unblock User

> Block and unblock users in CometChat Android UI Kit with user relationship checks, SDK methods, and composer UI updates.

<Accordion title="AI Integration Quick Reference">
  | Field          | Value                                                                                                                                            |
  | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
  | Package        | `com.cometchat:chat-uikit-android`                                                                                                               |
  | Key components | `CometChatMessageComposer`, `CometChat.blockUsers()`, `CometChat.unblockUsers()`, `User.isBlockedByMe()`                                         |
  | Purpose        | Let users block and unblock others directly within chat to control unwanted communication.                                                       |
  | Related        | [Message Composer](/ui-kit/android/message-composer), [Message List](/ui-kit/android/message-list), [All Guides](/ui-kit/android/guide-overview) |
</Accordion>

Enable users to block and unblock others directly within chat using CometChat’s Android UI Kit v5+, preventing unwanted communication and giving users more control.

## Overview

Blocking a user stops them from sending messages to the blocker. The CometChat UIKit handles most behaviors internally:

* **Composer Hidden:** The message composer is hidden when chatting with a blocked user.
* **Unblock Prompt:** An “Unblock” button is displayed to reverse the block.
* **Message Restrictions:** Blocked users cannot send messages to the blocker.

## Prerequisites

* Android Studio project with CometChat Android UI Kit v5 added to `build.gradle`.
* CometChat **App ID**, **Auth Key**, and **Region** configured and initialized.
* `<uses-permission android:name="android.permission.INTERNET"/>` in `AndroidManifest.xml`.
* Logged-in user via `CometChat.login()`.
* Existing one-on-one chat screen using `CometChatMessageList` and `CometChatMessageComposer`.

## Components

| Component / Class          | Role                                                       |
| :------------------------- | :--------------------------------------------------------- |
| `UserDetailActivity.java`  | Displays user profile and provides block/unblock options.  |
| `MessagesActivity.java`    | Hosts the chat screen and toggles UI based on block state. |
| `CometChat.blockUsers()`   | SDK API to block one or more users by UID.                 |
| `CometChat.unblockUsers()` | SDK API to unblock one or more users by UID.               |
| `User.isBlockedByMe()`     | Checks if the current user has blocked this user.          |
| `unblockLayout` (View)     | Layout shown when a user is blocked, containing unblock.   |
| `CometChatMessageComposer` | Hidden when chatting with a blocked user.                  |

## Integration Steps

### 1. Detect Block Status

Update UI when block state changes.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    // In MessagesActivity.kt
    private fun updateUserBlockStatus(user: User) {
        val blocked = user.isBlockedByMe
        binding.messageComposer.visibility = if (blocked) View.GONE else View.VISIBLE
        binding.unblockLayout.visibility = if (blocked) View.VISIBLE else View.GONE
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    // In MessagesActivity.java
    private void updateUserBlockStatus(User user) {
        boolean blocked = user.isBlockedByMe();
        binding.messageComposer.setVisibility(blocked ? View.GONE : View.VISIBLE);
        binding.unblockLayout.setVisibility(blocked ? View.VISIBLE : View.GONE);
    }
    ```
  </Tab>
</Tabs>

**File reference:**\
[`MessagesActivity.java`](https://github.com/cometchat/cometchat-uikit-android/blob/v5/sample-app-java/src/main/java/com/cometchat/sampleapp/java/ui/activity/MessagesActivity.java)

Ensures the composer and unblock UI reflect the current block state.

### 2. Hide Composer & Show Unblock UI

Define layout elements and their visibility toggles.

```xml activity_messages.xml lines theme={null}
<!-- In activity_messages.xml -->
<com.cometchat.chatuikit.messagecomposer.CometChatMessageComposer
    android:id="@+id/messageComposer"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

<LinearLayout
    android:id="@+id/unblockLayout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:gravity="center"
    android:padding="12dp"
    android:visibility="gone">

    <Button
        android:id="@+id/unblockBtn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Unblock" />
</LinearLayout>
```

**File reference:**\
[`activity_messages.xml`](https://github.com/cometchat/cometchat-uikit-android/blob/v5/sample-app-java/src/main/res/layout/activity_messages.xml)

Prepares the UI containers for dynamic show/hide operations.

### 3. Trigger Unblock Action

Call the unblock API and observe status updates.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    // In MessagesActivity.kt
    binding.unblockBtn.setOnClickListener { viewModel.unblockUser() }

    // In MessagesViewModel.kt
    fun unblockUser() {
        CometChat.unblockUsers(listOf(currentUser.uid), object : CometChat.CallbackListener<HashMap<String, String>>() {
            override fun onSuccess(resultMap: HashMap<String, String>) {
                unblockButtonState.postValue(false)
            }
            override fun onError(e: CometChatException?) {
                // Handle error
            }
        })
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    // In MessagesActivity.java
    binding.unblockBtn.setOnClickListener(v -> viewModel.unblockUser());

    // In MessagesViewModel.java
    public void unblockUser() {
        CometChat.unblockUsers(Collections.singletonList(currentUser.getUid()), new CometChat.CallbackListener<HashMap<String, String>>() {
            @Override
            public void onSuccess(HashMap<String, String> resultMap) {
                unblockButtonState.postValue(false);
            }
            @Override
            public void onError(CometChatException e) {
                // Handle error
            }
        });
    }
    ```
  </Tab>
</Tabs>

**File references:**

* [`MessagesActivity.java`](https://github.com/cometchat/cometchat-uikit-android/blob/v5/sample-app-java/src/main/java/com/cometchat/sampleapp/java/ui/activity/MessagesActivity.java)
* [`MessagesViewModel.java`](https://github.com/cometchat/cometchat-uikit-android/blob/v5/sample-app-java/src/main/java/com/cometchat/sampleapp/java/viewmodels/MessagesViewModel.java)

Executes unblock logic and updates LiveData to refresh UI.

### 4. Trigger Block from Detail Screen

Allow blocking directly from a user’s profile.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    // In UserDetailActivity.kt
    binding.blockMenuItem.setOnClickListener {
        CometChat.blockUsers(listOf(user.uid), object : CometChat.CallbackListener<HashMap<String, String>>() {
            override fun onSuccess(resultMap: HashMap<String, String>) {
                viewModel.refreshUser()
            }
            override fun onError(e: CometChatException?) {
                // Handle error
            }
        })
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    // In UserDetailActivity.java
    binding.blockMenuItem.setOnClickListener(v -> {
        CometChat.blockUsers(Collections.singletonList(user.getUid()), new CometChat.CallbackListener<HashMap<String, String>>() {
            @Override
            public void onSuccess(HashMap<String, String> resultMap) {
                viewModel.refreshUser();
            }
            @Override
            public void onError(CometChatException e) {
                // Handle error
            }
        });
    });
    ```
  </Tab>
</Tabs>

**File reference:**\
[`UserDetailActivity.java`](https://github.com/cometchat/cometchat-uikit-android/blob/v5/sample-app-java/src/main/java/com/cometchat/sampleapp/java/ui/activity/UserDetailsActivity.java)

Integrates block action into the profile menu, triggering the UI toggle via LiveData.

## Implementation Flow

| Step | Action                                | Location                                                                   |
| :--- | :------------------------------------ | :------------------------------------------------------------------------- |
| 1    | Check block status                    | `updateUserBlockStatus()` in `MessagesActivity.java` fileciteturn9file0 |
| 2    | Show/hide composer and unblock layout | `activity_messages.xml` fileciteturn9file0                              |
| 3    | Unblock API call and LiveData update  | `MessagesViewModel.unblockUser()`                                          |
| 4    | Block API call from profile           | `UserDetailActivity.blockMenuItem`                                         |

## Customization Options

* **Feedback UI:** Show a Toast or Snackbar upon success/failure.
* **Menu Icons/Text:** Toggle icon and text dynamically after block/unblock.
* **Disable History:** Optionally gray out or hide past messages when blocked.

## Filtering & Edge Cases

| Case            | Behavior                                      |
| :-------------- | :-------------------------------------------- |
| Blocked User    | Composer hidden; unblock layout shown.        |
| Block Self      | SDK ignores request; ensure menu is disabled. |
| Group Chat      | Blocking affects only 1:1 communication.      |
| Network Failure | Observe error callbacks and retry as needed.  |

## Error Handling

* Handle errors from `blockUsers` and `unblockUsers` callbacks by showing alerts or retry prompts.
* Ensure UI LiveData states revert on failure.

## Group vs. User-Level Differences

| Scenario             | UI Behavior                           |
| :------------------- | :------------------------------------ |
| `ReceiverType.USER`  | Block/unblock enabled.                |
| `ReceiverType.GROUP` | Block option ignored; chat continues. |

## Summary / Feature Matrix

| Feature            | Component / Method                 |
| :----------------- | :--------------------------------- |
| Check block state  | `User.isBlockedByMe()`             |
| Block user         | `CometChat.blockUsers()`           |
| Unblock user       | `CometChat.unblockUsers()`         |
| Update UI          | `updateUserBlockStatus()`          |
| Profile block menu | `UserDetailActivity.blockMenuItem` |

## Next Steps & Further Reading

<CardGroup>
  <Card title="Android Sample App (Java)">
    Explore this feature in the CometChat SampleApp:
    [GitHub → SampleApp](https://github.com/cometchat/cometchat-uikit-android/tree/v5/sample-app-java)
  </Card>

  <Card title="Android Sample App (Kotlin)">
    Explore this feature in the CometChat SampleApp:
    [GitHub → SampleApp](https://github.com/cometchat/cometchat-uikit-android/tree/v5/sample-app-kotlin)
  </Card>
</CardGroup>