expo-callkit-telecom 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Fairley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,197 @@
+# 📞 expo-callkit-telecom
+
+> A modern Expo module — written in Swift and Kotlin — that wraps **CallKit** on iOS and **Jetpack Core-Telecom** on Android with API parity. It owns the system call UI, the audio session, and VoIP push — your app owns the media (e.g. LiveKit, plain WebRTC, etc.).
+
+The module is opinionated about *system integration* and unopinionated about *media*. You wire your media library to the events it emits.
+
+## ✨ Features
+
+- 📱 **Native calling UI** — CallKit on iOS, Telecom incoming-call notification + full-screen intent on Android
+- 🔔 **VoIP notifications** — APNs VoIP on iOS (PushKit), FCM data messages on Android, parsed natively so calls can be reported from a terminated state
+- 🎵 **Ringtones** — system ringtone for incoming calls, configurable via the config plugin
+- ☎️ **Dialtone** — looped dialtone with fade-in for outgoing calls, configurable
+- 🎧 **Audio session management** — cross-platform port types (`builtInReceiver`, `builtInSpeaker`, `headphones`, `bluetoothA2DP`, `bluetoothHFP`, `bluetoothLE`, `airPlay`, `hdmi`, `carAudio`, `usbAudio`, `lineOut`)
+- 🔊 **Speaker override** and live route-change events
+- 🎚️ **Mute, hold, video, DTMF** — both directions: app → system and system → app (e.g. native mute button → your media)
+- 🗣️ **Call intents on iOS** — Recents list, Siri ("call Jane")
+- 🧩 **Typed TypeScript API** with a single `CallSession` object that tracks state across the call lifecycle
+
+## 📦 Install
+
+```sh
+bun add expo-callkit-telecom
+```
+
+Add the config plugin to `app.json` / `app.config.ts`. Minimal form:
+
+```jsonc
+{
+  "expo": {
+    "plugins": ["expo-callkit-telecom"]
+  }
+}
+```
+
+With custom ringtone and dialtone:
+
+```jsonc
+{
+  "expo": {
+    "plugins": [
+      [
+        "expo-callkit-telecom",
+        {
+          "sounds": [
+            "./assets/sounds/ringtone.caf",
+            "./assets/sounds/dialtone.caf"
+          ],
+          "defaultRingtoneIos": "ringtone.caf",
+          "defaultRingtoneAndroid": "ringtone.caf",
+          "defaultDialtone": "dialtone.caf",
+          "incomingCallTimeout": 45,
+          "outgoingCallTimeout": 60,
+          "microphonePermission": "$(PRODUCT_NAME) needs the microphone to make calls."
+        }
+      ]
+    ]
+  }
+}
+```
+
+Files in `sounds` are copied into the iOS bundle and Android raw resources at prebuild time. The full prop type is `ExpoCallKitTelecomPluginProps` in `plugin/src/`.
+
+
+## 🧠 Concepts
+
+The TS API is organised into three verbs:
+
+| Verb         | Direction              | Examples                                                              |
+| ------------ | ---------------------- | --------------------------------------------------------------------- |
+| **Request**  | App → System           | `startOutgoingCall`, `answerCall`, `endCall`, `setMuted`              |
+| **Report**   | App → System (state)   | `reportIncomingCall`, `reportOutgoingCallConnected`, `reportCallEnded` |
+| **Fulfill**  | App → System (ack)     | `fulfillIncomingCallConnected`                                        |
+
+Events flow the other way (System → App) via `addXxxListener`.
+
+## 🚀 VoIP push payload
+
+When the OS delivers a VoIP push (PushKit on iOS, an FCM data message on Android), the module parses the payload natively — before JS is running — and reports the call to the OS.
+
+The event itself is always the same shape on both transports. All keys are camelCase:
+
+```jsonc
+// IncomingCallEvent (the "inner" event)
+{
+  "eventId": "550e8400-e29b-41d4-a716-446655440000",   // required (UUID), for dedup
+  "serverCallId": "9e7f...",                           // required — your backend's call id
+                                                       //   (distinct from CallSession.id,
+                                                       //    which is the OS-assigned UUID)
+  "hasVideo": false,
+  "startedAt": "2026-01-15T19:42:11.000Z",             // RFC 3339, optional
+  "caller": {
+    "id": "<caller id>",                               // required — opaque, stable
+    "displayName": "Jane Smith",
+    "avatarUrl": "https://...",
+    "phoneNumber": "+14155551234",                     // optional; must be E.164 if present
+    "email": "jane@example.com"
+  },
+  "metadata": {                                        // optional, opaque pass-through
+    "chatId": "abc-123",
+    "tenantId": "acme-co"
+  }
+}
+```
+
+Any keys you put under `metadata` are forwarded verbatim from the push payload all the way through to your JS event handler. The lib treats them as opaque — you cast at the read site:
+
+```ts
+Calls.addCallAnsweredListener(({ id }) => {
+  const session = /* lookup */;
+  const chatId = session?.incomingCallEvent?.metadata?.chatId as string | undefined;
+});
+```
+
+Both transports wrap the event under an `incomingCall` key, just at different layers — APNs in the push payload dictionary, FCM in the data block:
+
+### 🍎 iOS — APNs VoIP push
+
+Send a VoIP push (`apns-push-type: voip`) whose dictionary payload nests the event under `incomingCall`:
+
+```jsonc
+{
+  "incomingCall": { /* IncomingCallEvent — see above */ }
+}
+```
+
+### 🤖 Android — FCM data message
+
+FCM data values must be strings, so JSON-encode the inner event and put it under `incomingCall`:
+
+```jsonc
+{
+  "data": {
+    "messageType": "incomingCall",
+    "incomingCall": "{\"eventId\":\"...\",\"serverCallId\":\"...\", ... }"
+  }
+}
+```
+
+Non-`incomingCall` data messages are forwarded to `expo-notifications`'s service for normal handling.
+
+## 🧪 Example
+
+`example/` contains a runnable Expo app (`example/client/`) and a zero-dep push-sender script (`example/server/`). See their READMEs for setup and how to validate VoIP push end-to-end.
+
+## 🔑 Registering for VoIP push
+
+```ts
+import {
+  registerVoIPPush,
+  useVoIPPushToken,
+} from "expo-callkit-telecom";
+
+// Once, early in app lifecycle:
+registerVoIPPush();
+
+// In a React component:
+function App() {
+  const voip = useVoIPPushToken();
+  useEffect(() => {
+    if (voip) {
+      // voip.type is "APNS_VOIP" on iOS, "FCM" on Android.
+      sendToBackend(voip.token, voip.type);
+    }
+  }, [voip]);
+}
+```
+
+## 📚 API surface
+
+See `src/Calls.ts` for full JSDoc. Main areas:
+
+- **Sessions** — `getActiveCallSession`, `addCallSession{Added,Updated,Removed}Listener`
+- **Outgoing** — `startOutgoingCall`, `addOutgoingCallStartedListener`, `reportOutgoingCallConnected`
+- **Incoming** — `reportIncomingCall`, `addIncomingCallReportedListener`, `answerCall`, `addCallAnsweredListener`, `fulfillIncomingCallConnected`, `failIncomingCallConnected`
+- **End** — `endCall`, `addCallEndedListener`, `reportCallEnded`
+- **Audio** — `getAudioSession`, `setAudioSessionPortOverride`, `prepareAudioSessionForCall`, `addAudioRouteChangedListener`
+- **Mute / Hold / Video / DTMF** — `setMuted`, `setHeld`, `reportVideo`, `playDTMF` and their listeners
+- **VoIP push** — `registerVoIPPush`, `getVoIPPushToken`, `useVoIPPushToken`, `addVoIPPushTokenUpdatedListener`
+
+## 📝 Platform notes
+
+- 🍎 **iOS** — requires the `voip` background mode and a VoIP push certificate. Uses CallKit + PushKit + WebRTC's `RTCAudioSession` for manual audio control. Min iOS 15.1.
+- 🤖 **Android** — requires `MANAGE_OWN_CALLS` permission, min SDK 26. Uses `androidx.core:core-telecom`. Incoming calls come via FCM data messages — the config plugin registers `ExpoCallKitTelecomMessagingService` automatically.
+- 🎟️ VoIP push token type is reported as `"APNS_VOIP"` on iOS and `"FCM"` on Android — send both to your backend so it knows which transport to use.
+
+## 🆚 Comparison with `react-native-callkeep`
+
+[`react-native-callkeep`](https://github.com/react-native-webrtc/react-native-callkeep) is the long-standing option in this space. Here are some differences with this package:
+
+- **Android backend.** callkeep uses the classic `android.telecom.ConnectionService` (`minSdk 23`). This module uses Jetpack `androidx.core:core-telecom` (`minSdk 26`), the Google-recommended path going forward — it owns the foreground service, the incoming-call notification, and the full-screen intent, so you don't wire any of that up.
+- **Native language.** callkeep is Objective-C + Java. This module is Swift + Kotlin.
+- **VoIP push parsing.** callkeep doesn't parse pushes — you wire up `pushRegistry:didReceiveIncomingPushWithPayload:` (or `react-native-voip-push-notification`) and FCM data handling yourself. This module parses APNs VoIP and FCM payloads natively, before JS is running, so calls report correctly from a terminated state without app-side glue.
+- **Audio session.** callkeep manipulates `AVAudioSession` directly, leaving WebRTC's `RTCAudioSession` to be coordinated by the app. This module integrates with `RTCAudioSession` so manual-audio WebRTC stacks (LiveKit, plain WebRTC) work without extra wiring.
+- **API shape.** callkeep's options are split into `{ ios: {...}, android: {...} }` and several methods are platform-only. This module exposes one typed `CallSession` object and one set of verbs (`request` / `report` / `fulfill`) that work the same on both platforms.
+- **Expo support.** This module is an Expo Module with a config plugin that handles entitlements, background modes, permissions, ringtone bundling, and FCM service registration.
+- **Tested with.** iOS 26 / Android 15, on real devices, with LiveKit as the media transport.
+

package/android/build.gradle

@@ -0,0 +1,32 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'expo.modules.callkittelecom'
+version = '0.1.0'
+
+android {
+  namespace "expo.modules.callkittelecom"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+dependencies {
+  implementation "androidx.core:core-telecom:1.0.1"
+  implementation "com.google.firebase:firebase-messaging:24.1.0"
+
+  // expo-notifications may be included as a source project or as a prebuilt
+  // Maven artifact via Expo's version catalog, depending on the SDK version.
+  def notificationsProject = rootProject.findProject(":expo-notifications")
+  if (notificationsProject != null) {
+    compileOnly notificationsProject
+  } else {
+    compileOnly "host.exp.exponent:expo.modules.notifications:+"
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,33 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.CAMERA" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+  <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_PHONE_CALL" />
+
+  <application>
+    <activity
+      android:name="expo.modules.callkittelecom.IncomingCallActivity"
+      android:exported="false"
+      android:showWhenLocked="true"
+      android:turnScreenOn="true"
+      android:launchMode="singleInstance"
+      android:excludeFromRecents="true"
+      android:taskAffinity=""
+      android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen" />
+
+    <receiver
+      android:name="expo.modules.callkittelecom.services.CallNotificationReceiver"
+      android:exported="false" />
+
+    <service
+      android:name="expo.modules.callkittelecom.services.ExpoCallKitTelecomMessagingService"
+      android:exported="false">
+      <intent-filter>
+        <action android:name="com.google.firebase.MESSAGING_EVENT" />
+      </intent-filter>
+    </service>
+  </application>
+</manifest>

package/android/src/main/java/expo/modules/callkittelecom/ExpoCallKitTelecomModule.kt

@@ -0,0 +1,384 @@
+package expo.modules.callkittelecom
+
+import expo.modules.callkittelecom.events.CallEventEmitter
+import expo.modules.callkittelecom.events.CallEvents
+import expo.modules.callkittelecom.managers.CallAudioManager
+import expo.modules.callkittelecom.managers.CallManager
+import expo.modules.callkittelecom.managers.CaptureSessionManager
+import expo.modules.callkittelecom.services.CallNotificationReceiver
+import expo.modules.callkittelecom.managers.VoIPPushManager
+import expo.modules.callkittelecom.models.CallEndedReason
+import expo.modules.callkittelecom.models.CallOptions
+import expo.modules.callkittelecom.models.CallParticipant
+import expo.modules.callkittelecom.models.IncomingCallEvent
+import expo.modules.callkittelecom.store.CallStore
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.util.UUID
+
+class ExpoCallKitTelecomModule : Module() {
+    /**
+     * Checks the current activity's launch intent for ACTION_ANSWER.
+     *
+     * On cold start from a notification answer action, the intent is delivered
+     * to onCreate() — not onNewIntent() — so OnNewIntent never fires.
+     * This method handles that case by checking the launch intent directly.
+     */
+    private fun handleLaunchIntent() {
+        val intent = appContext.currentActivity?.intent ?: return
+        handleAnswerIntent(intent)
+    }
+
+    /** Extracts the call ID from an ACTION_ANSWER intent and answers the call. */
+    private fun handleAnswerIntent(intent: android.content.Intent) {
+        if (intent.action != CallNotificationReceiver.ACTION_ANSWER) return
+
+        val callIdStr = intent.getStringExtra(CallNotificationReceiver.EXTRA_CALL_ID)
+            ?: return
+        val callId = try {
+            UUID.fromString(callIdStr)
+        } catch (_: IllegalArgumentException) {
+            return
+        }
+
+        // Clear the action so it isn't re-processed on configuration changes
+        intent.action = null
+
+        CallManager.shared.answerCall(callId)
+    }
+
+    override fun definition() =
+        ModuleDefinition {
+            Name("ExpoCallKitTelecom")
+
+            // region Events
+
+            Events(
+                CallEvents.CALL_SESSION_ADDED,
+                CallEvents.CALL_SESSION_UPDATED,
+                CallEvents.CALL_SESSION_REMOVED,
+                CallEvents.AUDIO_SESSION_ACTIVATED,
+                CallEvents.AUDIO_SESSION_DEACTIVATED,
+                CallEvents.AUDIO_ROUTE_CHANGED,
+                CallEvents.INCOMING_CALL_REPORTED,
+                CallEvents.OUTGOING_CALL_STARTED,
+                CallEvents.CALL_ANSWERED,
+                CallEvents.CALL_ENDED,
+                CallEvents.CALL_REPORTED_ENDED,
+                CallEvents.SET_MUTED_ACTION,
+                CallEvents.VIDEO_CHANGED,
+                CallEvents.SET_HELD_ACTION,
+                CallEvents.DTMF,
+                CallEvents.CALL_INTENT_RECEIVED,
+                CallEvents.VOIP_PUSH_TOKEN_UPDATED,
+            )
+
+            // endregion
+
+            // region Lifecycle
+
+            OnCreate {
+                val context = appContext.reactContext ?: return@OnCreate
+
+                CallManager.shared.initialize(context)
+
+                VoIPPushManager.register()
+
+                CallEventEmitter.setSender { eventName, body ->
+                    sendEvent(eventName, body)
+                }
+
+                // Handle the launch intent for cold-start answer actions.
+                // OnNewIntent only fires when the activity is already running.
+                // On cold start the ACTION_ANSWER intent is the launch intent,
+                // so we must check it here.
+                handleLaunchIntent()
+            }
+
+            OnDestroy {
+                CallEventEmitter.setSender(null)
+            }
+
+            OnNewIntent { intent ->
+                handleAnswerIntent(intent)
+            }
+
+            // Register per-event observers
+            OnStartObserving(CallEvents.CALL_SESSION_ADDED) {
+                CallEventEmitter.startObserving(CallEvents.CALL_SESSION_ADDED)
+            }
+            OnStopObserving(CallEvents.CALL_SESSION_ADDED) {
+                CallEventEmitter.stopObserving(CallEvents.CALL_SESSION_ADDED)
+            }
+
+            OnStartObserving(CallEvents.CALL_SESSION_UPDATED) {
+                CallEventEmitter.startObserving(CallEvents.CALL_SESSION_UPDATED)
+            }
+            OnStopObserving(CallEvents.CALL_SESSION_UPDATED) {
+                CallEventEmitter.stopObserving(CallEvents.CALL_SESSION_UPDATED)
+            }
+
+            OnStartObserving(CallEvents.CALL_SESSION_REMOVED) {
+                CallEventEmitter.startObserving(CallEvents.CALL_SESSION_REMOVED)
+            }
+            OnStopObserving(CallEvents.CALL_SESSION_REMOVED) {
+                CallEventEmitter.stopObserving(CallEvents.CALL_SESSION_REMOVED)
+            }
+
+            OnStartObserving(CallEvents.AUDIO_SESSION_ACTIVATED) {
+                CallEventEmitter.startObserving(CallEvents.AUDIO_SESSION_ACTIVATED)
+            }
+            OnStopObserving(CallEvents.AUDIO_SESSION_ACTIVATED) {
+                CallEventEmitter.stopObserving(CallEvents.AUDIO_SESSION_ACTIVATED)
+            }
+
+            OnStartObserving(CallEvents.AUDIO_SESSION_DEACTIVATED) {
+                CallEventEmitter.startObserving(CallEvents.AUDIO_SESSION_DEACTIVATED)
+            }
+            OnStopObserving(CallEvents.AUDIO_SESSION_DEACTIVATED) {
+                CallEventEmitter.stopObserving(CallEvents.AUDIO_SESSION_DEACTIVATED)
+            }
+
+            OnStartObserving(CallEvents.AUDIO_ROUTE_CHANGED) {
+                CallEventEmitter.startObserving(CallEvents.AUDIO_ROUTE_CHANGED)
+            }
+            OnStopObserving(CallEvents.AUDIO_ROUTE_CHANGED) {
+                CallEventEmitter.stopObserving(CallEvents.AUDIO_ROUTE_CHANGED)
+            }
+
+            OnStartObserving(CallEvents.INCOMING_CALL_REPORTED) {
+                CallEventEmitter.startObserving(CallEvents.INCOMING_CALL_REPORTED)
+            }
+            OnStopObserving(CallEvents.INCOMING_CALL_REPORTED) {
+                CallEventEmitter.stopObserving(CallEvents.INCOMING_CALL_REPORTED)
+            }
+
+            OnStartObserving(CallEvents.OUTGOING_CALL_STARTED) {
+                CallEventEmitter.startObserving(CallEvents.OUTGOING_CALL_STARTED)
+            }
+            OnStopObserving(CallEvents.OUTGOING_CALL_STARTED) {
+                CallEventEmitter.stopObserving(CallEvents.OUTGOING_CALL_STARTED)
+            }
+
+            OnStartObserving(CallEvents.CALL_ANSWERED) {
+                CallEventEmitter.startObserving(CallEvents.CALL_ANSWERED)
+            }
+            OnStopObserving(CallEvents.CALL_ANSWERED) {
+                CallEventEmitter.stopObserving(CallEvents.CALL_ANSWERED)
+            }
+
+            OnStartObserving(CallEvents.CALL_ENDED) {
+                CallEventEmitter.startObserving(CallEvents.CALL_ENDED)
+            }
+            OnStopObserving(CallEvents.CALL_ENDED) {
+                CallEventEmitter.stopObserving(CallEvents.CALL_ENDED)
+            }
+
+            OnStartObserving(CallEvents.CALL_REPORTED_ENDED) {
+                CallEventEmitter.startObserving(CallEvents.CALL_REPORTED_ENDED)
+            }
+            OnStopObserving(CallEvents.CALL_REPORTED_ENDED) {
+                CallEventEmitter.stopObserving(CallEvents.CALL_REPORTED_ENDED)
+            }
+
+            OnStartObserving(CallEvents.SET_MUTED_ACTION) {
+                CallEventEmitter.startObserving(CallEvents.SET_MUTED_ACTION)
+            }
+            OnStopObserving(CallEvents.SET_MUTED_ACTION) {
+                CallEventEmitter.stopObserving(CallEvents.SET_MUTED_ACTION)
+            }
+
+            OnStartObserving(CallEvents.VIDEO_CHANGED) {
+                CallEventEmitter.startObserving(CallEvents.VIDEO_CHANGED)
+            }
+            OnStopObserving(CallEvents.VIDEO_CHANGED) {
+                CallEventEmitter.stopObserving(CallEvents.VIDEO_CHANGED)
+            }
+
+            OnStartObserving(CallEvents.SET_HELD_ACTION) {
+                CallEventEmitter.startObserving(CallEvents.SET_HELD_ACTION)
+            }
+            OnStopObserving(CallEvents.SET_HELD_ACTION) {
+                CallEventEmitter.stopObserving(CallEvents.SET_HELD_ACTION)
+            }
+
+            OnStartObserving(CallEvents.DTMF) {
+                CallEventEmitter.startObserving(CallEvents.DTMF)
+            }
+            OnStopObserving(CallEvents.DTMF) {
+                CallEventEmitter.stopObserving(CallEvents.DTMF)
+            }
+
+            OnStartObserving(CallEvents.CALL_INTENT_RECEIVED) {
+                CallEventEmitter.startObserving(CallEvents.CALL_INTENT_RECEIVED)
+            }
+            OnStopObserving(CallEvents.CALL_INTENT_RECEIVED) {
+                CallEventEmitter.stopObserving(CallEvents.CALL_INTENT_RECEIVED)
+            }
+
+            OnStartObserving(CallEvents.VOIP_PUSH_TOKEN_UPDATED) {
+                CallEventEmitter.startObserving(CallEvents.VOIP_PUSH_TOKEN_UPDATED)
+            }
+            OnStopObserving(CallEvents.VOIP_PUSH_TOKEN_UPDATED) {
+                CallEventEmitter.stopObserving(CallEvents.VOIP_PUSH_TOKEN_UPDATED)
+            }
+
+            // endregion
+
+            // region Call Session
+
+            // Returns the first active call session, if present.
+            AsyncFunction("getActiveCallSession") {
+                CallStore.firstSession()?.toMap()
+            }
+
+            // endregion
+
+            // region Audio Session
+
+            // Returns current audio session snapshot for diagnostics/UI state.
+            Function("getAudioSessionState") {
+                CallAudioManager.getAudioSessionState()
+            }
+
+            // Prepares audio session state before starting/reporting a call.
+            Function("prepareAudioSessionForCall") { hasVideo: Boolean ->
+                CallAudioManager.prepareAudioSessionForCall(hasVideo)
+            }
+
+            // Restores pre-call audio mode/route state.
+            Function("restoreAudioSession") {
+                CallAudioManager.restoreAudioSession()
+            }
+
+            // Overrides route to speaker (true) or clears override (false).
+            Function("setAudioSessionPortOverride") { enabled: Boolean ->
+                CallAudioManager.setAudioSessionPortOverride(enabled)
+            }
+
+            // endregion
+
+            // region Capture Session
+
+            // Returns capture session state (currently camera permission).
+            Function("getCaptureSessionState") {
+                CaptureSessionManager.getCaptureSessionState()
+            }
+
+            // endregion
+
+            // region Start Outgoing Call
+
+            // Starts a new outgoing call and returns the native call session ID.
+            AsyncFunction("startOutgoingCall") { recipient: Map<String, Any?>, options: Map<String, Any?> ->
+                val callId =
+                    CallManager.shared.startOutgoingCall(
+                        recipient = CallParticipant.fromMap(recipient),
+                        options = CallOptions(hasVideo = options["hasVideo"] as? Boolean ?: false),
+                    )
+                callId
+            }
+
+            // endregion
+
+            // region Report Incoming Call
+
+            // Reports an incoming call to Telecom from app/push events.
+            AsyncFunction("reportIncomingCall") { event: Map<String, Any?> ->
+                CallManager.shared.reportIncomingCall(IncomingCallEvent.fromMap(event))
+            }
+
+            // endregion
+
+            // region Answer Call
+
+            // Answers an existing incoming call session.
+            AsyncFunction("answerCall") { id: String ->
+                CallManager.shared.answerCall(UUID.fromString(id))
+            }
+
+            // Fulfills pending incoming-call answer once media is connected.
+            AsyncFunction("fulfillIncomingCallAnswered") { requestId: String ->
+                CallManager.shared.fulfillIncomingCallConnected(UUID.fromString(requestId))
+            }
+
+
+
+            // Reports outgoing call media connection established.
+            AsyncFunction("reportOutgoingCallConnected") { id: String ->
+                CallManager.shared.reportOutgoingCallConnected(UUID.fromString(id))
+            }
+
+            // endregion
+
+            // region End Call
+
+            // Ends an active call.
+            AsyncFunction("endCall") { id: String ->
+                CallManager.shared.endCall(UUID.fromString(id))
+            }
+
+            // Reports an externally-ended call with explicit reason.
+            AsyncFunction("reportCallEnded") { id: String, reason: String ->
+                CallManager.shared.reportCallEnded(
+                    UUID.fromString(id),
+                    CallEndedReason.fromValue(reason),
+                )
+            }
+
+            // endregion
+
+            // region Mute Support
+
+            // Sets mute state for a call.
+            AsyncFunction("setMuted") { id: String, muted: Boolean ->
+                CallManager.shared.setMuted(UUID.fromString(id), muted)
+            }
+
+            // endregion
+
+            // region Video Support
+
+            // Reports call video enabled state changes.
+            AsyncFunction("reportVideo") { id: String, enabled: Boolean ->
+                CallManager.shared.reportVideo(UUID.fromString(id), enabled)
+            }
+
+            // endregion
+
+            // region Hold Support
+
+            // Sets call hold state.
+            AsyncFunction("setHeld") { id: String, onHold: Boolean ->
+                CallManager.shared.setHeld(UUID.fromString(id), onHold)
+            }
+
+            // endregion
+
+            // region DTMF Support
+
+            // Sends requested DTMF digits for a call.
+            AsyncFunction("playDTMF") { id: String, digits: String ->
+                CallManager.shared.playDTMF(UUID.fromString(id), digits)
+            }
+
+            // endregion
+
+            // region VoIP Push
+
+            // Registers for VoIP push by fetching the FCM token.
+            Function("registerVoIPPush") {
+                VoIPPushManager.register()
+            }
+
+            // Returns the current VoIP push token and its type.
+            Function("getVoIPPushToken") {
+                mapOf(
+                    "token" to VoIPPushManager.token,
+                    "type" to "FCM",
+                )
+            }
+
+            // endregion
+        }
+}