Ringing

import { CometChatCalls } from '@cometchat/calls-sdk-react-native';

const { data: call, error } = await CometChatCalls.initiateCall(receiverUid, {
  type: 'audio',                 // or 'video'
  receiverType: 'user',
  sessionSettings: {
    sessionType: 'VOICE',        // 'VIDEO' for a video call
    isPeerCall: true,            // 1:1: the call ends for both when either leaves
  },
});

if (error) {
  console.error('Could not start the call:', error);
} else {
  console.log(`Calling ${call.receiver}, session ${call.sessionId}`);
  showOutgoingScreen(call);
  listenOnPreparedSession(call);
}

function listenOnPreparedSession(call) {
  const session = CometChatCalls.getActiveSession();
  if (!session) return;
  const me = CometChatCalls.getLoggedInUser()?.uid;

  const offConnected = session.addEventListener('onParticipantConnected', participant => {
    // The callee's device received the push and is ringing.
    if (participant.uid === me) return;
    setStatus('Ringing…');
  });

  const offJoined = session.addEventListener('onParticipantJoined', participant => {
    // The callee answered: now the caller joins.
    if (participant.uid === me) return;
    joinCall(call.sessionId);
  });

  // The prepared session closed before anyone joined: the call is over.
  const offClosed = session.addEventListener('onConnectionClosed', closeOutgoingScreen);

  return () => [offConnected, offJoined, offClosed].forEach(off => off());
}

import { CometChatVoipNotifications } from '@cometchat/push-notifications-voip-react-native';

// A call for this user is ringing. The Push SDK already shows the ring;
// use this for your own state (badge, analytics, refreshing a list).
const offRinging = CometChatVoipNotifications.onCallRinging(call => {
  console.log('ringing', call.sessionId, 'from', call.callerUid);
});

// The user answered — open your call screen.
const offAccepted = CometChatVoipNotifications.onCallAccepted(call => {
  openCallScreen(call.sessionId, call.callType);
});

// The call ended. On the caller: "declined", "timedOut" or "cancelled".
    // event.callAction carries the raw push action — "busy" vs "rejected".
const offEnded = CometChatVoipNotifications.onCallEnded(event => {
  if (event.sessionId === currentSessionId) closeOutgoingScreen(event.reason);
});

// The ring itself stopped, whatever happened to the call.
const offRingEnded = CometChatVoipNotifications.onRingEnded(event => {
  dismissIncomingUi(event.sessionId);
});

// When the screen goes away:
[offRinging, offAccepted, offEnded, offRingEnded].forEach(off => off());

function App() {
  const [activeCall, setActiveCall] = useState(null);

  useEffect(() => CometChatVoipNotifications.onCallAccepted(call => {
    setActiveCall(call);           // call.sessionId, callerUid, callerName, callType
  }), []);

  if (activeCall) return <CallScreen call={activeCall} />;
  return <Chats />;
}

import { CometChatCalls } from '@cometchat/calls-sdk-react-native';

function CallScreen({ call }) {
  const { sessionId, callType } = call;          // the PNCallInfo from onCallAccepted
  const [callToken, setCallToken] = useState(null);

  useEffect(() => {
    const offs = [];
    (async () => {
      // Derived from the call, never hardcoded: `callType` is 'audio' or 'video', and a
      // video call joined as 'VOICE' comes up with no camera.
      const sessionType = callType === 'video' ? 'VIDEO' : 'VOICE';
      // Hands back the session already prepared for this call, without minting a second token.
      const session = await CometChatCalls.connect(sessionId, { sessionType });
      setCallToken(session.callToken);
      // The end of the call comes from the session, not from a prop on the component.
      offs.push(session.addEventListener('onSessionLeft', goBack));
      offs.push(session.addEventListener('onConnectionClosed', goBack));
    })();
    return () => offs.forEach(off => off());
  }, [sessionId, callType]);

  if (!callToken) return <Connecting />;
  return <CometChatCalls.Component callToken={callToken} />;
}

CometChatVoipNotifications.declineCall(sessionId);

await CometChatCalls.endCall(sessionId, 'rejected');

async function cancelOutgoingCall(sessionId: string) {
  const { error } = await CometChatCalls.endCall(sessionId, 'cancelled');
  if (error) console.error('Cancel failed:', error);
  closeOutgoingScreen();          // close locally either way
}

const timer = setTimeout(async () => {
  if (!answered) {
    await CometChatCalls.endCall(sessionId, 'unanswered');
    closeOutgoingScreen();
  }
}, 45_000);

// clear it on answer, cancel and unmount

async function hangUp() {
  await CometChatCalls.getActiveSession()?.leave();
  goBack();
}

const session = CometChatCalls.getActiveSession();
session?.addEventListener('onSessionLeft', goBack);
session?.addEventListener('onConnectionClosed', goBack);

await CometChatPushNotifications.unregister();   // needs the credential; must come first
CometChatVoipNotifications.clearIdentity();
await CometChatUIKit.logout();                   // Chat SDK only
await CometChatCalls.logout();