Web calls in native apps

import WebRTC // https://github.com/stasel/WebRTC

// Create a new RetellCall for each call; don't reuse one after hangUp().
final class RetellCall: NSObject {
  private let factory = RTCPeerConnectionFactory()
  private var peerConnection: RTCPeerConnection?
  private var control: RTCDataChannel? // keep a reference, or no events arrive
  private var sessionsURL: URL!
  private var accessToken = ""
  private var sessionId = ""

  // callId, accessToken, and iceServers come from your backend endpoint.
  func connect(callId: String, accessToken: String, iceServers: [RTCIceServer]) async throws {
    // Voice-call audio mode turns on echo cancellation.
    let audio = RTCAudioSession.sharedInstance()
    do {
      audio.lockForConfiguration()
      defer { audio.unlockForConfiguration() }
      try audio.setCategory(.playAndRecord, with: [.allowBluetooth, .defaultToSpeaker])
      try audio.setMode(.voiceChat)
      try audio.setActive(true)
    }

    // Peer connection with a mic track and the control channel.
    let config = RTCConfiguration()
    config.sdpSemantics = .unifiedPlan
    config.iceServers = iceServers
    let constraints = RTCMediaConstraints(mandatoryConstraints: nil, optionalConstraints: nil)
    let pc = factory.peerConnection(with: config, constraints: constraints, delegate: self)!
    let mic = factory.audioTrack(with: factory.audioSource(with: constraints), trackId: "mic")
    pc.add(mic, streamIds: ["mic"])
    control = pc.dataChannel(forLabel: "control", configuration: RTCDataChannelConfiguration())
    control?.delegate = self
    peerConnection = pc

    do {
      // Offer, give ICE gathering 1 second, post it, apply the answer.
      try await pc.setLocalDescription(try await pc.offer(for: constraints))
      try await Task.sleep(nanoseconds: 1_000_000_000)
      guard peerConnection === pc else { return } // hung up while waiting

      self.accessToken = accessToken
      sessionsURL = URL(string: "https://api.retellai.com/webrtc-proxy/\(callId)/v1/webrtc/sessions")!
      let answer = try await request("POST", sessionsURL, body: ["identity": "client", "sdp": pc.localDescription!.sdp])
      guard let id = answer["session_id"], let sdp = answer["sdp"] else { throw URLError(.badServerResponse) }
      sessionId = id
      guard peerConnection === pc else { // hung up during the POST
        _ = try? await request("DELETE", sessionsURL.appendingPathComponent(id))
        return
      }
      try await pc.setRemoteDescription(RTCSessionDescription(type: .answer, sdp: sdp))
    } catch {
      close()
      throw error
    }
  }

  func hangUp() async {
    close()
    guard !sessionId.isEmpty else { return }
    _ = try? await request("DELETE", sessionsURL.appendingPathComponent(sessionId))
  }

  func close() {
    guard let pc = peerConnection else { return } // pc.close() calls back into close()
    peerConnection = nil
    pc.close()
  }

  private func request(_ method: String, _ url: URL, body: [String: String]? = nil) async throws -> [String: String] {
    var request = URLRequest(url: url)
    request.httpMethod = method
    request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
    if let body {
      request.setValue("application/json", forHTTPHeaderField: "Content-Type")
      request.httpBody = try JSONSerialization.data(withJSONObject: body)
    }
    let (data, _) = try await URLSession.shared.data(for: request)
    return (try? JSONSerialization.jsonObject(with: data) as? [String: String]) ?? [:]
  }
}

extension RetellCall: RTCDataChannelDelegate {
  func dataChannel(_ channel: RTCDataChannel, didReceiveMessageWith buffer: RTCDataBuffer) {
    let message = try? JSONSerialization.jsonObject(with: buffer.data) as? [String: Any]
    if let state = message?["state"] as? String, state == "ended" || state == "replaced" {
      DispatchQueue.main.async { self.close() }
    }
  }

  func dataChannelDidChangeState(_ channel: RTCDataChannel) {}
}

// Also adopt RTCPeerConnectionDelegate and call close() when the
// connection state becomes .failed or .closed.

// implementation("io.getstream:stream-webrtc-android:1.3.10")
// implementation("com.squareup.okhttp3:okhttp:4.12.0")
// Create a new RetellCall for each call; don't reuse one after hangUp().
class RetellCall(private val context: Context) {
  private val http = OkHttpClient()
  private val closer = Executors.newSingleThreadExecutor()
  private var peerConnection: PeerConnection? = null
  private var sessionsUrl = ""
  private var accessToken = ""
  private var sessionId = ""

  // callId, accessToken, and iceServers come from your backend endpoint.
  // Call after the user grants RECORD_AUDIO.
  suspend fun connect(callId: String, accessToken: String, iceServers: List<PeerConnection.IceServer>) {
    // Voice-call audio mode turns on echo cancellation.
    val audio = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
    audio.mode = AudioManager.MODE_IN_COMMUNICATION

    // Peer connection with a mic track and the control channel.
    PeerConnectionFactory.initialize(
      PeerConnectionFactory.InitializationOptions.builder(context).createInitializationOptions()
    )
    val factory = PeerConnectionFactory.builder().createPeerConnectionFactory()
    val config = PeerConnection.RTCConfiguration(iceServers)
    config.sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN
    val pc = factory.createPeerConnection(config, observer)!!
    pc.addTrack(factory.createAudioTrack("mic", factory.createAudioSource(MediaConstraints())), listOf("mic"))
    pc.createDataChannel("control", DataChannel.Init()).registerObserver(controlObserver)
    peerConnection = pc

    try {
      // Offer, give ICE gathering 1 second, post it, apply the answer.
      val offer = sdp { pc.createOffer(it, MediaConstraints()) }!!
      sdp { pc.setLocalDescription(it, offer) }
      delay(1_000)
      if (peerConnection !== pc) return // hung up while waiting

      this.accessToken = accessToken
      sessionsUrl = "https://api.retellai.com/webrtc-proxy/$callId/v1/webrtc/sessions"
      val body = JSONObject().put("identity", "client").put("sdp", pc.localDescription.description)
      val answer = JSONObject(request(sessionsUrl, "POST", body.toString()))
      sessionId = answer.getString("session_id")
      if (peerConnection !== pc) { // hung up during the POST
        runCatching { request("$sessionsUrl/$sessionId", "DELETE", null) }
        return
      }
      val remote = SessionDescription(SessionDescription.Type.ANSWER, answer.getString("sdp"))
      sdp { pc.setRemoteDescription(it, remote) }
    } catch (e: Exception) {
      close()
      throw e
    }
  }

  suspend fun hangUp() {
    close()
    if (sessionId.isNotEmpty()) runCatching { request("$sessionsUrl/$sessionId", "DELETE", null) }
  }

  @Synchronized
  private fun close() {
    val pc = peerConnection ?: return // pc.close() calls back into close()
    peerConnection = null
    pc.close()
    (context.getSystemService(Context.AUDIO_SERVICE) as AudioManager).mode = AudioManager.MODE_NORMAL
  }

  private suspend fun request(url: String, method: String, json: String?): String =
    withContext(Dispatchers.IO) {
      val body = json?.toRequestBody("application/json".toMediaType())
      val request = Request.Builder().url(url).method(method, body)
        .header("Authorization", "Bearer $accessToken").build()
      http.newCall(request).execute().use { response ->
        check(response.isSuccessful) { "HTTP ${response.code}" }
        response.body!!.string()
      }
    }

  // Wraps WebRTC's callback-style SDP calls.
  private suspend fun sdp(call: (SdpObserver) -> Unit): SessionDescription? =
    suspendCoroutine { cont ->
      call(object : SdpObserver {
        override fun onCreateSuccess(sdp: SessionDescription) = cont.resume(sdp)
        override fun onSetSuccess() = cont.resume(null)
        override fun onCreateFailure(error: String?) = cont.resumeWithException(IllegalStateException(error))
        override fun onSetFailure(error: String?) = cont.resumeWithException(IllegalStateException(error))
      })
    }

  private val controlObserver = object : DataChannel.Observer {
    override fun onMessage(buffer: DataChannel.Buffer) {
      val bytes = ByteArray(buffer.data.remaining()).also { buffer.data.get(it) }
      val state = JSONObject(String(bytes)).optString("state")
      // Never close the peer connection on a WebRTC callback thread.
      if (state == "ended" || state == "replaced") closer.execute { close() }
    }
    override fun onBufferedAmountChange(previousAmount: Long) {}
    override fun onStateChange() {}
  }

  // Also define `observer`, a PeerConnection.Observer whose onConnectionChange
  // calls closer.execute { close() } on FAILED or CLOSED.
}

// npm install react-native-webrtc react-native-incall-manager
import { RTCPeerConnection, mediaDevices } from "react-native-webrtc";
import InCallManager from "react-native-incall-manager";

// Create a new RetellCall for each call; don't reuse one after hangUp().
export class RetellCall {
  // callId, accessToken, and iceServers come from your backend endpoint.
  async connect(callId, accessToken, iceServers) {
    // Voice-call audio mode turns on echo cancellation.
    InCallManager.start({ media: "audio" });

    // Peer connection with a mic track and the control channel.
    const pc = new RTCPeerConnection({ iceServers });
    this.pc = pc;
    try {
      pc.addEventListener("connectionstatechange", () => {
        if (pc.connectionState === "failed" || pc.connectionState === "closed") this.close();
      });
      this.mic = await mediaDevices.getUserMedia({ audio: true, video: false });
      if (this.pc !== pc) return this.mic.getTracks().forEach((track) => track.stop());
      this.mic.getAudioTracks().forEach((track) => pc.addTrack(track, this.mic));
      pc.createDataChannel("control").addEventListener("message", (event) => {
        const { state } = JSON.parse(event.data);
        if (state === "ended" || state === "replaced") this.close();
      });

      // Offer, give ICE gathering 1 second, post it, apply the answer.
      await pc.setLocalDescription(await pc.createOffer());
      await new Promise((resolve) => setTimeout(resolve, 1000));
      if (this.pc !== pc) return; // hung up while waiting

      this.sessionsUrl = `https://api.retellai.com/webrtc-proxy/${callId}/v1/webrtc/sessions`;
      this.auth = { Authorization: `Bearer ${accessToken}` };
      const res = await fetch(this.sessionsUrl, {
        method: "POST",
        headers: { ...this.auth, "Content-Type": "application/json" },
        body: JSON.stringify({ identity: "client", sdp: pc.localDescription.sdp }),
      });
      if (res.status !== 201) throw new Error(`Signaling error ${res.status}`);
      const { session_id, sdp } = await res.json();
      this.sessionId = session_id;
      if (this.pc !== pc) return this.hangUp(); // hung up during the POST
      await pc.setRemoteDescription({ type: "answer", sdp });
    } catch (error) {
      this.close();
      throw error;
    }
  }

  async hangUp() {
    this.close();
    if (!this.sessionId) return;
    await fetch(`${this.sessionsUrl}/${this.sessionId}`, { method: "DELETE", headers: this.auth })
      .catch(() => {});
  }

  close() {
    const pc = this.pc;
    if (!pc) return; // pc.close() calls back into close()
    this.pc = undefined;
    this.mic?.getTracks().forEach((track) => track.stop());
    pc.close();
    InCallManager.stop();
  }
}

// flutter pub add flutter_webrtc http
import 'dart:convert';

import 'package:flutter_webrtc/flutter_webrtc.dart';
import 'package:http/http.dart' as http;

// Create a new RetellCall for each call; don't reuse one after hangUp().
class RetellCall {
  RTCPeerConnection? _pc;
  MediaStream? _mic;
  String _sessionsUrl = '';
  Map<String, String> _auth = {};
  String _sessionId = '';

  // callId, accessToken, and iceServers come from your backend endpoint.
  // flutter_webrtc turns on the voice-call audio mode by itself.
  Future<void> connect(String callId, String accessToken, List<dynamic> iceServers) async {
    // Peer connection with a mic track and the control channel.
    final pc = await createPeerConnection({'iceServers': iceServers, 'sdpSemantics': 'unified-plan'});
    _pc = pc;
    try {
      pc.onConnectionState = (state) {
        if (state == RTCPeerConnectionState.RTCPeerConnectionStateFailed ||
            state == RTCPeerConnectionState.RTCPeerConnectionStateClosed) {
          close();
        }
      };
      final mic = await navigator.mediaDevices.getUserMedia({'audio': true, 'video': false});
      _mic = mic;
      if (_pc != pc) {
        for (final track in mic.getTracks()) {
          await track.stop();
        }
        return;
      }
      for (final track in mic.getAudioTracks()) {
        await pc.addTrack(track, mic);
      }
      final control = await pc.createDataChannel('control', RTCDataChannelInit());
      control.onMessage = (message) {
        final state = jsonDecode(message.text)['state'];
        if (state == 'ended' || state == 'replaced') close();
      };

      // Offer, give ICE gathering 1 second, post it, apply the answer.
      await pc.setLocalDescription(await pc.createOffer());
      await Future.delayed(const Duration(seconds: 1));
      if (_pc != pc) return; // hung up while waiting

      _sessionsUrl = 'https://api.retellai.com/webrtc-proxy/$callId/v1/webrtc/sessions';
      _auth = {'Authorization': 'Bearer $accessToken'};
      final local = await pc.getLocalDescription();
      final res = await http.post(
        Uri.parse(_sessionsUrl),
        headers: {..._auth, 'Content-Type': 'application/json'},
        body: jsonEncode({'identity': 'client', 'sdp': local!.sdp}),
      );
      if (res.statusCode != 201) throw Exception('Signaling error ${res.statusCode}');
      final answer = jsonDecode(res.body);
      _sessionId = answer['session_id'];
      if (_pc != pc) return await hangUp(); // hung up during the POST
      await pc.setRemoteDescription(RTCSessionDescription(answer['sdp'], 'answer'));
    } catch (_) {
      await close();
      rethrow;
    }
  }

  Future<void> hangUp() async {
    await close();
    if (_sessionId.isEmpty) return;
    try {
      await http.delete(Uri.parse('$_sessionsUrl/$_sessionId'), headers: _auth);
    } catch (_) {}
  }

  Future<void> close() async {
    final pc = _pc;
    if (pc == null) return; // pc.close() calls back into close()
    _pc = null;
    for (final track in _mic?.getTracks() ?? <MediaStreamTrack>[]) {
      await track.stop();
    }
    await pc.close();
  }
}