Ongoing Call - CometChat Docs

CometChatOngoingCall renders the active call: the Calls SDK’s video tiles and controls (mute, camera, switch camera, end). CometChatOngoingCallActivity hosts it full-screen, supports picture-in-picture, and is where an answered incoming call ends up: your app’s answer activity opens it with the answered call, and it joins the session.

Where It Fits

Every call ends up here:

Path	How the screen opens
Incoming call answered	The Push SDK starts your answer activity (`PNConfiguration.setAnswerActivity`), which builds the call with `CallRingingUtils.buildIncomingCall` and calls `CometChatOngoingCallActivity.launchOngoingCallActivity(context, call)`
Outgoing call answered	The Outgoing Call screen hands over once the callee joins: XML Views embed `CometChatOngoingCall` in the same activity, Compose launches `CometChatOngoingCallActivity`
Group call / meeting	Call Buttons send a meeting message; tapping it launches the activity with `CallWorkFlow.MEETING`
Your own flow	`CometChatOngoingCallActivity.launchOngoingCallActivity(context, sessionId, callType)` or the component directly

Kotlin (XML Views)
Jetpack Compose

import com.cometchat.uikit.kotlin.presentation.ongoingcall.ui.CometChatOngoingCallActivity

CometChatOngoingCallActivity.launchOngoingCallActivity(
    context = this,
    sessionId = sessionId,
    callType = CometChatConstants.CALL_TYPE_VIDEO
)

import com.cometchat.uikit.compose.presentation.ongoingcall.ui.CometChatOngoingCallActivity

CometChatOngoingCallActivity.launchOngoingCallActivity(
    context = context,
    sessionId = sessionId,
    callType = CometChatConstants.CALL_TYPE_VIDEO
)

Quick Start

From your answer activity (incoming calls)

The Push SDK opens your answer activity with the answered call in its intent. Turn it into a UI Kit Call and launch this screen; it asks for the microphone (and the camera for a video call) and joins:

val incoming = CallBundles.getCall(intent) ?: return finish()
val call = CallRingingUtils.buildIncomingCall(
    sessionId = incoming.sessionId,
    callType = if (incoming.isVideo) CometChatConstants.CALL_TYPE_VIDEO else CometChatConstants.CALL_TYPE_AUDIO,
    receiverType = incoming.receiverType,
    receiverUid = incoming.receiverUid,
    callerUid = incoming.callerUid,
    callerName = incoming.callerName,
    callerAvatarUrl = incoming.callerAvatarUrl,
    initiatedAtMs = incoming.initiatedAtMs,
    conversationId = incoming.conversationId
)
CometChatOngoingCallActivity.launchOngoingCallActivity(this, call)
finish()

See Calling Integration for the full answer activity and its manifest entry.

Launching it yourself

Kotlin (XML Views)
Jetpack Compose

CometChatOngoingCallActivity.launchOngoingCallActivity(
    context = this,
    sessionId = sessionId,
    callType = CometChatConstants.CALL_TYPE_AUDIO,
    callWorkFlow = CallWorkFlow.DEFAULT,          // MEETING for a group call
    callSettingsBuilder = null,                  // or your SessionSettingsBuilder
    style = null
)

CometChatOngoingCallActivity.launchOngoingCallActivity(
    context = context,
    sessionId = sessionId,
    callType = CometChatConstants.CALL_TYPE_AUDIO,
    callWorkFlow = CallWorkFlow.DEFAULT,          // MEETING for a group call
    callSettingsBuilder = null,                  // or your SessionSettingsBuilder
    style = null
)

Embedding the component

Use the component directly when you host the call in your own screen.

Kotlin (XML Views)
Jetpack Compose

activity_call.xml

<com.cometchat.uikit.kotlin.presentation.ongoingcall.ui.CometChatOngoingCall
    android:id="@+id/ongoing_call"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

val ongoingCall = findViewById<CometChatOngoingCall>(R.id.ongoing_call)
ongoingCall.setSessionId(sessionId)
ongoingCall.setCallType(CometChatConstants.CALL_TYPE_VIDEO)
ongoingCall.setCallWorkFlow(CallWorkFlow.DEFAULT)
ongoingCall.setSessionSettingsBuilder(CometChatCalls.SessionSettingsBuilder())
ongoingCall.startCall()

CometChatOngoingCall(
    sessionId = sessionId,
    callType = CometChatConstants.CALL_TYPE_VIDEO,
    callWorkFlow = CallWorkFlow.DEFAULT,
    onCallEnded = { finish() },
    onError = { e -> Log.e("Call", e.message ?: "") }
)

Prerequisites: CometChatUIKit.init() with setEnableCalling(true), a user logged in, and com.cometchat:calls-sdk-android in your app’s dependencies (the UI Kit does not bundle it). There is nothing to declare for permissions: RECORD_AUDIO and CAMERA merge into your manifest from the SDKs and are requested at runtime.

Actions and Events

Callback Methods

`onCallEnded`

Fires when this device has left the session: the user tapped End, the other side hung up, the session timed out, or the connection closed. Close the screen here.

Kotlin (XML Views)
Jetpack Compose

The hosting CometChatOngoingCallActivity finishes itself, and an embedded component finishes its host activity on CallEnded and SessionTimeout too. Observe the ViewModel’s events only for your own clean-up:

lifecycleScope.launch {
    ongoingCall.getViewModel()?.events?.collect { event ->
        if (event is OngoingCallEvent.CallEnded) finish()
    }
}

CometChatOngoingCall(
    sessionId = sessionId,
    callType = callType,
    onCallEnded = { finish() }
)

`onError`

Fires when the session could not be joined (bad session id, no network, the Calls SDK not logged in). A denied microphone does not fire it: the call joins muted.

Kotlin (XML Views)
Jetpack Compose

ongoingCall.setOnError { exception ->
    Log.e("OngoingCall", "Error: ${exception.message}")
}

CometChatOngoingCall(
    sessionId = sessionId,
    callType = callType,
    onError = { exception ->
        Log.e("OngoingCall", "Error: ${exception.message}")
    }
)

ViewModel Events (`OngoingCallEvent`)

Event	Fires when
`CallEnded`	This device left the session (End tapped, remote hang-up, connection closed)
`SessionTimeout`	The session timed out
`UserJoined(userId, isCurrentUser)`	A participant joined
`UserLeft(userId)`	A participant left
`Error(exception)`	Joining the session failed

Global UI Events (`CometChatEvents.callEvents`)

Event	Fires when	Payload
`CometChatCallEvent.CallEnded`	This device hangs up a 1:1 call (End, or the call screen’s own leave button) that the screen was opened with, as your answer activity does with `launchOngoingCallActivity(context, call)`. Not emitted when the other side hangs up, when the connection closes, or for a screen opened with a session id	`Call`

SDK Events (Real-Time, Automatic)

Calls SDK listener	Internal behavior
`SessionStatusListener.onSessionLeft`	Local clean-up, `CallEnded`
`SessionStatusListener.onSessionTimedOut`	`SessionTimeout`, screen ends
`SessionStatusListener.onConnectionClosed`	Screen ends, `CallEnded` (a join whose connection closed without a leave event)
`ParticipantEventListener.onParticipantJoined / Left`	`UserJoined` / `UserLeft`
`ButtonClickListener.onLeaveSessionButtonClicked`	The Calls SDK has already left; local clean-up only

Functionality

Method (Kotlin XML)	Compose Parameter	Description
`setSessionId(id)`	`sessionId`	Session to join (required)
`setCallType(type)`	`callType`	`CometChatConstants.CALL_TYPE_AUDIO` or `CALL_TYPE_VIDEO`; sets the session type
`setCallWorkFlow(flow)`	`callWorkFlow`	`DEFAULT` for 1:1 calls, `MEETING` for group calls
`setSessionSettingsBuilder(builder)`	`callSettingsBuilder`	Calls SDK `SessionSettingsBuilder` for layout, controls, audio mode. The component sets the session type on it
`startCall()`	automatic	Joins the session
`setOnError { }`	`onError`	Error callback
`setStyle(style)`	`style`	Container styling
`getViewModel()`	`viewModel`	Access to state and events

Hang-up and clean-up

Hanging up leaves the Calls SDK session with CallSession.leave(); nothing is sent to the Chat SDK. For a 1:1 call (DEFAULT) the UI Kit also clears its active-call state and, when the screen was opened with a Call, emits CometChatCallEvent.CallEnded on CometChatEvents.callEvents. A hang-up by the other side clears the same state but emits no global event; observe the component’s CallEnded instead. For a MEETING it only leaves and clears the meeting flag; the conference continues for the others. CometChatOngoingCallActivity leaves the session when it is destroyed, but only its own session: after answering a second call over a live one, the Push SDK opens your answer activity again, which hands the new call to CometChatOngoingCallActivity. That intent arrives in onNewIntent (SINGLE_TOP); the activity starts a fresh instance for the new session and finishes itself, and the old screen’s clean-up does not touch the new session.

Picture-in-Picture

CometChatOngoingCallActivity declares supportsPictureInPicture and enters PiP when the user leaves the screen during a call; the Calls SDK switches to its PiP layout (enablePictureInPictureLayout / disablePictureInPictureLayout). Dismissing the PiP window ends the call. Nothing to configure.

Second call during a call

Handled by the Push SDK: the new call rings over the live one with “Answering ends your current call”. Answer leaves the live session, prepares the new one and opens your answer activity, which opens CometChatOngoingCallActivity for it; Decline sends busy and keeps the current call.

Style

Kotlin (XML Views)
Jetpack Compose

val style = CometChatOngoingCallStyle.Builder(this)
    .setBackgroundColor(Color.parseColor("#141414"))
    .setProgressIndicatorColor(Color.parseColor("#6852D6"))
    .setCornerRadius(0f)
    .build()

CometChatOngoingCallActivity.launchOngoingCallActivity(
    context = this,
    sessionId = sessionId,
    callType = callType,
    style = style
)

CometChatOngoingCall(
    sessionId = sessionId,
    callType = callType,
    style = CometChatOngoingCallStyle.default().copy(
        backgroundColor = Color(0xFF141414),
        progressIndicatorColor = Color(0xFF6852D6)
    )
)

The style covers the container around the call surface (background, progress indicator while joining, corner radius, stroke). The call UI itself (tiles, buttons, layouts) is the Calls SDK’s and is configured through its SessionSettingsBuilder; see Session Settings and Call Layouts. See Component Styling for the full reference.

Next Steps

Calling Integration

Enable calling and push ringing

Outgoing Call

Calling and ringing states before the answer

Call Logs

View call history

Push Ringing

How incoming calls ring

​Where It Fits

​Quick Start

​From your answer activity (incoming calls)

​Launching it yourself

​Embedding the component

​Actions and Events

​Callback Methods

​onCallEnded

​onError

​ViewModel Events (OngoingCallEvent)

​Global UI Events (CometChatEvents.callEvents)

​SDK Events (Real-Time, Automatic)

​Functionality

​Hang-up and clean-up

​Picture-in-Picture

​Second call during a call

​Style

​Next Steps