expo-callkit-telecom 0.2.0 → 0.2.2

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

@@ -16,26 +16,25 @@ import expo.modules.callkittelecom.managers.CallManager
 import expo.modules.callkittelecom.models.CallSessionStatus
 import expo.modules.callkittelecom.store.CallStore
 import expo.modules.callkittelecom.utils.CallKitTelecomLog
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.UUID
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import java.net.HttpURLConnection
-import java.net.URL
-import java.util.UUID
 
 /**
  * Native full-screen incoming call Activity displayed over the lock screen.
  *
- * Shows caller information with answer/decline buttons. Automatically
- * dismisses when the call leaves the RINGING state (answered, declined,
- * timed out, or ended elsewhere).
+ * Shows caller information with answer/decline buttons. Automatically dismisses when the call
+ * leaves the RINGING state (answered, declined, timed out, or ended elsewhere).
  *
  * Answer flow: answers the call directly, dismisses the keyguard via
- * [KeyguardManager.requestDismissKeyguard], then launches the main Activity
- * so the user sees the in-call UI after unlocking.
+ * [KeyguardManager.requestDismissKeyguard], then launches the main Activity so the user sees the
+ * in-call UI after unlocking.
  */
 class IncomingCallActivity : Activity() {
     companion object {
@@ -81,7 +80,7 @@ class IncomingCallActivity : Activity() {
         window.addFlags(
             WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON or
                 WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON,
+                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
         )
     }
 
@@ -99,9 +98,8 @@ class IncomingCallActivity : Activity() {
     private fun bindAppBranding() {
         try {
             val appInfo = packageManager.getApplicationInfo(packageName, 0)
-            findViewById<ImageView>(R.id.expo_callkit_telecom_app_icon).setImageDrawable(
-                packageManager.getApplicationIcon(appInfo),
-            )
+            findViewById<ImageView>(R.id.expo_callkit_telecom_app_icon)
+                .setImageDrawable(packageManager.getApplicationIcon(appInfo))
             findViewById<TextView>(R.id.expo_callkit_telecom_app_name).text =
                 packageManager.getApplicationLabel(appInfo)
         } catch (_: Exception) {
@@ -109,10 +107,7 @@ class IncomingCallActivity : Activity() {
         }
     }
 
-    private fun bindCallerInfo(
-        displayName: String?,
-        hasVideo: Boolean,
-    ) {
+    private fun bindCallerInfo(displayName: String?, hasVideo: Boolean) {
         val name = displayName ?: "Unknown"
 
         findViewById<TextView>(R.id.expo_callkit_telecom_avatar_text).text =
@@ -125,9 +120,9 @@ class IncomingCallActivity : Activity() {
     }
 
     /**
-     * Loads the caller's avatar from [avatarUrl] on a background thread.
-     * On success, displays a circular-cropped image and hides the initial letter.
-     * On failure, silently keeps the initial letter fallback.
+     * Loads the caller's avatar from [avatarUrl] on a background thread. On success, displays a
+     * circular-cropped image and hides the initial letter. On failure, silently keeps the initial
+     * letter fallback.
      */
     private fun loadAvatar(avatarUrl: String?) {
         if (avatarUrl.isNullOrBlank()) return
@@ -165,10 +160,7 @@ class IncomingCallActivity : Activity() {
         }
     }
 
-    private fun bindButtons(
-        id: UUID,
-        hasVideo: Boolean,
-    ) {
+    private fun bindButtons(id: UUID, hasVideo: Boolean) {
         val answerButton = findViewById<ImageButton>(R.id.expo_callkit_telecom_answer_button)
         if (hasVideo) {
             answerButton.setImageResource(R.drawable.expo_callkit_telecom_ic_videocam)
@@ -181,12 +173,12 @@ class IncomingCallActivity : Activity() {
     }
 
     /**
-     * Answers the call directly, then dismisses the keyguard and launches
-     * the main Activity so the user transitions into the in-call UI.
+     * Answers the call directly, then dismisses the keyguard and launches the main Activity so the
+     * user transitions into the in-call UI.
      *
-     * The call is answered immediately (media connection starts) regardless
-     * of whether the keyguard dismissal succeeds. This matches the behavior
-     * of iOS CallKit where audio connects before the device is unlocked.
+     * The call is answered immediately (media connection starts) regardless of whether the keyguard
+     * dismissal succeeds. This matches the behavior of iOS CallKit where audio connects before the
+     * device is unlocked.
      */
     private fun onAnswerTapped(id: UUID) {
         if (isAnswering) return
@@ -237,12 +229,11 @@ class IncomingCallActivity : Activity() {
     }
 
     /**
-     * Observes session updates to auto-dismiss when the call is no longer ringing
-     * (answered elsewhere, timed out, or ended by the remote side).
+     * Observes session updates to auto-dismiss when the call is no longer ringing (answered
+     * elsewhere, timed out, or ended by the remote side).
      *
-     * When [isAnswering] is true (user tapped answer locally), only auto-dismiss
-     * for ENDED status — the CONNECTING transition is expected and handled by
-     * the keyguard dismissal flow.
+     * When [isAnswering] is true (user tapped answer locally), only auto-dismiss for ENDED status —
+     * the CONNECTING transition is expected and handled by the keyguard dismissal flow.
      */
     private fun observeSessionChanges(id: UUID) {
         scope.launch {
@@ -250,7 +241,9 @@ class IncomingCallActivity : Activity() {
                 if (session.status == CallSessionStatus.ENDED) {
                     finish()
                 } else if (!isAnswering && session.status != CallSessionStatus.RINGING) {
-                    CallKitTelecomLog.d(TAG) { "Call no longer ringing (${session.status.value}), finishing" }
+                    CallKitTelecomLog.d(TAG) {
+                        "Call no longer ringing (${session.status.value}), finishing"
+                    }
                     finish()
                 }
             }

package/android/src/main/java/expo/modules/callkittelecom/events/CallEventEmitter.kt

@@ -4,10 +4,7 @@ import expo.modules.callkittelecom.utils.CallKitTelecomLog
 import java.time.Instant
 import java.time.format.DateTimeFormatter
 
-private data class QueuedEvent(
-    val body: Map<String, Any?>,
-    val timestamp: Instant,
-)
+private data class QueuedEvent(val body: Map<String, Any?>, val timestamp: Instant)
 
 /**
  * Event bridge between Android native call state and the Expo JS module.
@@ -29,8 +26,7 @@ object CallEventEmitter {
 
     var defaultQueueLimit: Int? = 0
 
-    @Volatile
-    private var sender: ((String, Map<String, Any?>) -> Unit)? = null
+    @Volatile private var sender: ((String, Map<String, Any?>) -> Unit)? = null
 
     /** Sets or clears the active event sender provided by the Expo module. */
     fun setSender(eventSender: ((String, Map<String, Any?>) -> Unit)?) {
@@ -42,24 +38,17 @@ object CallEventEmitter {
      *
      * `null` means unlimited queueing, `0` disables queueing.
      */
-    fun setQueueLimit(
-        eventName: String,
-        limit: Int?,
-    ) {
-        synchronized(lock) {
-            queueLimits[eventName] = limit
-        }
+    fun setQueueLimit(eventName: String, limit: Int?) {
+        synchronized(lock) { queueLimits[eventName] = limit }
     }
 
     /**
      * Sends an event to JS if it is currently observed, or queues it otherwise.
      *
-     * All delivered events are augmented with a `meta` object containing timestamp and flush status.
+     * All delivered events are augmented with a `meta` object containing timestamp and flush
+     * status.
      */
-    fun send(
-        eventName: String,
-        body: Map<String, Any?>,
-    ) {
+    fun send(eventName: String, body: Map<String, Any?>) {
         val timestamp = Instant.now()
         val senderRef = sender
         val isObserving = synchronized(lock) { observingEvents.contains(eventName) }
@@ -79,16 +68,16 @@ object CallEventEmitter {
             queueCount = eventQueues[eventName]?.size ?: 0
             observingEvents.add(eventName)
         }
-        CallKitTelecomLog.d(TAG) { "Start observing - event: $eventName, queuedEvents: $queueCount" }
+        CallKitTelecomLog.d(TAG) {
+            "Start observing - event: $eventName, queuedEvents: $queueCount"
+        }
         flushQueue(eventName)
     }
 
     /** Marks an event as no longer observed by JS. */
     fun stopObserving(eventName: String) {
         CallKitTelecomLog.d(TAG) { "Stop observing - event: $eventName" }
-        synchronized(lock) {
-            observingEvents.remove(eventName)
-        }
+        synchronized(lock) { observingEvents.remove(eventName) }
     }
 
     /** Adds native event metadata used by TypeScript event types. */
@@ -107,11 +96,7 @@ object CallEventEmitter {
     }
 
     /** Queues an event and enforces per-event queue limits (drop oldest first). */
-    private fun queueEvent(
-        name: String,
-        body: Map<String, Any?>,
-        timestamp: Instant,
-    ) {
+    private fun queueEvent(name: String, body: Map<String, Any?>, timestamp: Instant) {
         synchronized(lock) {
             val limit = queueLimits[name] ?: defaultQueueLimit
             if (limit == 0) {
@@ -124,12 +109,14 @@ object CallEventEmitter {
 
             if (limit != null && queue.size > limit) {
                 val dropCount = queue.size - limit
-                repeat(dropCount) {
-                    queue.removeAt(0)
+                repeat(dropCount) { queue.removeAt(0) }
+                CallKitTelecomLog.d(TAG) {
+                    "Queueing event (dropped $dropCount old) - name: $name, queueSize: ${queue.size}"
                 }
-                CallKitTelecomLog.d(TAG) { "Queueing event (dropped $dropCount old) - name: $name, queueSize: ${queue.size}" }
             } else {
-                CallKitTelecomLog.d(TAG) { "Queueing event (JS not listening) - name: $name, queueSize: ${queue.size}" }
+                CallKitTelecomLog.d(TAG) {
+                    "Queueing event (JS not listening) - name: $name, queueSize: ${queue.size}"
+                }
             }
         }
     }
@@ -140,7 +127,9 @@ object CallEventEmitter {
         val queue = synchronized(lock) { eventQueues.remove(eventName) } ?: return
         if (queue.isEmpty()) return
 
-        CallKitTelecomLog.d(TAG) { "Flushing event queue - event: $eventName, count: ${queue.size}" }
+        CallKitTelecomLog.d(TAG) {
+            "Flushing event queue - event: $eventName, count: ${queue.size}"
+        }
         queue.forEach { event ->
             senderRef(
                 eventName,

package/android/src/main/java/expo/modules/callkittelecom/managers/CallAudioManager.kt

@@ -14,9 +14,8 @@ import expo.modules.callkittelecom.utils.PermissionUtils
 /**
  * Manages Android call audio state and routing for the shared calls API.
  *
- * Audio focus and mode are managed by Core-Telecom. This manager tracks
- * endpoint state, emits route changes to JS, and requests endpoint switches
- * via the active call scope.
+ * Audio focus and mode are managed by Core-Telecom. This manager tracks endpoint state, emits route
+ * changes to JS, and requests endpoint switches via the active call scope.
  */
 object CallAudioManager {
     private const val TAG = "ExpoCallKitTelecom.Audio"
@@ -55,14 +54,14 @@ object CallAudioManager {
                 }
 
                 override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>) {
-                    CallKitTelecomLog.d(TAG) { "Audio devices removed - count: ${removedDevices.size}" }
+                    CallKitTelecomLog.d(TAG) {
+                        "Audio devices removed - count: ${removedDevices.size}"
+                    }
                     if (!isActive) emitRouteChanged()
                 }
             }
 
-        routeCallback?.let { callback ->
-            audioManager.registerAudioDeviceCallback(callback, null)
-        }
+        routeCallback?.let { callback -> audioManager.registerAudioDeviceCallback(callback, null) }
 
         isInitialized = true
         CallKitTelecomLog.d(TAG) { "Initialized CallAudioManager" }
@@ -83,15 +82,14 @@ object CallAudioManager {
     /** Returns current audio session state in the shared TypeScript shape. */
     fun getAudioSessionState(): Map<String, Any?> {
         val sampleRate =
-            audioManager
-                .getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE)
-                ?.toDoubleOrNull()
+            audioManager.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE)?.toDoubleOrNull()
         val framesPerBuffer =
             audioManager
                 .getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER)
                 ?.toDoubleOrNull()
         val ioBufferDuration =
-            if (sampleRate != null && framesPerBuffer != null) framesPerBuffer / sampleRate else null
+            if (sampleRate != null && framesPerBuffer != null) framesPerBuffer / sampleRate
+            else null
 
         val currentRoute = currentRouteMap()
 
@@ -118,7 +116,9 @@ object CallAudioManager {
 
     /** No-op on Android — Core-Telecom manages audio mode and focus. Kept for JS API compat. */
     fun restoreAudioSession() {
-        CallKitTelecomLog.d(TAG) { "restoreAudioSession is a no-op on Android (Core-Telecom manages audio)" }
+        CallKitTelecomLog.d(TAG) {
+            "restoreAudioSession is a no-op on Android (Core-Telecom manages audio)"
+        }
     }
 
     /**
@@ -133,18 +133,9 @@ object CallAudioManager {
 
         isActive = true
 
-        val callInfos =
-            calls.map {
-                mapOf(
-                    "id" to it.id.toString(),
-                    "status" to it.status.value,
-                )
-            }
+        val callInfos = calls.map { mapOf("id" to it.id.toString(), "status" to it.status.value) }
 
-        CallEventEmitter.send(
-            CallEvents.AUDIO_SESSION_ACTIVATED,
-            mapOf("calls" to callInfos),
-        )
+        CallEventEmitter.send(CallEvents.AUDIO_SESSION_ACTIVATED, mapOf("calls" to callInfos))
     }
 
     /**
@@ -164,18 +155,9 @@ object CallAudioManager {
 
         emitRouteChanged()
 
-        val callInfos =
-            calls.map {
-                mapOf(
-                    "id" to it.id.toString(),
-                    "status" to it.status.value,
-                )
-            }
+        val callInfos = calls.map { mapOf("id" to it.id.toString(), "status" to it.status.value) }
 
-        CallEventEmitter.send(
-            CallEvents.AUDIO_SESSION_DEACTIVATED,
-            mapOf("calls" to callInfos),
-        )
+        CallEventEmitter.send(CallEvents.AUDIO_SESSION_DEACTIVATED, mapOf("calls" to callInfos))
     }
 
     /** Requests endpoint change to speaker (`true`) or best non-speaker device (`false`). */
@@ -195,18 +177,22 @@ object CallAudioManager {
     }
 
     /**
-     * Selects the best non-speaker endpoint matching iOS priority:
-     * Bluetooth > Wired Headset > Earpiece (audio) / Speaker (video).
+     * Selects the best non-speaker endpoint matching iOS priority: Bluetooth > Wired Headset >
+     * Earpiece (audio) / Speaker (video).
      */
     private fun selectBestNonSpeakerEndpoint(): CallEndpointCompat? {
         val available = currentAvailableEndpoints
 
         available
             .firstOrNull { it.type == CallEndpointCompat.TYPE_BLUETOOTH }
-            ?.let { return it }
+            ?.let {
+                return it
+            }
         available
             .firstOrNull { it.type == CallEndpointCompat.TYPE_WIRED_HEADSET }
-            ?.let { return it }
+            ?.let {
+                return it
+            }
 
         return if (configuredForVideo) {
             available.firstOrNull { it.type == CallEndpointCompat.TYPE_SPEAKER }
@@ -219,16 +205,13 @@ object CallAudioManager {
     private fun emitRouteChanged() {
         CallEventEmitter.send(
             CallEvents.AUDIO_ROUTE_CHANGED,
-            mapOf(
-                "currentRoute" to currentRouteMap(),
-                "availableRoutes" to availableRoutesMap(),
-            ),
+            mapOf("currentRoute" to currentRouteMap(), "availableRoutes" to availableRoutesMap()),
         )
     }
 
     /**
-     * Converts Core-Telecom available endpoints into JS-facing AudioPort objects.
-     * Each endpoint maps to a single output port.
+     * Converts Core-Telecom available endpoints into JS-facing AudioPort objects. Each endpoint
+     * maps to a single output port.
      */
     private fun availableRoutesMap(): List<Map<String, String>> =
         currentAvailableEndpoints.mapNotNull { endpoint -> resolveOutputPort(endpoint) }
@@ -236,38 +219,40 @@ object CallAudioManager {
     /**
      * Builds the current route payload with the single active input/output device.
      *
-     * During an active call, uses Core-Telecom's [CallEndpointCompat] to determine
-     * the active device (matching iOS's `AVAudioSession.currentRoute` behavior).
-     * When no call is active, falls back to built-in defaults.
+     * During an active call, uses Core-Telecom's [CallEndpointCompat] to determine the active
+     * device (matching iOS's `AVAudioSession.currentRoute` behavior). When no call is active, falls
+     * back to built-in defaults.
      */
     private fun currentRouteMap(): Map<String, Any?> {
         val endpoint = currentEndpoint
         if (endpoint != null) {
             val output = resolveOutputPort(endpoint)
             val input = resolveInputPort(endpoint.type)
-            return mapOf(
-                "inputs" to listOfNotNull(input),
-                "outputs" to listOfNotNull(output),
-            )
+            return mapOf("inputs" to listOfNotNull(input), "outputs" to listOfNotNull(output))
         }
 
-        val input = findDevicePort(AudioManager.GET_DEVICES_INPUTS, AudioDeviceInfo.TYPE_BUILTIN_MIC)
-        val output = findDevicePort(AudioManager.GET_DEVICES_OUTPUTS, AudioDeviceInfo.TYPE_BUILTIN_EARPIECE)
-        return mapOf(
-            "inputs" to listOfNotNull(input),
-            "outputs" to listOfNotNull(output),
-        )
+        val input =
+            findDevicePort(AudioManager.GET_DEVICES_INPUTS, AudioDeviceInfo.TYPE_BUILTIN_MIC)
+        val output =
+            findDevicePort(AudioManager.GET_DEVICES_OUTPUTS, AudioDeviceInfo.TYPE_BUILTIN_EARPIECE)
+        return mapOf("inputs" to listOfNotNull(input), "outputs" to listOfNotNull(output))
     }
 
     /** Maps Core-Telecom endpoint to a port map for the JS layer. */
     private fun resolveOutputPort(endpoint: CallEndpointCompat): Map<String, String>? =
         when (endpoint.type) {
             CallEndpointCompat.TYPE_SPEAKER -> {
-                findDevicePort(AudioManager.GET_DEVICES_OUTPUTS, AudioDeviceInfo.TYPE_BUILTIN_SPEAKER)
+                findDevicePort(
+                    AudioManager.GET_DEVICES_OUTPUTS,
+                    AudioDeviceInfo.TYPE_BUILTIN_SPEAKER,
+                )
             }
 
             CallEndpointCompat.TYPE_EARPIECE -> {
-                findDevicePort(AudioManager.GET_DEVICES_OUTPUTS, AudioDeviceInfo.TYPE_BUILTIN_EARPIECE)
+                findDevicePort(
+                    AudioManager.GET_DEVICES_OUTPUTS,
+                    AudioDeviceInfo.TYPE_BUILTIN_EARPIECE,
+                )
             }
 
             CallEndpointCompat.TYPE_BLUETOOTH -> {
@@ -280,7 +265,10 @@ object CallAudioManager {
 
             CallEndpointCompat.TYPE_WIRED_HEADSET -> {
                 findDevicePort(AudioManager.GET_DEVICES_OUTPUTS, AudioDeviceInfo.TYPE_WIRED_HEADSET)
-                    ?: findDevicePort(AudioManager.GET_DEVICES_OUTPUTS, AudioDeviceInfo.TYPE_WIRED_HEADPHONES)
+                    ?: findDevicePort(
+                        AudioManager.GET_DEVICES_OUTPUTS,
+                        AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+                    )
             }
 
             else -> {
@@ -301,14 +289,8 @@ object CallAudioManager {
     }
 
     /** Finds the first matching device by type and returns its port map. */
-    private fun findDevicePort(
-        direction: Int,
-        type: Int,
-    ): Map<String, String>? =
-        audioManager
-            .getDevices(direction)
-            .firstOrNull { it.type == type }
-            ?.let { portMap(it) }
+    private fun findDevicePort(direction: Int, type: Int): Map<String, String>? =
+        audioManager.getDevices(direction).firstOrNull { it.type == type }?.let { portMap(it) }
 
     /** Serializes an Android audio device into the shared audio port payload shape. */
     private fun portMap(info: AudioDeviceInfo): Map<String, String> =
@@ -326,8 +308,7 @@ object CallAudioManager {
             AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> "builtInSpeaker"
 
             AudioDeviceInfo.TYPE_WIRED_HEADSET,
-            AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
-            -> "headphones"
+            AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> "headphones"
 
             AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> "bluetoothA2DP"
 
@@ -339,12 +320,10 @@ object CallAudioManager {
 
             AudioDeviceInfo.TYPE_USB_DEVICE,
             AudioDeviceInfo.TYPE_USB_ACCESSORY,
-            AudioDeviceInfo.TYPE_USB_HEADSET,
-            -> "usbAudio"
+            AudioDeviceInfo.TYPE_USB_HEADSET -> "usbAudio"
 
             AudioDeviceInfo.TYPE_LINE_ANALOG,
-            AudioDeviceInfo.TYPE_LINE_DIGITAL,
-            -> "lineOut"
+            AudioDeviceInfo.TYPE_LINE_DIGITAL -> "lineOut"
 
             else -> "android_$type"
         }