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

# Incoming Call

> Full-screen incoming call banner with caller avatar, name, call type indicator, and accept/reject buttons.

<Accordion title="AI Integration Quick Reference">
  ```json theme={null}
  {
    "component": "CometChatIncomingCall",
    "package": "com.cometchat.chatuikit.calls.incomingcall",
    "xmlElement": "<com.cometchat.chatuikit.calls.incomingcall.CometChatIncomingCall />",
    "description": "Full-screen incoming call banner with caller avatar, name, call type indicator, and accept/reject buttons.",
    "primaryOutput": {
      "method": "setOnAcceptClick",
      "type": "OnClick"
    },
    "methods": {
      "data": {
        "setCall": {
          "type": "Call",
          "note": "Required. Sets the Call object so accept/reject actions work correctly."
        }
      },
      "callbacks": {
        "setOnAcceptClick": "OnClick",
        "setOnRejectClick": "OnClick",
        "setOnError": "OnError"
      },
      "functionality": {
        "disableSoundForCalls": { "type": "boolean", "default": "false" },
        "setCustomSoundForCalls": { "type": "@RawRes int", "default": "SDK default ringtone" }
      },
      "viewSlots": {
        "setItemView": "View — entire incoming call card",
        "setLeadingView": "View — avatar / left section",
        "setTitleView": "View — caller name / title text",
        "setSubtitleView": "View — subtitle text below name",
        "setTrailingView": "View — right section"
      },
      "advanced": {
        "setCall": "Call — sets the call object (required)",
        "setCallSettingsBuilder": "CometChatCalls.CallSettingsBuilder — custom call settings",
        "getViewModel": "IncomingCallViewModel — internal ViewModel access",
        "getBinding": "CometchatIncomingCallComponentBinding — root ViewBinding"
      },
      "style": {
        "setStyle": {
          "type": "@StyleRes int",
          "parent": "CometChatIncomingCallStyle"
        }
      }
    },
    "events": [
      {
        "name": "CometChatCallEvents.ccCallAccepted",
        "payload": "Call",
        "description": "A call was accepted"
      },
      {
        "name": "CometChatCallEvents.ccCallRejected",
        "payload": "Call",
        "description": "A call was rejected"
      }
    ],
    "sdkListeners": [
      "onIncomingCallReceived",
      "onIncomingCallCancelled"
    ]
  }
  ```
</Accordion>

## Where It Fits

`CometChatIncomingCall` is a call-handling component. It renders when the logged-in user receives an incoming voice or video call, displaying the caller's information and providing accept/reject controls. Wire it to `CometChatOngoingCallActivity` after the user accepts the call.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin CallHandlerActivity.kt lines theme={null}
    class CallHandlerActivity : AppCompatActivity() {

        private lateinit var incomingCall: CometChatIncomingCall

        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_call_handler)

            incomingCall = findViewById(R.id.incoming_call)

            // Set the Call object received from CometChat SDK
            incomingCall.setCall(call)

            incomingCall.setOnAcceptClick {
                // Navigate to ongoing call screen
            }

            incomingCall.setOnRejectClick {
                // Dismiss the incoming call screen
                finish()
            }
        }
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java CallHandlerActivity.java lines theme={null}
    public class CallHandlerActivity extends AppCompatActivity {

        private CometChatIncomingCall incomingCall;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_call_handler);

            incomingCall = findViewById(R.id.incoming_call);

            // Set the Call object received from CometChat SDK
            incomingCall.setCall(call);

            incomingCall.setOnAcceptClick(() -> {
                // Navigate to ongoing call screen
            });

            incomingCall.setOnRejectClick(() -> {
                // Dismiss the incoming call screen
                finish();
            });
        }
    }
    ```
  </Tab>
</Tabs>

## Quick Start

Add the component to your layout XML:

```xml layout_activity.xml lines theme={null}
<com.cometchat.chatuikit.calls.incomingcall.CometChatIncomingCall
        android:id="@+id/incoming_call"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
```

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-llms-scoped-indexes/k6T3T5MNYFVb-kxX/images/ef9ae7b8-Incoming_call-060686ee2b9aa89ad7c163fc8290d390.png?fit=max&auto=format&n=k6T3T5MNYFVb-kxX&q=85&s=138477b370ee1b11773f129ad988bc1b" width="360" height="720" data-path="images/ef9ae7b8-Incoming_call-060686ee2b9aa89ad7c163fc8290d390.png" />
</Frame>

Prerequisites: CometChat SDK initialized with `CometChatUIKit.init()`, a user logged in, and the `cometchat-chat-uikit-android` dependency added.

In your Activity, get a reference and set the `Call` object:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.layout_activity)

        val incomingCall = findViewById<CometChatIncomingCall>(R.id.incoming_call)
        incomingCall.setCall(call) // Required — pass the Call object from the SDK
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.layout_activity);

        CometChatIncomingCall incomingCall = findViewById(R.id.incoming_call);
        incomingCall.setCall(call); // Required — pass the Call object from the SDK
    }
    ```
  </Tab>
</Tabs>

To add programmatically in an Activity:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val incomingCall = CometChatIncomingCall(this)
        incomingCall.setCall(call)
        setContentView(incomingCall)
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        CometChatIncomingCall incomingCall = new CometChatIncomingCall(this);
        incomingCall.setCall(call);
        setContentView(incomingCall);
    }
    ```
  </Tab>
</Tabs>

Or in a Fragment:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourFragment.kt lines theme={null}
    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
        val incomingCall = CometChatIncomingCall(requireContext())
        incomingCall.setCall(call)
        return incomingCall
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java YourFragment.java lines theme={null}
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        CometChatIncomingCall incomingCall = new CometChatIncomingCall(getContext());
        incomingCall.setCall(call);
        return incomingCall;
    }
    ```
  </Tab>
</Tabs>

## Actions and Events

### Callback Methods

#### `setOnAcceptClick`

Fires when the user taps the accept button. Override this to replace the default call-accept behavior.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setOnAcceptClick {
        // Custom accept logic
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setOnAcceptClick(new OnClick() {
        @Override
        public void onClick() {
            // Custom accept logic
        }
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Replaces the default accept-button behavior. When the user taps the accept button, your custom `OnClick` lambda executes instead of the built-in call-accept logic.

#### `setOnRejectClick`

Fires when the user taps the reject button. Override this to replace the default call-reject behavior.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setOnRejectClick {
        // Custom reject logic
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setOnRejectClick(new OnClick() {
        @Override
        public void onClick() {
            // Custom reject logic
        }
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Replaces the default reject-button behavior. When the user taps the reject button, your custom `OnClick` lambda executes instead of the built-in call-decline logic.

#### `setOnError`

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

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setOnError { cometchatException ->
        // Handle error
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setOnError(cometchatException -> {
        // Handle error
    });
    ```
  </Tab>
</Tabs>

> **What this does:** Registers an error listener. If the component encounters an error, your callback receives the `CometChatException` so you can handle it with custom logic.

* **Verify**: After setting an action callback, trigger the corresponding user interaction (tap accept, tap reject) and confirm your custom logic executes instead of the default behavior.

### Global UI Events (CometChatCallEvents)

`CometChatCallEvents` emits events subscribable from anywhere in the application. Add a listener and remove it when no longer needed.

| Event | Fires when | Payload |
| - | - | - |
| `ccCallAccepted` | A call is accepted | `Call` |
| `ccCallRejected` | A call is rejected | `Call` |
| `ccCallEnded` | A call is ended | `Call` |
| `ccOutgoingCall` | An outgoing call is initiated | `Call` |

<Tabs>
  <Tab title="Kotlin">
    ```kotlin Add Listener lines theme={null}
    CometChatCallEvents.addListener("LISTENER_TAG", object : CometChatCallEvents() {
        override fun ccCallAccepted(call: Call?) {
            super.ccCallAccepted(call)
        }

        override fun ccCallRejected(call: Call?) {
            super.ccCallRejected(call)
        }

        override fun ccCallEnded(call: Call?) {
            super.ccCallEnded(call)
        }
    })
    ```

    Remove Listener

    ```
    CometChatCallEvents.removeListener("LISTENER_TAG")
    ```
  </Tab>

  <Tab title="Java">
    ```java Add Listener lines theme={null}
    CometChatCallEvents.addListener("LISTENER_TAG", new CometChatCallEvents() {
        @Override
        public void ccCallAccepted(Call call) {
            super.ccCallAccepted(call);
        }

        @Override
        public void ccCallRejected(Call call) {
            super.ccCallRejected(call);
        }

        @Override
        public void ccCallEnded(Call call) {
            super.ccCallEnded(call);
        }
    });
    ```

    Remove Listener

    ```
    CometChatCallEvents.removeListener("LISTENER_TAG");
    ```
  </Tab>
</Tabs>

### SDK Events

The component listens to these SDK events internally. No manual attachment needed unless additional side effects are required.

| SDK Listener | Internal behavior |
| - | - |
| `onIncomingCallReceived` | Triggers the incoming call screen display |
| `onIncomingCallCancelled` | Dismisses the incoming call screen |

> Automatic: call state changes update the component in real time.

## Functionality

Small functional customizations such as toggling call sounds and setting custom ringtones.

| Method | Description | Code |
| - | - | - |
| `disableSoundForCalls` | Disables the ringtone for incoming calls | `.disableSoundForCalls(true);` |
| `setCustomSoundForCalls` | Sets a custom ringtone from `res/raw` | `.setCustomSoundForCalls(R.raw.custom_ringtone);` |

* **Verify**: After calling `disableSoundForCalls(true)`, confirm no ringtone plays on incoming calls. After calling `setCustomSoundForCalls`, confirm the custom sound plays.

## Custom View Slots

Each slot replaces a section of the default UI. IncomingCall view slots accept plain `View` objects (not `ViewHolderListener`).

| Slot | Method | Replaces |
| - | - | - |
| Item view | `setItemView(View)` | Entire incoming call card |
| Leading view | `setLeadingView(View)` | Avatar / left section |
| Title view | `setTitleView(View)` | Caller name / title text |
| Subtitle view | `setSubtitleView(View)` | Subtitle text below name |
| Trailing view | `setTrailingView(View)` | Right section |

### `setItemView`

Replace the entire incoming call card with a custom view.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setItemView(view)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setItemView(view);
    ```
  </Tab>
</Tabs>

> **What this does:** Replaces the entire default incoming call card with your custom `View`. The custom view is responsible for rendering all caller information and call controls.

### `setLeadingView`

Replace the avatar / left section.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setLeadingView(view)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setLeadingView(view);
    ```
  </Tab>
</Tabs>

> **What this does:** Replaces the default leading (left) area of the incoming call screen with your custom `View`.

Example:

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-llms-scoped-indexes/MwUD0WbYp0FmjMsd/images/d6565a37-incoming_call_leading_view-1a7b3012972e5f6e17f433a02a49d8c5.png?fit=max&auto=format&n=MwUD0WbYp0FmjMsd&q=85&s=1ab06cab49704ab34ec1b0ed4c7d5fe9" width="2560" height="720" data-path="images/d6565a37-incoming_call_leading_view-1a7b3012972e5f6e17f433a02a49d8c5.png" />
</Frame>

```xml leading_view.xml lines theme={null}
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="@dimen/cometchat_45dp"
    android:layout_height="@dimen/cometchat_45dp"
    android:orientation="vertical">

    <com.cometchat.chatuikit.shared.views.avatar.CometChatAvatar
        android:id="@+id/avatar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</RelativeLayout>
```

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    val leadingView: View = LayoutInflater.from(this).inflate(R.layout.leading_view, null)
    val avatar = leadingView.findViewById<CometChatAvatar>(R.id.avatar)
    val callUser = call.callInitiator as User
    avatar.setAvatar(callUser.name, callUser.avatar)
    leadingView.layoutParams = LinearLayout.LayoutParams(
        Utils.convertDpToPx(this, 45),
        Utils.convertDpToPx(this, 45)
    )
    cometchatIncomingCall.setTrailingView(null)
    cometchatIncomingCall.setLeadingView(leadingView)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    View leadingView = LayoutInflater.from(this).inflate(R.layout.leading_view, null);
    CometChatAvatar avatar = leadingView.findViewById(R.id.avatar);
    User callUser = (User) call.getCallInitiator();
    avatar.setAvatar(callUser.getName(), callUser.getAvatar());
    leadingView.setLayoutParams(new LinearLayout.LayoutParams(
        Utils.convertDpToPx(this, 45),
        Utils.convertDpToPx(this, 45)
    ));
    cometchatIncomingCall.setTrailingView(null);
    cometchatIncomingCall.setLeadingView(leadingView);
    ```
  </Tab>
</Tabs>

### `setTitleView`

Replace the caller name / title text.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setTitleView(view)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setTitleView(view);
    ```
  </Tab>
</Tabs>

> **What this does:** Replaces the default title area of the incoming call screen with your custom `View`.

Example:

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-llms-scoped-indexes/cTCXebw8IhR7IiJw/images/41950607-incoming_call_title_view-198db15285a220503d51f46ea45948ba.png?fit=max&auto=format&n=cTCXebw8IhR7IiJw&q=85&s=8f1509e260cd8ba77cc32d3b087d005f" width="2560" height="720" data-path="images/41950607-incoming_call_title_view-198db15285a220503d51f46ea45948ba.png" />
</Frame>

```xml custom_title_view.xml lines theme={null}
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/user_layout"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:gravity="center_vertical"
    android:orientation="horizontal">

    <TextView
        android:id="@+id/title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="teacher"
        android:textAppearance="?attr/cometchatTextAppearanceHeading4Medium"
        android:textColor="?attr/cometchatTextColorPrimary" />

    <View
        android:id="@+id/role"
        android:layout_width="50dp"
        android:layout_height="15dp"
        android:layout_marginStart="@dimen/cometchat_16dp"
        android:background="@drawable/important" />
</LinearLayout>
```

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    val titleView: View = LayoutInflater.from(this).inflate(R.layout.custom_title_view, null)
    val title = titleView.findViewById<TextView>(R.id.title)
    title.text = "George Allen"
    titleView.layoutParams = LinearLayout.LayoutParams(
        ViewGroup.LayoutParams.WRAP_CONTENT,
        ViewGroup.LayoutParams.WRAP_CONTENT
    )
    cometchatIncomingCall.setTitleView(titleView)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    View titleView = LayoutInflater.from(this).inflate(R.layout.custom_title_view, null);
    TextView title = titleView.findViewById(R.id.title);
    title.setText("George Allen");
    titleView.setLayoutParams(new LinearLayout.LayoutParams(
        ViewGroup.LayoutParams.WRAP_CONTENT,
        ViewGroup.LayoutParams.WRAP_CONTENT
    ));
    cometchatIncomingCall.setTitleView(titleView);
    ```
  </Tab>
</Tabs>

### `setSubtitleView`

Replace the subtitle text below the caller's name.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setSubtitleView(view)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setSubtitleView(view);
    ```
  </Tab>
</Tabs>

> **What this does:** Replaces the default subtitle area of the incoming call screen with your custom `View`. Use this to show additional information below the caller's name.

### `setTrailingView`

Replace the right section of the incoming call card.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    cometchatIncomingCall.setTrailingView(view)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    cometchatIncomingCall.setTrailingView(view);
    ```
  </Tab>
</Tabs>

> **What this does:** Replaces the default trailing (right) area of the incoming call screen with your custom `View`.

Example:

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-llms-scoped-indexes/JjWlPukYmAPwZawH/images/3cff00d3-incoming_call_trailing_view-ac387445c4c331cad3b5c3d571cc4f9a.png?fit=max&auto=format&n=JjWlPukYmAPwZawH&q=85&s=51a9baa7df9e872175b215b38dda2cb8" width="2560" height="720" data-path="images/3cff00d3-incoming_call_trailing_view-ac387445c4c331cad3b5c3d571cc4f9a.png" />
</Frame>

```xml trailing_view.xml lines theme={null}
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="@dimen/cometchat_45dp"
    android:layout_height="@dimen/cometchat_45dp"
    android:orientation="vertical">

    <com.cometchat.chatuikit.shared.views.avatar.CometChatAvatar
        android:id="@+id/avatar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</RelativeLayout>
```

<Tabs>
  <Tab title="Kotlin">
    ```kotlin YourActivity.kt lines theme={null}
    val trailingView: View = LayoutInflater.from(this).inflate(R.layout.trailing_view, null)
    val avatar = trailingView.findViewById<CometChatAvatar>(R.id.avatar)
    val callUser = call.callInitiator as User
    if (callUser.tags.contains("pro_user")) {
        avatar.setAvatar(ResourcesCompat.getDrawable(resources, R.drawable.pro_user, null)!!)
    }
    avatar.setAvatar(callUser.name, callUser.avatar)
    trailingView.layoutParams = LinearLayout.LayoutParams(
        Utils.convertDpToPx(this, 45),
        Utils.convertDpToPx(this, 45)
    )
    cometchatIncomingCall.setTrailingView(trailingView)
    ```
  </Tab>

  <Tab title="Java">
    ```java YourActivity.java lines theme={null}
    View trailingView = LayoutInflater.from(this).inflate(R.layout.trailing_view, null);
    CometChatAvatar avatar = trailingView.findViewById(R.id.avatar);
    User callUser = (User) call.getCallInitiator();
    if (callUser.getTags().contains("pro_user")) {
        avatar.setAvatar(ResourcesCompat.getDrawable(getResources(), R.drawable.pro_user, null));
    }
    avatar.setAvatar(callUser.getName(), callUser.getAvatar());
    trailingView.setLayoutParams(new LinearLayout.LayoutParams(
        Utils.convertDpToPx(this, 45),
        Utils.convertDpToPx(this, 45)
    ));
    cometchatIncomingCall.setTrailingView(trailingView);
    ```
  </Tab>
</Tabs>

* **Verify**: After setting any custom view slot, confirm the custom view renders in the correct position on the incoming call screen and displays the expected caller information.

## Common Patterns

### Silent incoming call

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    cometchatIncomingCall.disableSoundForCalls(true)
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    cometchatIncomingCall.disableSoundForCalls(true);
    ```
  </Tab>
</Tabs>

### Custom ringtone

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    cometchatIncomingCall.setCustomSoundForCalls(R.raw.my_ringtone)
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    cometchatIncomingCall.setCustomSoundForCalls(R.raw.my_ringtone);
    ```
  </Tab>
</Tabs>

### Custom call settings

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    val callSettingsBuilder = CometChatCalls.CallSettingsBuilder(this, true)
        .setDefaultAudioMode("SPEAKER")
    cometchatIncomingCall.setCallSettingsBuilder(callSettingsBuilder)
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatCalls.CallSettingsBuilder callSettingsBuilder = new CometChatCalls.CallSettingsBuilder(this, true)
        .setDefaultAudioMode("SPEAKER");
    cometchatIncomingCall.setCallSettingsBuilder(callSettingsBuilder);
    ```
  </Tab>
</Tabs>

### Override accept to add logging

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    cometchatIncomingCall.setOnAcceptClick {
        Log.d("IncomingCall", "Call accepted by user")
        // Proceed with default accept via ViewModel
        cometchatIncomingCall.viewModel.acceptCall(call)
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    cometchatIncomingCall.setOnAcceptClick(() -> {
        Log.d("IncomingCall", "Call accepted by user");
        // Proceed with default accept via ViewModel
        cometchatIncomingCall.getViewModel().acceptCall(call);
    });
    ```
  </Tab>
</Tabs>

## Advanced Methods

### `setCall`

Sets the `Call` object for the incoming call screen. Required for accept/reject actions to work correctly. The component extracts the caller's name, avatar, and call type from this object.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    cometchatIncomingCall.setCall(call)
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    cometchatIncomingCall.setCall(call);
    ```
  </Tab>
</Tabs>

### `setCallSettingsBuilder`

Provides a custom `CallSettingsBuilder` to configure call settings (audio mode, video resolution, etc.) used when the call is accepted.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    val builder = CometChatCalls.CallSettingsBuilder(this, true)
    cometchatIncomingCall.setCallSettingsBuilder(builder)
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    CometChatCalls.CallSettingsBuilder builder = new CometChatCalls.CallSettingsBuilder(this, true);
    cometchatIncomingCall.setCallSettingsBuilder(builder);
    ```
  </Tab>
</Tabs>

### Internal Access

These methods provide direct access to internal components for advanced use cases.

| Method | Returns | Description |
| - | - | - |
| `getViewModel()` | `IncomingCallViewModel` | The ViewModel managing call state and actions |
| `getBinding()` | `CometchatIncomingCallComponentBinding` | The ViewBinding for the component's root layout |

> Use these only when the standard API is insufficient. Directly manipulating the ViewModel or binding may conflict with the component's internal state management.

## Style

The component uses XML theme styles. Define a custom style with parent `CometChatIncomingCallStyle` in `themes.xml`, then apply with `setStyle()`.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-llms-scoped-indexes/MwUD0WbYp0FmjMsd/images/d771544a-incoming_call_styled-4a37ea9ee6fd91529ac0dc12725739a7.png?fit=max&auto=format&n=MwUD0WbYp0FmjMsd&q=85&s=7654ac473af58c406d7d406cae324646" width="4524" height="3200" data-path="images/d771544a-incoming_call_styled-4a37ea9ee6fd91529ac0dc12725739a7.png" />
</Frame>

```xml themes.xml lines theme={null}
<style name="CustomAvatarStyle" parent="CometChatAvatarStyle">
    <item name="cometchatAvatarStrokeRadius">8dp</item>
    <item name="cometchatAvatarBackgroundColor">#FBAA75</item>
</style>

<style name="CustomIncomingCallStyle" parent="CometChatIncomingCallStyle">
    <item name="cometchatIncomingCallBackgroundColor">#AA9EE8</item>
    <item name="cometchatIncomingCallIconTint">?attr/cometchatPrimaryColor</item>
    <item name="cometchatIncomingCallRejectButtonBackgroundColor">?attr/cometchatColorWhite</item>
    <item name="cometchatIncomingCallAcceptButtonBackgroundColor">?attr/cometchatPrimaryColor</item>
    <item name="cometchatIncomingCallRejectButtonTextColor">?attr/cometchatErrorColor</item>
    <item name="cometchatIncomingCallAcceptButtonTextColor">?attr/cometchatColorWhite</item>
    <item name="cometchatIncomingCallRejectButtonTextAppearance">?attr/cometchatTextAppearanceButtonMedium</item>
    <item name="cometchatIncomingCallAcceptButtonTextAppearance">?attr/cometchatTextAppearanceButtonMedium</item>
    <item name="cometchatIncomingCallAvatarStyle">@style/CustomAvatarStyle</item>
</style>
```

<Tabs>
  <Tab title="Kotlin">
    ```kotlin lines theme={null}
    cometchatIncomingCall.setStyle(R.style.CustomIncomingCallStyle)
    ```
  </Tab>

  <Tab title="Java">
    ```java lines theme={null}
    cometchatIncomingCall.setStyle(R.style.CustomIncomingCallStyle);
    ```
  </Tab>
</Tabs>

To know more such attributes, visit the [attributes file](https://github.com/cometchat/cometchat-uikit-android/blob/v5/chatuikit/src/main/res/values/attr_cometchat_incoming_call.xml).

### Programmatic Style Properties

In addition to XML theme styles, the component exposes programmatic setters for fine-grained control:

| Method | Type | Description |
| - | - | - |
| `setBackgroundColor` | `@ColorInt int` | Background color of the component |
| `setTitleTextColor` | `@ColorInt int` | Text color for the caller name |
| `setTitleTextAppearance` | `@StyleRes int` | Text appearance for the caller name |
| `setSubtitleTextColor` | `@ColorInt int` | Text color for the call type subtitle |
| `setSubtitleTextAppearance` | `@StyleRes int` | Text appearance for the call type subtitle |
| `setIconTint` | `@ColorInt int` | Tint color for the call type icon |
| `setVoiceCallIcon` | `Drawable` | Custom icon for voice calls |
| `setVideoCallIcon` | `Drawable` | Custom icon for video calls |
| `setAcceptCallButtonBackgroundColor` | `@ColorInt int` | Background color for the accept button |
| `setRejectCallButtonBackgroundColor` | `@ColorInt int` | Background color for the reject button |
| `setAcceptButtonTextColor` | `@ColorInt int` | Text color for the accept button |
| `setRejectButtonTextColor` | `@ColorInt int` | Text color for the reject button |
| `setAcceptButtonTextAppearance` | `@StyleRes int` | Text appearance for the accept button |
| `setRejectButtonTextAppearance` | `@StyleRes int` | Text appearance for the reject button |
| `setCornerRadius` | `@Dimension int` | Corner radius of the component card |
| `setStrokeWidth` | `@Dimension int` | Stroke width of the component border |
| `setStrokeColor` | `@ColorInt int` | Stroke color of the component border |
| `setAvatarStyle` | `@StyleRes int` | Style for the caller avatar |

* **Verify**: The incoming call screen displays with a purple background (`#AA9EE8`), custom button colors, and avatars with rounded corners (8dp radius) and an orange background (`#FBAA75`).

## Customization Matrix

| What to change | Where | Property/API | Example |
| - | - | - | - |
| Background color | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallBackgroundColor` | `<item name="cometchatIncomingCallBackgroundColor">#AA9EE8</item>` |
| Icon tint | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallIconTint` | `<item name="cometchatIncomingCallIconTint">?attr/cometchatPrimaryColor</item>` |
| Reject button background | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallRejectButtonBackgroundColor` | `<item name="cometchatIncomingCallRejectButtonBackgroundColor">?attr/cometchatColorWhite</item>` |
| Accept button background | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallAcceptButtonBackgroundColor` | `<item name="cometchatIncomingCallAcceptButtonBackgroundColor">?attr/cometchatPrimaryColor</item>` |
| Reject button text color | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallRejectButtonTextColor` | `<item name="cometchatIncomingCallRejectButtonTextColor">?attr/cometchatErrorColor</item>` |
| Accept button text color | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallAcceptButtonTextColor` | `<item name="cometchatIncomingCallAcceptButtonTextColor">?attr/cometchatColorWhite</item>` |
| Reject button text appearance | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallRejectButtonTextAppearance` | `<item name="cometchatIncomingCallRejectButtonTextAppearance">?attr/cometchatTextAppearanceButtonMedium</item>` |
| Accept button text appearance | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallAcceptButtonTextAppearance` | `<item name="cometchatIncomingCallAcceptButtonTextAppearance">?attr/cometchatTextAppearanceButtonMedium</item>` |
| Avatar style | `themes.xml` | `CometChatIncomingCallStyle` with `cometchatIncomingCallAvatarStyle` | `<item name="cometchatIncomingCallAvatarStyle">@style/CustomAvatarStyle</item>` |
| Apply a custom style | Activity/Fragment | `setStyle(int styleRes)` | `cometchatIncomingCall.setStyle(R.style.CustomIncomingCallStyle);` |
| Call object | Activity/Fragment | `setCall(Call)` | `.setCall(call)` |
| Custom call sound | Activity/Fragment | `setCustomSoundForCalls(@RawRes int)` | `.setCustomSoundForCalls(R.raw.custom_ringtone);` |
| Disable call sound | Activity/Fragment | `disableSoundForCalls(boolean)` | `.disableSoundForCalls(true)` |
| Call settings | Activity/Fragment | `setCallSettingsBuilder(CallSettingsBuilder)` | `.setCallSettingsBuilder(builder)` |
| Accept button action | Activity/Fragment | `setOnAcceptClick(OnClick)` | See `setOnAcceptClick` code above |
| Reject button action | Activity/Fragment | `setOnRejectClick(OnClick)` | See `setOnRejectClick` code above |
| Error handler | Activity/Fragment | `setOnError(OnError)` | See `setOnError` code above |
| Entire call card view | Activity/Fragment | `setItemView(View)` | `cometchatIncomingCall.setItemView(view);` |
| Leading view (avatar area) | Activity/Fragment | `setLeadingView(View)` | See `setLeadingView` code above |
| Title view (caller name) | Activity/Fragment | `setTitleView(View)` | See `setTitleView` code above |
| Subtitle view | Activity/Fragment | `setSubtitleView(View)` | `cometchatIncomingCall.setSubtitleView(view);` |
| Trailing view | Activity/Fragment | `setTrailingView(View)` | See `setTrailingView` code above |

## Next Steps

<CardGroup cols={2}>
  <Card title="Outgoing Call" icon="phone-arrow-up-right" href="/ui-kit/android/v5/outgoing-call">
    Outgoing call screen with end-call control
  </Card>

  <Card title="Call Buttons" icon="phone" href="/ui-kit/android/v5/call-buttons">
    Voice and video call initiation buttons
  </Card>

  <Card title="Call Logs" icon="clock-rotate-left" href="/ui-kit/android/v5/call-logs">
    View call history
  </Card>

  <Card title="Conversations" icon="comments" href="/ui-kit/android/v5/conversations">
    Browse recent conversations
  </Card>
</CardGroup>


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