Ongoing Call

Display CometChat iOS UI Kit ongoing calls with video, call controls, participant management, recording, screen sharing, and callbacks.

The CometChatOngoingCall component provides users with a dedicated interface for managing real-time voice or video conversations. It includes features like a video display area for video calls, call controls for mic and camera management, participant information, call status indicators, and options for call recording and screen-sharing.

AI Integration Quick Reference

{
  "component": "CometChatOngoingCall",
  "package": "CometChatUIKitSwift",
  "import": "import CometChatUIKitSwift\nimport CometChatCallsSDK",
  "description": "Displays active call interface with video, controls, and participant management",
  "inherits": "UIViewController",
  "primaryOutput": {
    "callback": "onCallEnded",
    "type": "(Call) -> Void"
  },
  "props": {
    "data": {
      "sessionID": { "type": "String", "required": true },
      "callSettingsBuilder": { "type": "CallSettingsBuilder?", "default": "nil" }
    },
    "callbacks": {
      "onCallEnded": "(Call) -> Void",
      "onError": "(CometChatException) -> Void"
    }
  },
  "events": [
    { "name": "onCallEnded", "payload": "Call", "description": "Fires when call ends" }
  ],
  "sdkListeners": [],
  "compositionExample": {
    "description": "OngoingCall is presented during an active call",
    "components": ["CometChatIncomingCall", "CometChatOutgoingCall", "CometChatOngoingCall"],
    "flow": "Call accepted → OngoingCall shown → Call ends → Returns to previous screen"
  }
}

Field	Value
Component	CometChatOngoingCall
Package	CometChatUIKitSwift
Inherits	UIViewController

---

Usage

Integration

CometChatOngoingCall is a custom view controller that offers versatility in its integration. It can be seamlessly launched via button clicks or any user-triggered action, enhancing the overall user experience and facilitating smoother interactions within the application.

Swift

// The sessionID should be received from CometChat SDK when the call was initiated or received
let sessionID = "your_session_id"

let cometChatOngoingCall = CometChatOngoingCall()
cometChatOngoingCall.set(sessionID: sessionID)
cometChatOngoingCall.modalPresentationStyle = .fullScreen
self.present(cometChatOngoingCall, animated: true)

If you are already using a navigation controller, you can use the pushViewController function instead of presenting the view controller.

Actions

Actions dictate how a component functions. They are divided into two types: Predefined and User-defined. You can override either type, allowing you to tailor the behavior of the component to fit your specific needs.

1. SetOnCallEnded

The setOnCallEnded action is typically triggered when the call ends, carrying out default actions. You can customize or override this default behavior using the following code snippet:

Swift

let cometChatOngoingCall = CometChatOngoingCall()
.setOnCallEnded { call in
  // Perform your action
}

---

Filters

Filters allow you to customize the data displayed in a list within a Component. You can filter the list based on your specific criteria for a more customized experience. Filters can be applied using RequestBuilders of the Chat SDK.

You can adjust the callSettingsBuilder in the OnGoing Call Component to customize the call. Numerous options are available to alter the builder to meet your specific needs. For additional details on CallSettingsBuilder, visit CallSettingsBuilder.

1. CallSettingsBuilder

The CallSettingsBuilder enables you to filter and customize the call list based on available parameters. This feature allows you to create more specific and targeted queries during the call.

Methods	Description	Code
setAudioModeButtonDisable	Disable the audio mode button	.setAudioModeButtonDisable(Bool)
setAvatarMode	Set the avatar mode	.setAvatarMode("")
setDefaultAudioMode	Set the default audio mode	.setDefaultAudioMode("")
setDefaultLayout	Set the default layout	.setDefaultLayout(Bool)
setDelegate	Set the calls events delegate	.setDelegate(CallsEventsDelegate)
setEnableDraggableVideoTile	Enable draggable video tile	.setEnableDraggableVideoTile(Bool)
setEnableVideoTileClick	Enable click actions on video tile	.setEnableVideoTileClick(Bool)
setEndCallButtonDisable	Disable the end call button	.setEndCallButtonDisable(Bool)
setIsAudioOnly	Set the call as audio only	.setIsAudioOnly(Bool)
setIsSingleMode	Set the call as single mode	.setIsSingleMode(Bool)
setMode	Set the mode	.setMode("NSString")
setMuteAudioButtonDisable	Disable the mute audio button	.setMuteAudioButtonDisable(Bool)
setPauseVideoButtonDisable	Disable the pause video button	.setPauseVideoButtonDisable(Bool)
setShowRecordingButton	Show or hide the recording button	.setShowRecordingButton(Bool)
setShowSwitchToVideoCall	Show or hide the switch to video call button	.setShowSwitchToVideoCall(Bool)
setStartAudioMuted	Start with audio muted	.setStartAudioMuted(Bool)
setStartRecordingOnCallStart	Start recording when the call starts	.setStartRecordingOnCallStart(Bool)
setStartVideoMuted	Start with video muted	.setStartVideoMuted(Bool)
setSwitchCameraButtonDisable	Disable the switch camera button	.setSwitchCameraButtonDisable(Bool)
setVideoContainer	Set the video container	.setVideoContainer(NSMutableDictionary)
setVideoSettings	Set the video settings	.setVideoSettings(NSMutableDictionary)

Example

In the example below, we are applying a filter to the calls:

Swift

let callBuilder = CallSettingsBuilder()
.setAudioModeButtonDisable(true)
.setEndCallButtonDisable(false)

let cometChatOngoingCall = CometChatOngoingCall()
.set(sessionId: "Your Session ID")
.set(callSettingsBuilder: callBuilder)

cometChatOngoingCall.modalPresentationStyle = .fullScreen
self.present(cometChatOngoingCall, animated: true)

Ensure to include an NSMicrophoneUsageDescription key with a descriptive string value in the app’s Info.plist.

---

Events

Events are emitted by a Component. By using events, you can extend existing functionality. Being global events, they can be applied in multiple locations and can be added or removed as needed.

Event	Description
onCallEnded	Triggers when the ongoing or outgoing call ends.

Add Listener

// View controller from your project where you want to listen to events
public class ViewController: UIViewController {

   public override func viewDidLoad() {
        super.viewDidLoad()

       // Subscribe to the listener for call events
        CometChatCallEvents.addListener("UNIQUE_ID", self as CometChatCallEventListener)
    }
}

// Listener for call events
extension ViewController: CometChatCallEventListener {

    func onCallEnded(call: Call) {
        // Handle call ended
    }
}

Emitting Call Events

// Emit this when logged in user ends a call
CometChatCallEvents.emitOnCallEnded(call: Call)

Remove Listener

public override func viewWillDisappear(_ animated: Bool) {
      // Unsubscribe from the listener
      CometChatCallEvents.removeListener("LISTENER_ID_USED_FOR_ADDING_THIS_LISTENER")
}

---

Customization

To fit your app’s design requirements, you can customize the appearance of the component. We provide exposed methods that allow you to modify the experience and behavior according to your specific needs.

Style

Using Style, you can customize the look and feel of the component in your app. These parameters typically control elements such as the color, size, shape, and fonts used within the component.

The OngoingCall component does not have any exposed Styles.

---

Functionality

These are small functional customizations that allow you to fine-tune the overall experience of the component. With these, you can change text, set custom icons, and toggle the visibility of UI elements.

Swift

let cometChatOngoingCall = CometChatOngoingCall()
.set(sessionId: "Your Session ID")
.set(callWorkFlow: .defaultCalling)

cometChatOngoingCall.modalPresentationStyle = .fullScreen
self.present(cometChatOngoingCall, animated: true)

If you are already using a navigation controller, you can use the pushViewController function instead of presenting the view controller.

Property	Description	Code
CallWorkFlow	Sets the call type to default or direct.	CallWorkFlow
Session Id	Sets the session ID for CometChatOngoingCall.	.set(sessionId: String)

Advanced

For advanced-level customization, you can set custom views to the component. This lets you tailor each aspect of the component to fit your exact needs and application aesthetics. You can create and define your own views, layouts, and UI elements and then incorporate those into the component.

The OngoingCall component does not provide additional functionalities beyond this level of customization.

---

Common Patterns

Present Ongoing Call After Acceptance

Show the ongoing call screen after a call is accepted:

Swift

func presentOngoingCall(sessionId: String) {
    let ongoingCall = CometChatOngoingCall()
    ongoingCall.set(sessionId: sessionId)
    ongoingCall.modalPresentationStyle = .fullScreen
    
    self.present(ongoingCall, animated: true)
}

Configure Call Settings for Video Call

Customize video call settings before starting:

Swift

let callSettingsBuilder = CallSettingsBuilder()
    .setIsAudioOnly(false)
    .setDefaultAudioMode("SPEAKER")
    .setShowSwitchToVideoCall(false)
    .setShowRecordingButton(true)
    .setStartVideoMuted(false)
    .setStartAudioMuted(false)

let ongoingCall = CometChatOngoingCall()
ongoingCall.set(sessionId: sessionId)
ongoingCall.set(callSettingsBuilder: callSettingsBuilder)

Audio-Only Call Configuration

Set up an audio-only call with speaker mode:

Swift

let audioCallSettings = CallSettingsBuilder()
    .setIsAudioOnly(true)
    .setDefaultAudioMode("SPEAKER")
    .setMuteAudioButtonDisable(false)
    .setEndCallButtonDisable(false)

let ongoingCall = CometChatOngoingCall()
ongoingCall.set(sessionId: sessionId)
ongoingCall.set(callSettingsBuilder: audioCallSettings)
ongoingCall.modalPresentationStyle = .fullScreen
self.present(ongoingCall, animated: true)

Listen for Call End Events

Use CometChatCallEvents to handle call end:

Swift

// Subscribe to call events
CometChatCallEvents.addListener("ongoing_call_listener", self as CometChatCallEventListener)

// In CometChatCallEventListener extension
func onCallEnded(call: Call) {
    DispatchQueue.main.async { [weak self] in
        self?.dismiss(animated: true) {
            // Show call summary
            let duration = call.duration ?? 0
            let minutes = duration / 60
            let seconds = duration % 60
            
            let alert = UIAlertController(
                title: "Call Ended",
                message: "Duration: \(minutes)m \(seconds)s",
                preferredStyle: .alert
            )
            alert.addAction(UIAlertAction(title: "OK", style: .default))
            self?.present(alert, animated: true)
        }
    }
}

---