VoIP Calling

Quick Reference for AI Agents & Developers

import { Platform } from 'react-native';
import { CometChatNotifications } from '@cometchat/chat-sdk-react-native';

const { PushPlatforms } = CometChatNotifications;

// Register AFTER login. iOS VoIP is its OWN platform, distinct from ordinary iOS push.
// providerId is the Provider ID from Dashboard → Notifications.
await CometChatNotifications.registerPushToken(
  token,
  Platform.OS === 'ios' ? PushPlatforms.APNS_REACT_NATIVE_VOIP
                        : PushPlatforms.FCM_REACT_NATIVE_ANDROID,
  PROVIDER_ID,
);

await CometChatNotifications.unregisterPushToken();   // on logout

Not code-only. iOS needs a VoIP .p12 certificate + a native PushKit/CallKit module; Android needs Firebase + a self-managed ConnectionService
On iOS you must call reportNewIncomingCall for every VoIP push — the OS terminates an app that does not
Skipping the logout unregister leaves the next user on that device receiving the previous user’s calls
Prerequisite → Ringing covers the foreground half

Implement VoIP push notifications to receive incoming calls even when your app is in the background or terminated. This requires platform-specific configuration for iOS CallKit and Android ConnectionService.

iOS VoIP Configuration

Enable VoIP Push Notifications

In Xcode, select your target
Go to Signing & Capabilities
Add Push Notifications capability
Add Background Modes capability
Enable Voice over IP

Create VoIP Certificate

Go to Apple Developer Portal
Navigate to Certificates, Identifiers & Profiles
Create a new VoIP Services Certificate
Download and install the certificate
Export the .p12 file for your server

Configure CometChat Dashboard

Go to your CometChat Dashboard
Navigate to Notifications > Push Notifications
Upload your VoIP certificate (.p12 file)
Configure the certificate password

Implement CallKit

Create a native module to handle CallKit:

// ios/CallKitManager.swift
import CallKit
import PushKit

@objc(CallKitManager)
class CallKitManager: NSObject, CXProviderDelegate, PKPushRegistryDelegate {
    
    static let shared = CallKitManager()
    
    private let provider: CXProvider
    private let callController = CXCallController()
    private var voipRegistry: PKPushRegistry?
    
    override init() {
        let config = CXProviderConfiguration()
        config.supportsVideo = true
        config.maximumCallsPerCallGroup = 1
        config.supportedHandleTypes = [.generic]
        
        provider = CXProvider(configuration: config)
        super.init()
        provider.setDelegate(self, queue: nil)
    }
    
    @objc func registerForVoIPPushes() {
        voipRegistry = PKPushRegistry(queue: .main)
        voipRegistry?.delegate = self
        voipRegistry?.desiredPushTypes = [.voIP]
    }
    
    // PKPushRegistryDelegate
    func pushRegistry(_ registry: PKPushRegistry, didUpdate pushCredentials: PKPushCredentials, for type: PKPushType) {
        let token = pushCredentials.token.map { String(format: "%02x", $0) }.joined()
        // Send token to CometChat
        NotificationCenter.default.post(
            name: NSNotification.Name("VoIPTokenReceived"),
            object: nil,
            userInfo: ["token": token]
        )
    }
    
    func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith payload: PKPushPayload, for type: PKPushType, completion: @escaping () -> Void) {
        guard type == .voIP else { return }
        
        let callerId = payload.dictionaryPayload["callerId"] as? String ?? "Unknown"
        let callerName = payload.dictionaryPayload["callerName"] as? String ?? "Unknown"
        let sessionId = payload.dictionaryPayload["sessionId"] as? String ?? ""
        let hasVideo = payload.dictionaryPayload["hasVideo"] as? Bool ?? false
        
        reportIncomingCall(
            uuid: UUID(),
            handle: callerId,
            callerName: callerName,
            hasVideo: hasVideo
        ) { error in
            completion()
        }
    }
    
    func reportIncomingCall(uuid: UUID, handle: String, callerName: String, hasVideo: Bool, completion: @escaping (Error?) -> Void) {
        let update = CXCallUpdate()
        update.remoteHandle = CXHandle(type: .generic, value: handle)
        update.localizedCallerName = callerName
        update.hasVideo = hasVideo
        
        provider.reportNewIncomingCall(with: uuid, update: update) { error in
            completion(error)
        }
    }
    
    // CXProviderDelegate
    func providerDidReset(_ provider: CXProvider) {}
    
    func provider(_ provider: CXProvider, perform action: CXAnswerCallAction) {
        // Notify React Native to accept the call
        NotificationCenter.default.post(
            name: NSNotification.Name("CallKitAnswerCall"),
            object: nil,
            userInfo: ["callUUID": action.callUUID.uuidString]
        )
        action.fulfill()
    }
    
    func provider(_ provider: CXProvider, perform action: CXEndCallAction) {
        // Notify React Native to end the call
        NotificationCenter.default.post(
            name: NSNotification.Name("CallKitEndCall"),
            object: nil,
            userInfo: ["callUUID": action.callUUID.uuidString]
        )
        action.fulfill()
    }
}

Android VoIP Configuration

Add Firebase Cloud Messaging

Add Firebase to your Android project
Add the FCM dependency to android/app/build.gradle:

dependencies {
    implementation 'com.google.firebase:firebase-messaging:23.0.0'
}

Configure CometChat Dashboard

Go to your CometChat Dashboard
Navigate to Notifications > Push Notifications
Upload your Firebase Server Key

Implement ConnectionService

Create a ConnectionService for incoming calls:

// android/app/src/main/java/com/yourapp/CallConnectionService.java
package com.yourapp;

import android.telecom.Connection;
import android.telecom.ConnectionRequest;
import android.telecom.ConnectionService;
import android.telecom.PhoneAccountHandle;
import android.telecom.TelecomManager;

public class CallConnectionService extends ConnectionService {
    
    @Override
    public Connection onCreateIncomingConnection(
            PhoneAccountHandle connectionManagerPhoneAccount,
            ConnectionRequest request) {
        
        CallConnection connection = new CallConnection();
        connection.setConnectionProperties(Connection.PROPERTY_SELF_MANAGED);
        connection.setCallerDisplayName(
            request.getExtras().getString("callerName"),
            TelecomManager.PRESENTATION_ALLOWED
        );
        connection.setRinging();
        
        return connection;
    }
    
    @Override
    public Connection onCreateOutgoingConnection(
            PhoneAccountHandle connectionManagerPhoneAccount,
            ConnectionRequest request) {
        
        CallConnection connection = new CallConnection();
        connection.setConnectionProperties(Connection.PROPERTY_SELF_MANAGED);
        connection.setDialing();
        
        return connection;
    }
}

Register ConnectionService

Add to AndroidManifest.xml:

<service
    android:name=".CallConnectionService"
    android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"
    android:exported="true">
    <intent-filter>
        <action android:name="android.telecom.ConnectionService" />
    </intent-filter>
</service>

Add Permissions

<uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />

Register Push Token

Register the VoIP/FCM token with CometChat using CometChatNotifications.registerPushToken. iOS VoIP is its own platform — APNS_REACT_NATIVE_VOIP, distinct from the APNS_REACT_NATIVE_DEVICE used for ordinary message notifications — so an app that both rings and notifies registers two tokens.

import { CometChatNotifications } from '@cometchat/chat-sdk-react-native';

const { PushPlatforms } = CometChatNotifications;

async function registerPushToken(token: string, platform: 'ios' | 'android') {
  try {
    await CometChatNotifications.registerPushToken(
      token,
      platform === 'ios'
        ? PushPlatforms.APNS_REACT_NATIVE_VOIP     // the PushKit token
        : PushPlatforms.FCM_REACT_NATIVE_ANDROID,
      PROVIDER_ID,                                 // Dashboard → Notifications → Provider ID
    );
    console.log('Push token registered');
  } catch (error) {
    console.error('Error registering push token:', error);
  }
}

Register the token after the user logs in — a token registered with no logged-in user is attached to nobody. Re-register when the token refreshes.providerId is the Provider ID you configured in Dashboard → Notifications → Push Notifications (for example APNS_PROVIDER_ID). Pass it so the token is bound to the right provider.

Unregister on Logout

Release the token when the user logs out, or the next user on that device receives their calls:

import { CometChatNotifications } from '@cometchat/chat-sdk-react-native';

async function unregisterPushToken() {
  try {
    await CometChatNotifications.unregisterPushToken();
  } catch (error) {
    console.error('Error unregistering push token:', error);
  }
}

Handle Incoming VoIP Push

import { useEffect } from 'react';
import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
import { CometChat } from '@cometchat/chat-sdk-react-native';
import { CometChatCalls } from '@cometchat/calls-sdk-react-native';

function useVoIPPush() {
  useEffect(() => {
    if (Platform.OS === 'ios') {
      const eventEmitter = new NativeEventEmitter(NativeModules.CallKitManager);
      
      const answerSubscription = eventEmitter.addListener(
        'CallKitAnswerCall',
        async (data) => {
          // Accept the call via Chat SDK
          const sessionId = data.sessionId;
          await CometChat.acceptCall(sessionId);
          
          // Start the call session
          const { token } = await CometChatCalls.generateToken(sessionId);
          // Navigate to call screen with token
        }
      );
      
      const endSubscription = eventEmitter.addListener(
        'CallKitEndCall',
        async (data) => {
          CometChatCalls.leaveSession();
        }
      );
      
      return () => {
        answerSubscription.remove();
        endSubscription.remove();
      };
    }
  }, []);
}

export default useVoIPPush;

Ringing - Implement call notifications
Background Handling - Keep calls active in background
Setup - Initial SDK setup

Overview

Getting Started

Call Session

Features

Advanced

Migration Guide

Resources

iOS VoIP Configuration

Enable VoIP Push Notifications

Create VoIP Certificate

Configure CometChat Dashboard

Implement CallKit

Android VoIP Configuration

Add Firebase Cloud Messaging

Configure CometChat Dashboard

Implement ConnectionService

Register ConnectionService

Add Permissions

Register Push Token

Unregister on Logout

Handle Incoming VoIP Push

​iOS VoIP Configuration

​Enable VoIP Push Notifications

​Create VoIP Certificate

​Configure CometChat Dashboard

​Implement CallKit

​Android VoIP Configuration

​Add Firebase Cloud Messaging

​Configure CometChat Dashboard

​Implement ConnectionService

​Register ConnectionService

​Add Permissions

​Register Push Token

​Unregister on Logout

​Handle Incoming VoIP Push

​Related Documentation

iOS VoIP Configuration

Enable VoIP Push Notifications

Create VoIP Certificate

Configure CometChat Dashboard

Implement CallKit

Android VoIP Configuration

Add Firebase Cloud Messaging

Configure CometChat Dashboard

Implement ConnectionService

Register ConnectionService

Add Permissions

Register Push Token

Unregister on Logout

Handle Incoming VoIP Push

Related Documentation