@stream-io/react-native-callingx 0.1.0-beta.7 → 0.1.1-beta.1

package/android/src/main/java/io/getstream/rn/callingx/StreamMessagingService.kt

@@ -0,0 +1,48 @@
+package io.getstream.rn.callingx
+
+import android.annotation.SuppressLint
+import com.google.firebase.messaging.RemoteMessage
+import io.invertase.firebase.messaging.ReactNativeFirebaseMessagingService
+
+/**
+ * Extends React Native Firebase's messaging service to start [CallService] when a
+ * data message contains "stream" (e.g. incoming call push), then delegates to the
+ * parent so setBackgroundMessageHandler() still runs in JS.
+ *
+ * Only compiled when the app has @react-native-firebase/app and @react-native-firebase/messaging
+ * as dependencies. The app must remove the default [io.invertase.firebase.messaging.ReactNativeFirebaseMessagingService] from
+ * the merged manifest so this service is the single FCM handler
+ */
+@SuppressLint("MissingFirebaseInstanceTokenRefresh")
+class StreamMessagingService : ReactNativeFirebaseMessagingService() {
+
+  companion object {
+    const val TAG = "[Callingx] StreamMessagingService"
+  }
+
+  override fun onMessageReceived(remoteMessage: RemoteMessage) {
+    val data = remoteMessage.data
+    debugLog(TAG, "onMessageReceived data = $data")
+
+    val isSupportedStreamVideoCallRing =
+      data["sender"] == "stream.video" && data["type"] == "call.ring"
+
+    if (isSupportedStreamVideoCallRing) {
+      val callCid = data["call_cid"]
+      if (callCid.isNullOrEmpty()) {
+        debugLog(
+          TAG,
+          "missing call_cid for call.ring, skipping CallService start",
+        )
+      } else {
+        CallService.startIncomingCallFromPush(applicationContext, data)
+      }
+    } else {
+      debugLog(TAG, "sender or type is not supported, skipping CallService start")
+    }
+
+    // Let React Native Firebase continue its normal processing so
+    // setBackgroundMessageHandler() still runs in JS.
+    super.onMessageReceived(remoteMessage)
+  }
+}

package/android/src/main/java/io/getstream/rn/callingx/model/Call.kt

@@ -27,6 +27,7 @@ sealed class Call {
         val isActive: Boolean,
         val isOnHold: Boolean,
         val isMuted: Boolean,
+        val isPending: Boolean,
         val errorCode: Int?,
         val currentCallEndpoint: CallEndpointCompat?,
         val availableCallEndpoints: List<CallEndpointCompat>,

package/android/src/main/java/io/getstream/rn/callingx/notifications/CallNotificationManager.kt

@@ -20,11 +20,15 @@ import io.getstream.rn.callingx.debugLog
 import io.getstream.rn.callingx.getDisconnectCauseString
 import io.getstream.rn.callingx.model.Call
 import io.getstream.rn.callingx.repo.CallRepository
+import io.getstream.rn.callingx.utils.SettingsStore
+import androidx.core.graphics.toColorInt
 
 /**
  * Handles call status changes and updates the notification accordingly. For more guidance around
  * notifications check https://developer.android.com/develop/ui/views/notifications
  *
+ * Supports multiple simultaneous call notifications, each keyed by callId.
+ *
  * @see updateCallNotification
  */
 class CallNotificationManager(
@@ -35,110 +39,229 @@ class CallNotificationManager(
 
     internal companion object {
         private const val TAG = "[Callingx] CallNotificationManager"
-
-        const val NOTIFICATION_ID = 200
+        private const val DISABLED_COLOR = "#757575" // NOTE: hint color might be ignored by OS
     }
 
+    enum class OptimisticState { NONE, ACCEPTING, REJECTING }
+
+    private val lock = Any()
+
     private var notificationsConfig = NotificationsConfig.loadNotificationsConfig(context)
 
     private var ringtone: Ringtone? = null
 
-    private var hasBecameActive = false
+    /**
+     * Per-call notification state. Consolidates all per-call tracking into a single struct.
+     */
+    private data class CallNotificationState(
+        val optimisticState: OptimisticState = OptimisticState.NONE,
+        val lastSnapshot: NotificationSnapshot? = null,
+        val activeWhen: Long? = null,
+        val hasBecameActive: Boolean = false,
+    )
+
+    // Per-call state, all guarded by [lock]
+    private val notificationsState = mutableMapOf<String, CallNotificationState>()
 
-    private var lastPostedSnapshot: NotificationSnapshot? = null
+    /** The callId whose notification was used for startForeground(). */
+    private var foregroundCallId: String? = null
+
+    /**
+     * Deterministic per-call notification ID.
+     *
+     * `NotificationManager.notify()`/`cancel()` require a stable integer id for updates/cancels.
+     * We derive it from `callId` so we don't need to allocate/store ids.
+     */
+    private fun getNotificationId(callId: String): Int {
+        // Keep the value non-negative (defensive for Android-side expectations).
+        return callId.hashCode() and 0x7fffffff
+    }
 
     /**
      * Snapshot of call state used to detect notification changes.
-     * Using a data class ensures immutable comparison and avoids issues
-     * with mutable Call.Registered objects.
      */
-    private data class NotificationSnapshot(
+    data class NotificationSnapshot(
         val id: String,
         val isActive: Boolean,
         val isIncoming: Boolean,
+        val optimisticState: OptimisticState,
         val displayTitle: String?,
-        val displaySubtitle: String?,
         val displayName: CharSequence,
         val address: Uri
     )
 
-    private fun Call.Registered.toSnapshot() = NotificationSnapshot(
+    /**
+     * Creates a snapshot of the call state used to detect notification changes.
+     * @return NotificationSnapshot
+     */
+    private fun Call.Registered.toSnapshot(callId: String) = NotificationSnapshot(
         id = id,
         isActive = isActive,
         isIncoming = isIncoming(),
+        optimisticState = notificationsState[callId]?.optimisticState ?: OptimisticState.NONE,
         displayTitle = displayOptions?.getString(CallService.EXTRA_DISPLAY_TITLE),
-        displaySubtitle = displayOptions?.getString(CallService.EXTRA_DISPLAY_SUBTITLE),
         displayName = callAttributes.displayName,
         address = callAttributes.address
     )
 
-    fun createNotification(call: Call.Registered): Notification {
+    fun getOrCreateNotificationId(callId: String): Int = synchronized(lock) {
+        if (!notificationsState.containsKey(callId)) {
+            notificationsState[callId] = CallNotificationState()
+        }
+        if (foregroundCallId == null) {
+            foregroundCallId = callId
+        }
+        return@synchronized getNotificationId(callId)
+    }
+
+    /**
+     * Sets the optimistic state of the call notification.
+     * Optimistic state is used to update the notification text while the app is connecting or declining the call.
+     * @param state The optimistic state to set.
+     */
+    fun setOptimisticState(callId: String, state: OptimisticState) = synchronized(lock) {
+        // Be resilient to races where we receive optimistic actions before a notification state entry exists.
+        val current =
+            notificationsState[callId]
+                ?: CallNotificationState().also {
+                    if (foregroundCallId == null) {
+                        foregroundCallId = callId
+                    }
+                }
+        notificationsState[callId] = if (state != OptimisticState.NONE) {
+            current.copy(optimisticState = state, lastSnapshot = null)
+        } else {
+            current.copy(optimisticState = state)
+        }
+    }
+
+    /**
+     * Creates a notification for the call.
+     * Notification is created based on the call state and optimistic state.
+     * @param call The call to create a notification for.
+     * @return The notification.
+     */
+    fun createNotification(callId: String, call: Call.Registered): Notification = synchronized(lock) {
         debugLog(TAG,"[notifications] createNotification: Creating notification for call ID: ${call.id}")
 
+        val state = notificationsState[callId]
+        val optimisticState = state?.optimisticState ?: OptimisticState.NONE
+
         val contentIntent =
                 NotificationIntentFactory.getLaunchActivityIntent(
                         context,
                         CallingxModuleImpl.CALL_ANSWERED_ACTION,
                         call.id
                 )
-        val callStyle = createCallStyle(call)
-        val channelId = getChannelId(call)
+        val callStyle = createCallStyle(call, optimisticState)
+        val channelId = getChannelId(call, optimisticState)
         debugLog(TAG, "[notifications] createNotification: Channel ID: $channelId")
 
         val builder =
                 NotificationCompat.Builder(context, channelId)
                         .setContentIntent(contentIntent)
                         .setFullScreenIntent(contentIntent, true)
-                        .setStyle(callStyle)
                         .setSmallIcon(R.drawable.ic_round_call_24)
                         .setCategory(NotificationCompat.CATEGORY_CALL)
                         .setPriority(NotificationCompat.PRIORITY_MAX)
-                        .setOngoing(true)
+                        .setOngoing(optimisticState != OptimisticState.REJECTING)
 
-        if (!hasBecameActive && call.isActive) {
-            debugLog(TAG, "[notifications] createNotification: Setting when to current time")
-            builder.setWhen(System.currentTimeMillis())
+        builder.setStyle(callStyle)
+
+        // When call becomes active we need to set the when to current time and show the chronometer
+        if (call.isActive && optimisticState == OptimisticState.NONE && state != null) {
+            // We need to set the activation time once when call becomes active
+            if (!state.hasBecameActive) {
+                debugLog(TAG, "[notifications] createNotification: Setting when to current time for $callId")
+                val now = System.currentTimeMillis()
+                notificationsState[callId] = state.copy(activeWhen = now, hasBecameActive = true)
+            }
+            builder.setWhen(notificationsState[callId]?.activeWhen ?: System.currentTimeMillis())
             builder.setUsesChronometer(true)
             builder.setShowWhen(true)
-            hasBecameActive = true
         }
 
-        call.displayOptions?.let {
-            if (it.containsKey(CallService.EXTRA_DISPLAY_SUBTITLE)) {
-                builder.setContentText(it.getString(CallService.EXTRA_DISPLAY_SUBTITLE))
+        // If the call is not active and the optimistic state is not none, we need to set the notification text
+        // based on exact action that is being taken (accepting or rejecting)
+        if (optimisticState != OptimisticState.NONE && !call.isActive) {
+            val text = when (optimisticState) {
+                OptimisticState.ACCEPTING -> SettingsStore.getOptimisticAcceptingText(context)
+                OptimisticState.REJECTING -> SettingsStore.getOptimisticRejectingText(context)
+                else -> null
             }
+            if (text != null) builder.setContentText(text)
         }
 
         return builder.build()
     }
 
-    fun updateCallNotification(call: Call) {
-        when (call) {
-            Call.None, is Call.Unregistered -> {
-                debugLog(TAG, "[notifications] updateCallNotification: Dismissing notification (call is None or Unregistered)")
-                notificationManager.cancel(NOTIFICATION_ID)
-                lastPostedSnapshot = null
-                hasBecameActive = false
-            }
-            is Call.Registered -> {
-                val newSnapshot = call.toSnapshot()
-                if (newSnapshot == lastPostedSnapshot) {
-                    debugLog(TAG, "[notifications] updateCallNotification: Skipping - no state change")
-                    return
-                }
+    /**
+     * Updates the call notification.
+     * If the call is None or Unregistered, we need to dismiss the notification.
+     * If the call is active and the optimistic state is not none, we need to reset the optimistic state.
+     * If the call is active and the optimistic state is none, we need to create a new notification.
+     * @param call The call to update the notification for.
+     */
+    fun updateCallNotification(callId: String, call: Call.Registered) = synchronized(lock) {
+        val state = notificationsState[callId]
+        val optimisticState = state?.optimisticState ?: OptimisticState.NONE
+        if (call.isActive && optimisticState != OptimisticState.NONE && state != null) {
+            notificationsState[callId] = state.copy(optimisticState = OptimisticState.NONE)
+            debugLog(TAG, "[notifications] updateCallNotification[$callId]: Resetting optimistic state")
+        }
 
-                lastPostedSnapshot = newSnapshot
-                val notification = createNotification(call)
-                notificationManager.notify(NOTIFICATION_ID, notification)
-                debugLog(TAG, "[notifications] updateCallNotification: Notification posted successfully")
+        // If the new snapshot is the same as the last posted snapshot, we need to skip the update
+        val newSnapshot = call.toSnapshot(callId)
+        if (newSnapshot == notificationsState[callId]?.lastSnapshot) {
+            debugLog(TAG, "[notifications] updateCallNotification[$callId]: Skipping - no state change")
+            return@synchronized
+        }
+
+        val notificationId = getOrCreateNotificationId(callId)
+        notificationsState[callId] =
+            notificationsState[callId]?.copy(lastSnapshot = newSnapshot)
+                ?: CallNotificationState(lastSnapshot = newSnapshot)
+        val notification = createNotification(callId, call)
+        notificationManager.notify(notificationId, notification)
+        debugLog(TAG, "[notifications] updateCallNotification[$callId]: Notification posted (id=$notificationId)")
+    }
+
+    fun postNotification(callId: String, notification: Notification) = synchronized(lock) {
+        val notificationId = getOrCreateNotificationId(callId)
+        notificationManager.notify(notificationId, notification)
+    }
+
+    /**
+     * Returns a new foreground notification ID if the caller needs to call startForeground()
+     * to re-promote the service, or null if no action is needed.
+     */
+    fun cancelNotification(callId: String): Int? = synchronized(lock) {
+        debugLog(TAG, "[notifications] cancelNotification[$callId]")
+        val state = notificationsState.remove(callId)
+        val notificationId = getNotificationId(callId)
+        notificationManager.cancel(notificationId)
+        if (state != null) {
+            debugLog(TAG, "[notifications] cancelNotification[$callId]: Cancelled (id=$notificationId)")
+        }
+
+        if (foregroundCallId == callId) {
+            foregroundCallId = notificationsState.keys.firstOrNull()
+            // Return the new foreground notification ID so the service can re-promote
+            if (foregroundCallId != null) {
+                return@synchronized getNotificationId(foregroundCallId!!)
             }
         }
+        return@synchronized null
     }
 
-    fun cancelNotifications() {
-        notificationManager.cancel(NOTIFICATION_ID)
-        hasBecameActive = false
-        lastPostedSnapshot = null
+    fun getForegroundCallId(): String? = synchronized(lock) { foregroundCallId }
+
+    fun cancelAllNotifications() = synchronized(lock) {
+        for (callId in notificationsState.keys) {
+            notificationManager.cancel(getNotificationId(callId))
+        }
+        notificationsState.clear()
+        foregroundCallId = null
     }
 
     fun startRingtone() {
@@ -174,18 +297,24 @@ class CallNotificationManager(
         ringtone = null
     }
 
-    private fun getChannelId(call: Call.Registered): String {
-        return if (call.isIncoming() && !call.isActive) {
+    fun resetOptimisticState(callId: String) = synchronized(lock) {
+        debugLog(TAG, "[notifications] resetOptimisticState[$callId]: Resetting optimistic state")
+        val current = notificationsState[callId] ?: return@synchronized
+        notificationsState[callId] = current.copy(optimisticState = OptimisticState.NONE, lastSnapshot = null)
+    }
+
+    private fun getChannelId(call: Call.Registered, optimisticState: OptimisticState): String {
+        return if (call.isIncoming() && !call.isActive && optimisticState == OptimisticState.NONE) {
             notificationsConfig.incomingChannel.id
         } else {
             notificationsConfig.ongoingChannel.id
         }
     }
 
-    private fun createCallStyle(call: Call.Registered): NotificationCompat.CallStyle {
+    private fun createCallStyle(call: Call.Registered, optimisticState: OptimisticState): NotificationCompat.CallStyle? {
         val caller = createPerson(call)
 
-        if (call.isIncoming() && !call.isActive) {
+        if (call.isIncoming() && !call.isActive && optimisticState == OptimisticState.NONE) {
             return NotificationCompat.CallStyle.forIncomingCall(
                     caller,
                     NotificationIntentFactory.getPendingBroadcastIntent(
@@ -211,6 +340,17 @@ class CallNotificationManager(
             )
         }
 
+        if (optimisticState == OptimisticState.REJECTING) {
+            return NotificationCompat.CallStyle.forOngoingCall(
+                    caller,
+                    NotificationIntentFactory.getPendingBroadcastIntent(
+                            context,
+                            "io.getstream.CALL_END_NOOP",
+                            call.id
+                    ) ,
+            ).setDeclineButtonColorHint(DISABLED_COLOR.toColorInt())
+        }
+
         return NotificationCompat.CallStyle.forOngoingCall(
                 caller,
                 NotificationIntentFactory.getPendingBroadcastIntent(

package/android/src/main/java/io/getstream/rn/callingx/notifications/NotificationIntentFactory.kt

@@ -5,12 +5,18 @@ import android.content.Context
 import android.content.Intent
 import android.os.Build
 import io.getstream.rn.callingx.CallingxModuleImpl
+import kotlin.math.absoluteValue
 
 object NotificationIntentFactory {
-  // Stable request codes for PendingIntents
+  // Base request codes for PendingIntents — combined with callId hash for uniqueness
   private const val REQUEST_CODE_LAUNCH_ACTIVITY = 1001
-  private const val REQUEST_CODE_RECEIVER_ACTIVITY = 1002
-  private const val REQUEST_CODE_SERVICE = 1003
+  private const val REQUEST_CODE_RECEIVER_ACTIVITY = 2001
+  private const val REQUEST_CODE_SERVICE = 3001
+
+  /** Generates a unique request code per callId + base offset to avoid PendingIntent collisions. */
+  private fun requestCodeFor(callId: String, base: Int): Int {
+    return (base + callId.hashCode()).absoluteValue
+  }
 
   fun getPendingNotificationIntent(
     context: Context,
@@ -35,7 +41,7 @@ object NotificationIntentFactory {
 
     return PendingIntent.getService(
       context,
-      REQUEST_CODE_SERVICE,
+      requestCodeFor(callId, REQUEST_CODE_SERVICE),
       intent,
       PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
     )
@@ -57,7 +63,7 @@ object NotificationIntentFactory {
 
     return PendingIntent.getActivities(
       context,
-      REQUEST_CODE_RECEIVER_ACTIVITY,
+      requestCodeFor(callId, REQUEST_CODE_RECEIVER_ACTIVITY),
       arrayOf(launchActivityIntent, receiverIntent),
       PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
     )
@@ -75,7 +81,7 @@ object NotificationIntentFactory {
 
     return PendingIntent.getActivity(
       context,
-      REQUEST_CODE_LAUNCH_ACTIVITY,
+      requestCodeFor(callId, REQUEST_CODE_LAUNCH_ACTIVITY),
       callIntent,
       PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
     )
@@ -94,10 +100,10 @@ object NotificationIntentFactory {
         addExtras(this)
       }
 
-    // Use action hashCode for unique request code per action type
+    // Use action + callId hash for unique request code per action per call
     return PendingIntent.getBroadcast(
       context,
-      action.hashCode(),
+      (action.hashCode() + callId.hashCode()).absoluteValue,
       intent,
       PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
     )

package/android/src/main/java/io/getstream/rn/callingx/notifications/NotificationReceiverActivity.kt

@@ -4,6 +4,7 @@ import android.app.Activity
 import android.content.Intent
 import android.os.Bundle
 import io.getstream.rn.callingx.CallingxModuleImpl
+import io.getstream.rn.callingx.debugLog
 
 // For Android 12+
 class NotificationReceiverActivity : Activity() {
@@ -26,10 +27,20 @@ class NotificationReceiverActivity : Activity() {
       return
     }
 
-    //we need it only for answered call event, as for cold start case we need to send broadcast event and to launch the app
     if (intent.action == CallingxModuleImpl.CALL_ANSWERED_ACTION) {
+      debugLog("[Callingx] NotificationReceiverActivity", "[receiver] answered call action")
       val callId = intent.getStringExtra(CallingxModuleImpl.EXTRA_CALL_ID)
       val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
+
+      if (callId != null) {
+        Intent(CallingxModuleImpl.CALL_OPTIMISTIC_ACCEPT_ACTION)
+          .apply {
+            setPackage(packageName)
+            putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+          }
+          .also { sendBroadcast(it) }
+      }
+
       Intent(CallingxModuleImpl.CALL_ANSWERED_ACTION)
         .apply {
           setPackage(packageName)

package/android/src/main/java/io/getstream/rn/callingx/notifications/NotificationReceiverService.kt

@@ -34,6 +34,13 @@ class NotificationReceiverService : Service() {
     val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
     callId?.let {
       try {
+        Intent(CallingxModuleImpl.CALL_OPTIMISTIC_ACCEPT_ACTION)
+                .apply {
+                    setPackage(packageName)
+                    putExtra(CallingxModuleImpl.EXTRA_CALL_ID, it)
+                }
+                .also { it -> sendBroadcast(it) }
+
         NotificationIntentFactory.getPendingBroadcastIntent(
                         applicationContext,
                         CallingxModuleImpl.CALL_ANSWERED_ACTION,

package/android/src/main/java/io/getstream/rn/callingx/repo/CallRepository.kt

@@ -29,7 +29,7 @@ abstract class CallRepository(protected val context: Context) {
   }
 
   interface Listener {
-    fun onCallStateChanged(call: Call)
+    fun onCallStateChanged(callId: String, call: Call)
     fun onIsCallAnswered(callId: String, source: EventSource)
     fun onIsCallDisconnected(callId: String?, cause: DisconnectCause, source: EventSource)
     fun onIsCallInactive(callId: String)
@@ -39,8 +39,8 @@ abstract class CallRepository(protected val context: Context) {
     fun onCallEndpointChanged(callId: String, endpoint: String)
   }
 
-  protected val _currentCall: MutableStateFlow<Call> = MutableStateFlow(Call.None)
-  val currentCall: StateFlow<Call> = _currentCall.asStateFlow()
+  protected val _calls: MutableStateFlow<Map<String, Call.Registered>> = MutableStateFlow(emptyMap())
+  val calls: StateFlow<Map<String, Call.Registered>> = _calls.asStateFlow()
 
   protected var _listener: Listener? = null
   protected val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
@@ -65,9 +65,19 @@ abstract class CallRepository(protected val context: Context) {
     isVideo: Boolean,
     displayOptions: Bundle?,
   ) {
-    updateCurrentCall { copy(displayOptions = displayOptions) }
+    updateCallById(callId) { copy(displayOptions = displayOptions) }
   }
 
+  fun getCall(callId: String): Call.Registered? = _calls.value[callId]
+
+  fun hasAnyCalls(): Boolean = _calls.value.isNotEmpty()
+
+  fun hasRingingCall(excludeCallId: String? = null): Boolean =
+    _calls.value.any { (id, c) -> id != excludeCallId && !c.isPending && c.isIncoming() && !c.isActive }
+
+  fun hasActiveCall(excludeCallId: String? = null): Boolean =
+    _calls.value.any { (id, c) -> id != excludeCallId && !c.isPending && c.isActive }
+
   //this call instance is used to display call notification before the call is registered, this is needed to invoke startForeground method on the service
   public fun getTempCall(callInfo: CallService.CallInfo, incoming: Boolean): Call.Registered {
     val attributes = createCallAttributes(
@@ -79,6 +89,7 @@ abstract class CallRepository(protected val context: Context) {
 
     return Call.Registered(
         id = callInfo.callId,
+        isPending = true,
         isActive = false,
         isOnHold = false,
         callAttributes = attributes,
@@ -92,34 +103,42 @@ abstract class CallRepository(protected val context: Context) {
   }
 
   /**
-   * Update the current state of our call applying the transform lambda only if the call is
-   * registered. Otherwise keep the current state
+   * Update the state of a specific call applying the transform lambda only if the call is
+   * found in the map. Otherwise keep the current state.
    */
-  protected fun updateCurrentCall(transform: Call.Registered.() -> Call) {
-    val currentState = _currentCall.value
-    debugLog(
-      getTag(),
-      "[repository] updateCurrentCall: Current call state: ${currentState::class.simpleName}"
-    )
-
-    _currentCall.update { call ->
-      if (call is Call.Registered) {
+  protected fun updateCallById(callId: String, transform: Call.Registered.() -> Call) {
+    _calls.update { currentMap ->
+      val call = currentMap[callId]
+      if (call != null) {
         val updated = call.transform()
         debugLog(
           getTag(),
-          "[repository] updateCurrentCall: Call state updated to: ${updated::class.simpleName}"
+          "[repository] updateCallById: Call $callId state updated to: ${updated::class.simpleName}"
         )
-        updated
+        if (updated is Call.Registered) {
+          currentMap + (callId to updated)
+        } else {
+          // Call transitioned to non-Registered state (e.g. Unregistered) — remove from map
+          currentMap - callId
+        }
       } else {
         Log.w(
           getTag(),
-          "[repository] updateCurrentCall: Call is not Registered, skipping update"
+          "[repository] updateCallById: Call $callId not found in map, skipping update"
         )
-        call
+        currentMap
       }
     }
   }
 
+  protected fun addCall(callId: String, call: Call.Registered) {
+    _calls.update { it + (callId to call) }
+  }
+
+  protected fun removeCall(callId: String) {
+    _calls.update { it - callId }
+  }
+
   protected fun createCallAttributes(
     displayName: String,
     address: Uri,