> ## Documentation Index
> Fetch the complete documentation index at: https://www.cometchat.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Group Members

> Scrollable list of all members in a group with search, avatars, names, scope badges, and online/offline status.

`CometChatGroupMembers` renders a scrollable list of all members in a specific group with real-time updates for membership changes, search, avatars, scope badges, and online/offline status indicators. Requires a `Group` object to load data.

![](https://mintcdn.com/cometchat-22654f5b/tI1D0nyKUVcz2LEZ/images/c316bb0a-group_members-9849dc973b6addaffc0990af38520294.png?fit=max\&auto=format\&n=tI1D0nyKUVcz2LEZ\&q=85\&s=27e7f24a18ad2ab01b3702ce3c046398)

***

## Where It Fits

`CometChatGroupMembers` is a list component. It renders all members of a given group and emits the selected `GroupMember` via `onItemClick`. Use it inside a group detail screen or as a standalone member browser.

> [tab] Kotlin (XML Views)
>
> ```xml activity_group_members.xml lines theme={null}
> <com.cometchat.uikit.kotlin.presentation.groupmembers.ui.CometChatGroupMembers
>     android:id="@+id/group_members"
>     android:layout_width="match_parent"
>     android:layout_height="match_parent" />
> ```
>
> ```kotlin lines theme={null}
> val groupMembers = findViewById<CometChatGroupMembers>(R.id.group_members)
> groupMembers.setGroup(group)
>
> groupMembers.setOnItemClick { groupMember ->
>     // Navigate to member profile or start DM
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     modifier = Modifier.fillMaxSize(),
>     onItemClick = { groupMember ->
>         // Navigate to member profile or start DM
>     }
> )
> ```

***

## Quick Start

> [tab] Kotlin (XML Views)
>
> Add to your layout XML:
>
> ```xml lines theme={null}
> <com.cometchat.uikit.kotlin.presentation.groupmembers.ui.CometChatGroupMembers
>     android:id="@+id/group_members"
>     android:layout_width="match_parent"
>     android:layout_height="match_parent" />
> ```
>
> Then set the group in your Activity:
>
> ```kotlin lines theme={null}
> override fun onCreate(savedInstanceState: Bundle?) {
>     super.onCreate(savedInstanceState)
>     setContentView(R.layout.activity_group_members)
>
>     val groupMembers = findViewById<CometChatGroupMembers>(R.id.group_members)
>     groupMembers.setGroup(group) // Required — must be called before data loads
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> @Composable
> fun GroupMembersScreen(group: Group) {
>     CometChatGroupMembers(
>         group = group,
>         modifier = Modifier.fillMaxSize()
>     )
> }
> ```

Prerequisites: CometChat SDK initialized with `CometChatUIKit.init()`, a user logged in, and the UI Kit dependency added.

Or in a Fragment:

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
>     val view = CometChatGroupMembers(requireContext())
>     view.setGroup(group)
>     return view
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
>     return ComposeView(requireContext()).apply {
>         setContent { CometChatGroupMembers(group = group) }
>     }
> }
> ```

***

## Filtering Group Members

> [tab] Kotlin (XML Views)
>
> Pass a `GroupMembersRequest.GroupMembersRequestBuilder` to control what loads:
>
> ```kotlin lines theme={null}
> groupMembers.setGroupMembersRequestBuilder(
>     GroupMembersRequest.GroupMembersRequestBuilder(group.guid)
>         .setLimit(20)
>         .setScopes(listOf("admin", "moderator"))
> )
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     groupMembersRequestBuilder = GroupMembersRequest.GroupMembersRequestBuilder(group.guid)
>         .setLimit(20)
>         .setScopes(listOf("admin", "moderator"))
> )
> ```

### Filter Recipes

| Recipe | Builder method |
| - | - |
| Limit per page | `.setLimit(10)` |
| Search by keyword | `.setSearchKeyword("john")` |
| Filter by scopes | `.setScopes(listOf("admin", "moderator"))` |

> [!WARNING]
>
> Pass the builder object, not the result of `.build()`. The component calls `.build()` internally. Default page size is 30 with infinite scroll.

***

## Actions and Events

### Callback Methods

#### `onItemClick`

Fires when a member row is tapped. Primary navigation hook.

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOnItemClick { groupMember ->
>     // Navigate to member profile
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     onItemClick = { groupMember ->
>         // Navigate to member profile
>     }
> )
> ```

> Replaces the default item-click behavior. Your custom lambda executes instead of the built-in navigation.

#### `onItemLongClick`

Fires when a member row is long-pressed. Use for additional actions like kick or ban.

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOnItemLongClick { groupMember ->
>     // Show context menu
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     onItemLongClick = { groupMember ->
>         // Show context menu
>     }
> )
> ```

#### `onBackPress`

Fires when the user presses the back button in the toolbar.

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOnBackPress {
>     finish()
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     onBackPress = { /* navigate back */ }
> )
> ```

#### `onSearchClick`

Fires when the user taps the search icon in the toolbar.

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOnSearchClick {
>     // Open search screen
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     onSearchClick = { /* open search */ }
> )
> ```

#### `onSelection`

Fires when members are selected/deselected in multi-select mode.

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setSelectionMode(UIKitConstants.SelectionMode.MULTIPLE)
> groupMembers.setOnSelection { selectedMembers ->
>     updateToolbar(selectedMembers.size)
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     selectionMode = UIKitConstants.SelectionMode.MULTIPLE,
>     onSelection = { selectedMembers ->
>         updateToolbar(selectedMembers.size)
>     }
> )
> ```

#### `onError`

Fires on internal errors (network failure, auth issue, SDK exception).

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOnError { exception ->
>     Log.e("GroupMembers", "Error: ${exception.message}")
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     onError = { exception ->
>         Log.e("GroupMembers", "Error: ${exception.message}")
>     }
> )
> ```

#### `onLoad`

Fires when the list is successfully fetched and loaded.

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOnLoad { memberList ->
>     Log.d("GroupMembers", "Loaded ${memberList.size}")
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     onLoad = { memberList ->
>         Log.d("GroupMembers", "Loaded ${memberList.size}")
>     }
> )
> ```

#### `onEmpty`

Fires when the list is empty after loading.

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOnEmpty {
>     Log.d("GroupMembers", "No members found")
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     onEmpty = { /* no members */ }
> )
> ```

### SDK Events (Real-Time, Automatic)

The component listens to these SDK events internally. No manual setup needed.

| SDK Listener | Internal behavior |
| - | - |
| `onGroupMemberJoined` | Adds the new member to the list |
| `onGroupMemberLeft` | Removes the member from the list |
| `onGroupMemberKicked` | Removes the kicked member |
| `onGroupMemberBanned` | Removes the banned member |
| `onGroupMemberUnbanned` | Updates the member list |
| `onGroupMemberScopeChanged` | Updates the member's scope badge |
| `onMemberAddedToGroup` | Adds new members to the list |

***

## Functionality

| Method (Kotlin XML) | Compose Parameter | Description |
| - | - | - |
| `setGroup(group)` | `group = group` | Set the group to load members for (required) |
| `setBackIconVisibility(View.VISIBLE)` | `hideBackIcon = false` | Toggle back button |
| `setToolbarVisibility(View.GONE)` | `hideToolbar = true` | Toggle toolbar |
| `setSearchBoxVisibility(View.GONE)` | `hideSearchBox = true` | Toggle search box |
| `setSeparatorVisibility(View.GONE)` | `hideSeparator = true` | Toggle list separators |
| `setSelectionMode(MULTIPLE)` | `selectionMode = MULTIPLE` | Enable selection mode |
| `setTitle("Members")` | `title = "Members"` | Custom toolbar title |
| `setSearchPlaceholderText("Find...")` | `searchPlaceholderText = "Find..."` | Search placeholder |

***

## Custom View Slots

### Leading View

Replace the avatar / left section.

![](https://mintcdn.com/cometchat-22654f5b/2U5tVIzH12dbbFtr/images/b013490a-group_members_leading_view-87dce6741e65f09e848ea6698c75e978.png?fit=max\&auto=format\&n=2U5tVIzH12dbbFtr\&q=85\&s=60d882fddea606c70701c2182f739340)

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setLeadingView(object : GroupMembersViewHolderListener() {
>     override fun createView(context: Context, binding: CometchatListBaseItemsBinding): View {
>         return ImageView(context).apply {
>             layoutParams = ViewGroup.LayoutParams(48.dp, 48.dp)
>         }
>     }
>
>     override fun bindView(
>         context: Context, createdView: View, groupMember: GroupMember,
>         holder: RecyclerView.ViewHolder, memberList: List<GroupMember>, position: Int
>     ) {
>         val imageView = createdView as ImageView
>         // Load member avatar
>     }
> })
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     leadingView = { groupMember ->
>         CometChatAvatar(
>             imageUrl = groupMember.avatar,
>             name = groupMember.name
>         )
>     }
> )
> ```

### Title View

Replace the name / title text.

![](https://mintcdn.com/cometchat-22654f5b/oaJbJ0bOxG69pJ1L/images/8cc2ed79-group_members_title_view-a20a9c5f8ef829a4a5d35794d94ec352.png?fit=max\&auto=format\&n=oaJbJ0bOxG69pJ1L\&q=85\&s=404036e36742911741502fb45777019b)

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setTitleView(object : GroupMembersViewHolderListener() {
>     override fun createView(context: Context, binding: CometchatListBaseItemsBinding): View {
>         return TextView(context)
>     }
>
>     override fun bindView(
>         context: Context, createdView: View, groupMember: GroupMember,
>         holder: RecyclerView.ViewHolder, memberList: List<GroupMember>, position: Int
>     ) {
>         (createdView as TextView).text = groupMember.name ?: ""
>     }
> })
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     titleView = { groupMember ->
>         Text(
>             text = groupMember.name ?: "",
>             style = CometChatTheme.typography.heading4Medium
>         )
>     }
> )
> ```

### Subtitle View

Replace the subtitle text below the member's name.

![](https://mintcdn.com/cometchat-22654f5b/CrArf1QwUPg5EvCC/images/2b73a513-group_members_subtitle_view-b0b1463389d35067432eaf60d8418ffe.png?fit=max\&auto=format\&n=CrArf1QwUPg5EvCC\&q=85\&s=03215e499f332ec6705c137ec3e08ee8)

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setSubtitleView(object : GroupMembersViewHolderListener() {
>     override fun createView(context: Context, binding: CometchatListBaseItemsBinding): View {
>         return TextView(context).apply { maxLines = 1; ellipsize = TextUtils.TruncateAt.END }
>     }
>
>     override fun bindView(
>         context: Context, createdView: View, groupMember: GroupMember,
>         holder: RecyclerView.ViewHolder, memberList: List<GroupMember>, position: Int
>     ) {
>         (createdView as TextView).text = "Scope: ${groupMember.scope}"
>     }
> })
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     subtitleView = { groupMember ->
>         Text(
>             text = "Scope: ${groupMember.scope}",
>             maxLines = 1,
>             overflow = TextOverflow.Ellipsis
>         )
>     }
> )
> ```

### Trailing View

Replace the right section of each member item.

![](https://mintcdn.com/cometchat-22654f5b/aledzZZMtw_sXx4U/images/fb7e32ac-group_members_tail_view-19ea33e3931012467d4df750210007fe.png?fit=max\&auto=format\&n=aledzZZMtw_sXx4U\&q=85\&s=000761e5f3560b99cfbdc54acf95e671)

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setTrailingView(object : GroupMembersViewHolderListener() {
>     override fun createView(context: Context, binding: CometchatListBaseItemsBinding): View {
>         return TextView(context)
>     }
>
>     override fun bindView(
>         context: Context, createdView: View, groupMember: GroupMember,
>         holder: RecyclerView.ViewHolder, memberList: List<GroupMember>, position: Int
>     ) {
>         (createdView as TextView).text = groupMember.scope ?: ""
>     }
> })
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     trailingView = { groupMember ->
>         Text(text = groupMember.scope ?: "")
>     }
> )
> ```

### Item View

Replace the entire list item row.

![](https://mintcdn.com/cometchat-22654f5b/Relz_yItqW5RHUsU/images/506c713b-group_members_list_item_view-7db7e3429ec8898cb29e584a459ec43f.png?fit=max\&auto=format\&n=Relz_yItqW5RHUsU\&q=85\&s=376cda939b1a13556221461675370bdc)

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setItemView(object : GroupMembersViewHolderListener() {
>     override fun createView(context: Context, binding: CometchatListBaseItemsBinding): View {
>         return LayoutInflater.from(context).inflate(R.layout.custom_member_item, null)
>     }
>
>     override fun bindView(
>         context: Context, createdView: View, groupMember: GroupMember,
>         holder: RecyclerView.ViewHolder, memberList: List<GroupMember>, position: Int
>     ) {
>         val avatar = createdView.findViewById<CometChatAvatar>(R.id.custom_avatar)
>         val title = createdView.findViewById<TextView>(R.id.tvName)
>         title.text = groupMember.name
>         avatar.setAvatar(groupMember.name, groupMember.avatar)
>     }
> })
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     itemView = { groupMember ->
>         Row(
>             modifier = Modifier.fillMaxWidth().padding(12.dp),
>             verticalAlignment = Alignment.CenterVertically
>         ) {
>             CometChatAvatar(imageUrl = groupMember.avatar, name = groupMember.name)
>             Spacer(Modifier.width(12.dp))
>             Column {
>                 Text(groupMember.name ?: "", style = CometChatTheme.typography.heading4Medium)
>                 Text(groupMember.scope ?: "", style = CometChatTheme.typography.body3Regular)
>             }
>         }
>     }
> )
> ```

### State Views

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setEmptyView(R.layout.custom_empty_view)
> groupMembers.setErrorView(R.layout.custom_error_view)
> groupMembers.setLoadingView(R.layout.custom_loading_view)
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     emptyView = { Text("No members found") },
>     errorView = { onRetry -> Button(onClick = onRetry) { Text("Retry") } },
>     loadingView = { CircularProgressIndicator() }
> )
> ```

### Overflow Menu

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setOverflowMenu(ImageButton(context).apply {
>     setImageResource(R.drawable.ic_add_member)
>     setOnClickListener { /* add member */ }
> })
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     overflowMenu = {
>         IconButton(onClick = { /* add member */ }) {
>             Icon(painterResource(R.drawable.ic_add_member), "Add Member")
>         }
>     }
> )
> ```

***

## Member Permissions (who can act on whom)

`CometChatGroupMembers` **enforces a permission matrix before it shows the long-press menu**. If the
logged-in user is not allowed to act on the tapped member, no menu appears at all — this is built in,
not something you wire.

| Logged-in user is… | Can open the menu on… | Cannot act on |
| - | - | - |
| **Owner** (`loggedInUser.uid == group.owner`) | any member except themselves | — |
| **Admin** (`group.scope == "admin"`) | participants and moderators | other admins, the owner |
| **Moderator** (`group.scope == "moderator"`) | participants only | moderators, admins, the owner |
| **Participant** | nobody — the menu never opens | everyone |

Additionally, in the scope-change sheet a **moderator cannot assign the `admin` role** — that option is
rendered disabled.

Scope values come from `CometChatConstants`: `SCOPE_ADMIN` (`"admin"`), `SCOPE_MODERATOR`
(`"moderator"`), `SCOPE_PARTICIPANT` (`"participant"`).

> [!WARNING]
>
> **Parameter order differs between the two ownership APIs** — a common source of silent bugs:
>
> ```kotlin theme={null}
> CometChat.updateGroupMemberScope(UID, GUID, scope, listener)   // UID first
> CometChat.transferGroupOwnership(GUID, UID, listener)          // GUID first
> ```

***

## Menu Options

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> // Replace all options
> groupMembers.setOptions { context, groupMember ->
>     listOf(
>         CometChatPopupMenu.MenuItem(id = "kick", name = "Kick", onClick = { /* ... */ }),
>         CometChatPopupMenu.MenuItem(id = "ban", name = "Ban", onClick = { /* ... */ })
>     )
> }
>
> // Append to defaults
> groupMembers.setAddOptions { context, groupMember ->
>     listOf(
>         CometChatPopupMenu.MenuItem(id = "promote", name = "Promote", onClick = { /* ... */ })
>     )
> }
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     options = { context, groupMember ->
>         listOf(
>             MenuItem(id = "kick", name = "Kick", onClick = { /* ... */ }),
>             MenuItem(id = "ban", name = "Ban", onClick = { /* ... */ })
>         )
>     },
>     addOptions = { context, groupMember ->
>         listOf(MenuItem(id = "promote", name = "Promote", onClick = { /* ... */ }))
>     }
> )
> ```

***

## Common Patterns

### Minimal list — hide all chrome

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setToolbarVisibility(View.GONE)
> groupMembers.setSearchBoxVisibility(View.GONE)
> groupMembers.setSeparatorVisibility(View.GONE)
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     hideToolbar = true,
>     hideSearchBox = true,
>     hideSeparator = true
> )
> ```

### Admins and moderators only

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setGroupMembersRequestBuilder(
>     GroupMembersRequest.GroupMembersRequestBuilder(group.guid)
>         .setScopes(listOf("admin", "moderator"))
> )
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     groupMembersRequestBuilder = GroupMembersRequest.GroupMembersRequestBuilder(group.guid)
>         .setScopes(listOf("admin", "moderator"))
> )
> ```

***

## Advanced Methods

### Programmatic Selection

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> // Enable selection
> groupMembers.setSelectionMode(UIKitConstants.SelectionMode.MULTIPLE)
>
> // Select a member
> groupMembers.selectGroupMember(member, UIKitConstants.SelectionMode.MULTIPLE)
>
> // Get selected
> val selected = groupMembers.getSelectedMembers()
>
> // Or observe selection as it changes
> groupMembers.setOnSelection { members -> /* members: List<GroupMember> */ }
>
> // Clear
> groupMembers.clearSelection()
> ```

> [tab] Jetpack Compose
>
> Selection is managed via the `selectionMode` and `onSelection` parameters. The component handles selection state internally.

### ViewModel Access

```kotlin lines theme={null}
val factory = CometChatGroupMembersViewModelFactory()
val viewModel = ViewModelProvider(this, factory)
    .get(CometChatGroupMembersViewModel::class.java)
```

> [tab] Kotlin (XML Views)
>
> ```kotlin lines theme={null}
> groupMembers.setViewModel(viewModel)
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     groupMembersViewModel = viewModel
> )
> ```

See [ViewModel & Data](https://www.cometchat.com/docs/ui-kit/android/customization-viewmodel-data.md) for ListOperations, state observation, and custom repositories.

***

## Style

![](https://mintcdn.com/cometchat-22654f5b/RxKy5RgybeX-8GbH/images/1bd5a982-group_members_styling-ee7427e23be4ccf40776d8b1df1342f4.png?fit=max\&auto=format\&n=RxKy5RgybeX-8GbH\&q=85\&s=af8235ae2cada597fd116f7344cad96c)

> [tab] Kotlin (XML Views)
>
> Define a custom style in `themes.xml`:
>
> ```xml themes.xml lines theme={null}
> <style name="CustomGroupMembersAvatarStyle" parent="CometChatAvatarStyle">
>     <item name="cometchatAvatarStrokeRadius">8dp</item>
>     <item name="cometchatAvatarBackgroundColor">#FBAA75</item>
> </style>
>
> <style name="CustomGroupMembersStyle" parent="CometChatGroupMembersStyle">
>     <item name="cometchatGroupMembersAvatarStyle">@style/CustomGroupMembersAvatarStyle</item>
>     <item name="cometchatGroupMembersSeparatorColor">#F76808</item>
>     <item name="cometchatGroupMembersTitleTextColor">#F76808</item>
> </style>
>
> <style name="AppTheme" parent="CometChatTheme.DayNight">
>     <item name="cometchatGroupMembersStyle">@style/CustomGroupMembersStyle</item>
> </style>
> ```

> [tab] Jetpack Compose
>
> ```kotlin lines theme={null}
> CometChatGroupMembers(
>     group = group,
>     style = CometChatGroupMembersStyle.default().copy(
>         backgroundColor = Color(0xFFF5F5F5),
>         titleTextColor = Color(0xFF141414),
>         avatarStyle = CometChatAvatarStyle.default().copy(cornerRadius = 12.dp),
>         statusIndicatorStyle = CometChatStatusIndicatorStyle.default().copy()
>     )
> )
> ```

### Style Properties

| Property | Description |
| - | - |
| `backgroundColor` | List background color |
| `titleTextColor` | Toolbar title color |
| `searchBoxStyle` | Search box appearance |
| `itemStyle.backgroundColor` | Row background |
| `itemStyle.selectedBackgroundColor` | Selected row background |
| `itemStyle.titleTextColor` | Member name color |
| `itemStyle.subtitleTextColor` | Subtitle text color |
| `itemStyle.separatorColor` | Row separator color |
| `itemStyle.avatarStyle` | Avatar appearance |
| `itemStyle.statusIndicatorStyle` | Online/offline indicator |

See [Component Styling](https://www.cometchat.com/docs/ui-kit/android/component-styling.md) for the full reference.

***

## Next Steps

> [card] [Groups](https://www.cometchat.com/docs/ui-kit/android/groups.md)
>
> Browse and search available groups

> [card] [Conversations](https://www.cometchat.com/docs/ui-kit/android/conversations.md)
>
> Browse recent conversations

> [card] [Component Styling](https://www.cometchat.com/docs/ui-kit/android/component-styling.md)
>
> Detailed styling reference with screenshots

> [card] [ViewModel & Data](https://www.cometchat.com/docs/ui-kit/android/customization-viewmodel-data.md)
>
> Custom ViewModels, repositories, and ListOperations


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