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

# Block/Unblock User

> Let users block and unblock others directly within chat to control unwanted communication.

<Accordion title="AI Integration Quick Reference">
  | Field | Value |
  | - | - |
  | Packages | `com.cometchat:chatuikit-kotlin-android` · `com.cometchat:chatuikit-compose-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 v6+, 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 v6 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 `CometChatUIKit.login()`.
* Existing one-on-one chat screen using `CometChatMessageList` and `CometChatMessageComposer`.

## Components

| Component / Class | Role |
| :- | :- |
| `UserDetailActivity` | Displays user profile and provides block/unblock options. |
| `MessagesActivity` | 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 (XML Views)">
    ```kotlin lines theme={null}
    // In MessagesActivity.kt
    import com.cometchat.uikit.kotlin.presentation.messagecomposer.ui.CometChatMessageComposer

    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="Jetpack Compose">
    ```kotlin lines theme={null}
    // In MessagesScreen.kt
    import com.cometchat.uikit.compose.presentation.messagecomposer.ui.CometChatMessageComposer

    @Composable
    fun MessagesScreen(user: User) {
        val blocked = user.isBlockedByMe

        Column(modifier = Modifier.fillMaxSize()) {
            // Message list...

            if (blocked) {
                UnblockPrompt(onUnblock = { /* unblock logic */ })
            } else {
                CometChatMessageComposer(user = user)
            }
        }
    }
    ```
  </Tab>
</Tabs>

**File reference:**\
[`MessagesActivity.kt`](https://github.com/cometchat/cometchat-uikit-android/blob/v6/sample-app-kotlin)

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 (chatuikit-kotlin) -->
<com.cometchat.uikit.kotlin.presentation.messagecomposer.ui.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>
```

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 (XML Views)">
    ```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.value = false
            }
            override fun onError(e: CometChatException?) {
                // Handle error
            }
        })
    }
    ```
  </Tab>

  <Tab title="Jetpack Compose">
    ```kotlin lines theme={null}
    // In MessagesViewModel.kt
    private val _isBlocked = MutableStateFlow(false)
    val isBlocked: StateFlow<Boolean> = _isBlocked.asStateFlow()

    fun unblockUser() {
        CometChat.unblockUsers(listOf(currentUser.uid), object : CometChat.CallbackListener<HashMap<String, String>>() {
            override fun onSuccess(resultMap: HashMap<String, String>) {
                _isBlocked.value = false
            }
            override fun onError(e: CometChatException?) {
                // Handle error
            }
        })
    }

    // In MessagesScreen.kt
    @Composable
    fun MessagesScreen(viewModel: MessagesViewModel = viewModel()) {
        val isBlocked by viewModel.isBlocked.collectAsState()

        if (isBlocked) {
            Button(onClick = { viewModel.unblockUser() }) {
                Text("Unblock")
            }
        }
    }
    ```
  </Tab>
</Tabs>

Executes unblock logic and updates state to refresh UI.

### 4. Trigger Block from Detail Screen

Allow blocking directly from a user's profile.

<Tabs>
  <Tab title="Kotlin (XML Views)">
    ```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="Jetpack Compose">
    ```kotlin lines theme={null}
    // In UserDetailScreen.kt
    @Composable
    fun BlockButton(user: User, onBlocked: () -> Unit) {
        Button(onClick = {
            CometChat.blockUsers(listOf(user.uid), object : CometChat.CallbackListener<HashMap<String, String>>() {
                override fun onSuccess(resultMap: HashMap<String, String>) {
                    onBlocked()
                }
                override fun onError(e: CometChatException?) { /* Handle error */ }
            })
        }) {
            Text("Block User")
        }
    }
    ```
  </Tab>
</Tabs>

## Implementation Flow

| Step | Action | Location |
| :- | :- | :- |
| 1 | Check block status | `updateUserBlockStatus()` in `MessagesActivity` |
| 2 | Show/hide composer and unblock layout | `activity_messages.xml` or Compose conditional |
| 3 | Unblock API call and state 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 state reverts 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 (Kotlin)">
    Explore this feature in the CometChat SampleApp:
    [GitHub → SampleApp](https://github.com/cometchat/cometchat-uikit-android/tree/v6/sample-app-kotlin)
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.