expo-callkit-telecom 0.1.0

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

@@ -0,0 +1,275 @@
+package expo.modules.callkittelecom
+
+import android.app.Activity
+import android.app.KeyguardManager
+import android.content.Context
+import android.content.Intent
+import android.graphics.BitmapFactory
+import android.os.Bundle
+import android.view.View
+import android.view.WindowManager
+import android.widget.ImageButton
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.core.graphics.drawable.RoundedBitmapDrawableFactory
+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 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).
+ *
+ * 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.
+ */
+class IncomingCallActivity : Activity() {
+    companion object {
+        private const val TAG = "ExpoCallKitTelecom.IncomingCallActivity"
+        const val EXTRA_CALL_ID = "expo.modules.callkittelecom.EXTRA_CALL_ID"
+    }
+
+    private var callId: UUID? = null
+    private var isAnswering = false
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        configureWindowForLockScreen()
+        setContentView(R.layout.activity_incoming_call)
+
+        val id = parseCallId() ?: return
+        callId = id
+
+        val session = CallStore.session(id)
+        if (session == null || session.status != CallSessionStatus.RINGING) {
+            CallKitTelecomLog.d(TAG) { "No ringing session for $id, finishing" }
+            finish()
+            return
+        }
+
+        val caller = session.remoteParticipants.firstOrNull()
+
+        bindAppBranding()
+        bindCallerInfo(caller?.displayName, session.options.hasVideo)
+        loadAvatar(caller?.avatarUrl)
+        bindButtons(id, session.options.hasVideo)
+        observeSessionChanges(id)
+
+        CallKitTelecomLog.d(TAG) { "Showing incoming call UI - callId: $id" }
+    }
+
+    @Suppress("DEPRECATION")
+    private fun configureWindowForLockScreen() {
+        setShowWhenLocked(true)
+        setTurnScreenOn(true)
+        window.addFlags(
+            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON or
+                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON,
+        )
+    }
+
+    private fun parseCallId(): UUID? {
+        val callIdStr = intent.getStringExtra(EXTRA_CALL_ID)
+        return try {
+            UUID.fromString(callIdStr)
+        } catch (_: Exception) {
+            CallKitTelecomLog.e(TAG) { "Invalid or missing call ID: $callIdStr" }
+            finish()
+            null
+        }
+    }
+
+    private fun bindAppBranding() {
+        try {
+            val appInfo = packageManager.getApplicationInfo(packageName, 0)
+            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) {
+            // Non-critical — branding just won't show
+        }
+    }
+
+    private fun bindCallerInfo(
+        displayName: String?,
+        hasVideo: Boolean,
+    ) {
+        val name = displayName ?: "Unknown"
+
+        findViewById<TextView>(R.id.expo_callkit_telecom_avatar_text).text =
+            name.firstOrNull()?.uppercase() ?: "?"
+
+        findViewById<TextView>(R.id.expo_callkit_telecom_caller_name).text = name
+
+        findViewById<TextView>(R.id.expo_callkit_telecom_subtitle).text =
+            if (hasVideo) "Incoming video call" else "Incoming call"
+    }
+
+    /**
+     * 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
+
+        val avatarImage = findViewById<ImageView>(R.id.expo_callkit_telecom_avatar_image)
+        val avatarText = findViewById<TextView>(R.id.expo_callkit_telecom_avatar_text)
+
+        scope.launch {
+            val drawable =
+                withContext(Dispatchers.IO) {
+                    try {
+                        val connection = URL(avatarUrl).openConnection() as HttpURLConnection
+                        connection.connectTimeout = 5_000
+                        connection.readTimeout = 5_000
+                        val bitmap =
+                            connection.inputStream.use { stream ->
+                                BitmapFactory.decodeStream(stream)
+                            }
+                        bitmap?.let {
+                            RoundedBitmapDrawableFactory.create(resources, it).apply {
+                                isCircular = true
+                            }
+                        }
+                    } catch (e: Exception) {
+                        CallKitTelecomLog.d(TAG) { "Avatar load failed: ${e.message}" }
+                        null
+                    }
+                }
+
+            if (drawable != null) {
+                avatarImage.setImageDrawable(drawable)
+                avatarImage.visibility = View.VISIBLE
+                avatarText.visibility = View.GONE
+            }
+        }
+    }
+
+    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)
+        }
+        answerButton.setOnClickListener { onAnswerTapped(id) }
+
+        findViewById<ImageButton>(R.id.expo_callkit_telecom_decline_button).setOnClickListener {
+            onDeclineTapped(id)
+        }
+    }
+
+    /**
+     * 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.
+     */
+    private fun onAnswerTapped(id: UUID) {
+        if (isAnswering) return
+        isAnswering = true
+        CallKitTelecomLog.d(TAG) { "Answer tapped - callId: $id" }
+
+        // Answer immediately — don't wait for keyguard dismissal
+        CallManager.shared.answerCall(id)
+
+        // Dismiss keyguard, then bring the main app to the foreground
+        val keyguardManager = getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+        keyguardManager.requestDismissKeyguard(
+            this,
+            object : KeyguardManager.KeyguardDismissCallback() {
+                override fun onDismissSucceeded() {
+                    launchMainActivity()
+                    finish()
+                }
+
+                override fun onDismissCancelled() {
+                    // User cancelled unlock — call is still answered, launch anyway
+                    launchMainActivity()
+                    finish()
+                }
+
+                override fun onDismissError() {
+                    launchMainActivity()
+                    finish()
+                }
+            },
+        )
+    }
+
+    private fun launchMainActivity() {
+        val intent =
+            packageManager.getLaunchIntentForPackage(packageName)?.apply {
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP
+            }
+        if (intent != null) {
+            startActivity(intent)
+        }
+    }
+
+    private fun onDeclineTapped(id: UUID) {
+        CallKitTelecomLog.d(TAG) { "Decline tapped - callId: $id" }
+        CallManager.shared.endCall(id)
+        finish()
+    }
+
+    /**
+     * 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.
+     */
+    private fun observeSessionChanges(id: UUID) {
+        scope.launch {
+            CallStore.sessionUpdates(id).collect { session ->
+                if (session.status == CallSessionStatus.ENDED) {
+                    finish()
+                } else if (!isAnswering && session.status != CallSessionStatus.RINGING) {
+                    CallKitTelecomLog.d(TAG) { "Call no longer ringing (${session.status.value}), finishing" }
+                    finish()
+                }
+            }
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        val id = callId ?: return
+        val session = CallStore.session(id)
+        if (session == null || session.status == CallSessionStatus.ENDED) {
+            finish()
+        } else if (!isAnswering && session.status != CallSessionStatus.RINGING) {
+            finish()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        scope.cancel()
+    }
+}

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

@@ -0,0 +1,151 @@
+package expo.modules.callkittelecom.events
+
+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,
+)
+
+/**
+ * Event bridge between Android native call state and the Expo JS module.
+ *
+ * Behavior:
+ * - Tracks which individual events are being observed by JS
+ * - Queues events that arrive before observers mount
+ * - Flushes queued events with `{ meta: { flushed: true } }`
+ *
+ * All mutable state is guarded by [lock] for thread safety.
+ */
+object CallEventEmitter {
+    private const val TAG = "ExpoCallKitTelecom.Emitter"
+
+    private val lock = Any()
+    private val observingEvents = mutableSetOf<String>()
+    private val eventQueues = mutableMapOf<String, MutableList<QueuedEvent>>()
+    private val queueLimits = mutableMapOf<String, Int?>()
+
+    var defaultQueueLimit: Int? = 0
+
+    @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)?) {
+        sender = eventSender
+    }
+
+    /**
+     * Configures queue size for a specific event.
+     *
+     * `null` means unlimited queueing, `0` disables queueing.
+     */
+    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.
+     */
+    fun send(
+        eventName: String,
+        body: Map<String, Any?>,
+    ) {
+        val timestamp = Instant.now()
+        val senderRef = sender
+        val isObserving = synchronized(lock) { observingEvents.contains(eventName) }
+
+        if (senderRef != null && isObserving) {
+            CallKitTelecomLog.d(TAG) { "Sending event to JS - name: $eventName" }
+            senderRef(eventName, buildEventBody(body, flushed = false, timestamp = timestamp))
+            return
+        }
+        queueEvent(eventName, body, timestamp)
+    }
+
+    /** Marks an event as observed and flushes any pending queue for that event. */
+    fun startObserving(eventName: String) {
+        val queueCount: Int
+        synchronized(lock) {
+            queueCount = eventQueues[eventName]?.size ?: 0
+            observingEvents.add(eventName)
+        }
+        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)
+        }
+    }
+
+    /** Adds native event metadata used by TypeScript event types. */
+    private fun buildEventBody(
+        body: Map<String, Any?>,
+        flushed: Boolean,
+        timestamp: Instant,
+    ): Map<String, Any?> {
+        val result = body.toMutableMap()
+        result["meta"] =
+            mapOf(
+                "flushed" to flushed,
+                "timestamp" to DateTimeFormatter.ISO_INSTANT.format(timestamp),
+            )
+        return result
+    }
+
+    /** Queues an event and enforces per-event queue limits (drop oldest first). */
+    private fun queueEvent(
+        name: String,
+        body: Map<String, Any?>,
+        timestamp: Instant,
+    ) {
+        synchronized(lock) {
+            val limit = queueLimits[name] ?: defaultQueueLimit
+            if (limit == 0) {
+                CallKitTelecomLog.d(TAG) { "Dropping event (queueing disabled) - name: $name" }
+                return
+            }
+
+            val queue = eventQueues.getOrPut(name) { mutableListOf() }
+            queue += QueuedEvent(body = body, timestamp = timestamp)
+
+            if (limit != null && queue.size > limit) {
+                val dropCount = queue.size - limit
+                repeat(dropCount) {
+                    queue.removeAt(0)
+                }
+                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}" }
+            }
+        }
+    }
+
+    /** Flushes all queued events for a single event name. */
+    private fun flushQueue(eventName: String) {
+        val senderRef = sender ?: return
+        val queue = synchronized(lock) { eventQueues.remove(eventName) } ?: return
+        if (queue.isEmpty()) return
+
+        CallKitTelecomLog.d(TAG) { "Flushing event queue - event: $eventName, count: ${queue.size}" }
+        queue.forEach { event ->
+            senderRef(
+                eventName,
+                buildEventBody(event.body, flushed = true, timestamp = event.timestamp),
+            )
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+package expo.modules.callkittelecom.events
+
+/**
+ * Canonical event names emitted by the Android native call layer.
+ *
+ * These values must stay aligned with the TypeScript listeners in `Calls.ts`.
+ */
+object CallEvents {
+    /** Emitted when a new native call session is created. */
+    const val CALL_SESSION_ADDED = "onCallSessionAdded"
+
+    /** Emitted when an existing native call session changes state. */
+    const val CALL_SESSION_UPDATED = "onCallSessionUpdated"
+
+    /** Emitted when a native call session is removed. */
+    const val CALL_SESSION_REMOVED = "onCallSessionRemoved"
+
+    /** Emitted when call audio has been activated for one or more calls. */
+    const val AUDIO_SESSION_ACTIVATED = "onAudioSessionActivated"
+
+    /** Emitted when call audio has been deactivated after call teardown. */
+    const val AUDIO_SESSION_DEACTIVATED = "onAudioSessionDeactivated"
+
+    /** Emitted when the current input/output route changes. */
+    const val AUDIO_ROUTE_CHANGED = "onAudioRouteChanged"
+
+    /** Emitted after an incoming call is successfully handed to Telecom. */
+    const val INCOMING_CALL_REPORTED = "onIncomingCallReported"
+
+    /** Emitted when an outgoing call has started and JS should connect media. */
+    const val OUTGOING_CALL_STARTED = "onOutgoingCallStarted"
+
+    /** Emitted when an incoming call is answered and media setup should begin. */
+    const val CALL_ANSWERED = "onCallAnswered"
+
+    /** Emitted when the local user/system ends a call. */
+    const val CALL_ENDED = "onCallEnded"
+
+    /** Emitted when the app reports an externally-ended call reason. */
+    const val CALL_REPORTED_ENDED = "onCallReportedEnded"
+
+    /** Emitted when mute state is requested or changed. */
+    const val SET_MUTED_ACTION = "onSetMutedAction"
+
+    /** Emitted when video enabled state changes. */
+    const val VIDEO_CHANGED = "onVideoChanged"
+
+    /** Emitted when hold state is requested or changed. */
+    const val SET_HELD_ACTION = "onSetHeldAction"
+
+    /** Emitted when DTMF digits are requested. */
+    const val DTMF = "onDTMF"
+
+    /** Reserved for call intent integration. */
+    const val CALL_INTENT_RECEIVED = "onCallIntentReceived"
+
+    /** Emitted when the FCM push token is refreshed. */
+    const val VOIP_PUSH_TOKEN_UPDATED = "onVoIPPushTokenUpdated"
+}