@stream-io/react-native-callingx 0.1.0-beta.6 → 0.1.1-beta.0

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

@@ -2,7 +2,10 @@ package io.getstream.rn.callingx
 
 import android.app.Notification
 import android.app.Service
+import android.content.BroadcastReceiver
+import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
 import android.content.pm.ServiceInfo
 import android.net.Uri
 import android.os.Binder
@@ -11,11 +14,16 @@ import android.os.Bundle
 import android.os.IBinder
 import android.telecom.DisconnectCause
 import android.util.Log
+import androidx.core.content.ContextCompat
+import androidx.core.net.toUri
 import io.getstream.rn.callingx.model.Call
 import io.getstream.rn.callingx.model.CallAction
 import io.getstream.rn.callingx.notifications.CallNotificationManager
+import io.getstream.rn.callingx.notifications.NotificationChannelsManager
+import io.getstream.rn.callingx.notifications.NotificationsConfig
 import io.getstream.rn.callingx.repo.CallRepository
 import io.getstream.rn.callingx.repo.CallRepositoryFactory
+import io.getstream.rn.callingx.utils.SettingsStore
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
@@ -59,6 +67,59 @@ class CallService : Service(), CallRepository.Listener {
         internal const val ACTION_STOP_BACKGROUND_TASK = "stop_background_task"
         internal const val ACTION_STOP_SERVICE = "stop_service"
         internal const val ACTION_REGISTRATION_FAILED = "registration_failed"
+
+        fun startIncomingCallFromPush(context: Context, data: Map<String, String>) {
+            debugLog(TAG, "[service] startIncomingCallFromPush: Starting incoming call from push")
+
+            // Check if we are allowed to post call notifications (moved from JS layer).
+            val notificationsConfig = NotificationsConfig.loadNotificationsConfig(context)
+            val notificationChannelsManager =
+                    NotificationChannelsManager(context).apply {
+                        setNotificationsConfig(notificationsConfig)
+                    }
+            val notificationStatus = notificationChannelsManager.getNotificationStatus()
+            if (!notificationStatus.canPost) {
+                debugLog(
+                        TAG,
+                        "[service] startIncomingCallFromPush: Cannot post notifications, skipping incoming call"
+                )
+                return
+            }
+
+            val shouldRejectCallWhenBusy = SettingsStore.shouldRejectCallWhenBusy(context)
+            if (shouldRejectCallWhenBusy && CallRegistrationStore.hasRegisteredCall()) {
+                debugLog(
+                        TAG,
+                        "[service] startIncomingCallFromPush: Registered call found and rejectCallWhenBusy is enabled, skipping incoming call"
+                )
+                return
+            }
+
+            val callCid = data["call_cid"]
+            if (callCid.isNullOrEmpty()) {
+                debugLog(
+                        TAG,
+                        "[service] startIncomingCallFromPush: Call CID is null or empty, skipping"
+                )
+                return
+            }
+
+            val callName = data["created_by_display_name"].orEmpty()
+            val isVideo = data["video"] == "true"
+
+            CallRegistrationStore.trackCallRegistration(callCid, null)
+
+            val intent =
+                    Intent(context, CallService::class.java).apply {
+                        action = ACTION_INCOMING_CALL
+                        putExtra(EXTRA_CALL_ID, callCid)
+                        putExtra(EXTRA_URI, callCid.toUri())
+                        putExtra(EXTRA_NAME, callName)
+                        putExtra(EXTRA_IS_VIDEO, isVideo)
+                    }
+
+            ContextCompat.startForegroundService(context, intent)
+        }
     }
 
     inner class CallServiceBinder : Binder() {
@@ -71,9 +132,72 @@ class CallService : Service(), CallRepository.Listener {
 
     private val binder = CallServiceBinder()
     private val scope: CoroutineScope = CoroutineScope(SupervisorJob())
+    private val actionProcessingLock = Object()
 
     private var isInForeground = false
 
+    private val optimisticNotificationReceiver =
+            object : BroadcastReceiver() {
+                override fun onReceive(context: Context, intent: Intent) {
+                    val callId = intent.getStringExtra(CallingxModuleImpl.EXTRA_CALL_ID) ?: return
+                    when (intent.action) {
+                        CallingxModuleImpl.CALL_OPTIMISTIC_ACCEPT_ACTION -> {
+                            debugLog(
+                                    TAG,
+                                    "[service] optimisticReceiver: Optimistic accept for $callId"
+                            )
+                            notificationManager.stopRingtone()
+                            notificationManager.setOptimisticState(
+                                    callId,
+                                    CallNotificationManager.OptimisticState.ACCEPTING
+                            )
+                            val call = callRepository.getCall(callId)
+                            if (call != null) {
+                                notificationManager.updateCallNotification(callId, call)
+                            }
+                        }
+                        CallingxModuleImpl.CALL_END_ACTION -> {
+                            val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
+                            val cause =
+                                    intent.getStringExtra(CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE)
+                            val rejectedCause =
+                                    getDisconnectCauseString(
+                                            DisconnectCause(DisconnectCause.REJECTED)
+                                    )
+                            val call = callRepository.getCall(callId)
+
+                            val isSysSource =
+                                    source == CallRepository.EventSource.SYS.name.lowercase()
+
+                            // we handle optimistic updates only if incoming call (non-answered) was rejected within notification action
+                            if (!isSysSource ||
+                                            cause != rejectedCause ||
+                                            call == null ||
+                                            !call.isIncoming() ||
+                                            call.isActive
+                            ) {
+                              debugLog(
+                                TAG,
+                                "[service] optimisticReceiver: Skipping optimistic reject for $callId"
+                              )
+                                return
+                            }
+
+                            debugLog(
+                                    TAG,
+                                    "[service] optimisticReceiver: Optimistic reject for $callId"
+                            )
+                            notificationManager.stopRingtone()
+                            notificationManager.setOptimisticState(
+                                    callId,
+                                    CallNotificationManager.OptimisticState.REJECTING
+                            )
+                            notificationManager.updateCallNotification(callId, call)
+                        }
+                    }
+                }
+            }
+
     override fun onCreate() {
         super.onCreate()
         debugLog(TAG, "[service] onCreate: TelecomCallService created")
@@ -83,6 +207,18 @@ class CallService : Service(), CallRepository.Listener {
         callRepository = CallRepositoryFactory.create(applicationContext)
         callRepository.setListener(this)
 
+        val filter =
+                IntentFilter().apply {
+                    addAction(CallingxModuleImpl.CALL_OPTIMISTIC_ACCEPT_ACTION)
+                    addAction(CallingxModuleImpl.CALL_END_ACTION)
+                }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            registerReceiver(optimisticNotificationReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            @Suppress("UnspecifiedRegisterReceiverFlag")
+            registerReceiver(optimisticNotificationReceiver, filter)
+        }
+
         sendBroadcastEvent(CallingxModuleImpl.SERVICE_READY_ACTION)
     }
 
@@ -90,7 +226,9 @@ class CallService : Service(), CallRepository.Listener {
         super.onDestroy()
         debugLog(TAG, "[service] onDestroy: TelecomCallService destroyed")
 
-        notificationManager.cancelNotifications()
+        unregisterReceiver(optimisticNotificationReceiver)
+
+        notificationManager.cancelAllNotifications()
         notificationManager.stopRingtone()
         callRepository.release()
         headlessJSManager.release()
@@ -124,23 +262,25 @@ class CallService : Service(), CallRepository.Listener {
                 registerCall(intent, false)
             }
             ACTION_START_BACKGROUND_TASK -> {
-                if (!isInForeground) {
-                    debugLog(TAG, "[service] onStartCommand: Starting foreground for background task")
-                    // for now bg task is intended to be used after a call registered and
-                    // notification is shown, so we don't need to show a separate notification for
-                    // bg task
-                    // startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
-                    // isInForeground = true
-                }
-
                 startBackgroundTask(intent)
+                return START_NOT_STICKY
             }
             ACTION_STOP_BACKGROUND_TASK -> {
                 stopBackgroundTask()
+                return START_NOT_STICKY
             }
             ACTION_UPDATE_CALL -> {
                 updateCall(intent)
             }
+            ACTION_STOP_SERVICE -> {
+                if (isInForeground) {
+                    stopForeground(STOP_FOREGROUND_REMOVE)
+                    isInForeground = false
+                }
+                notificationManager.cancelAllNotifications()
+                notificationManager.stopRingtone()
+                stopSelf()
+            }
             else -> {
                 Log.e(TAG, "[service] onStartCommand: Unknown action: ${intent.action}")
                 stopSelf()
@@ -158,51 +298,61 @@ class CallService : Service(), CallRepository.Listener {
         return super.onUnbind(intent)
     }
 
-    override fun onCallStateChanged(call: Call) {
-        debugLog(TAG, "[service] onCallStateChanged: Call state changed: ${call::class.simpleName}")
+    override fun onCallStateChanged(callId: String, call: Call) {
+        debugLog(
+                TAG,
+                "[service] onCallStateChanged[$callId]: Call state changed: ${call::class.simpleName}"
+        )
         when (call) {
             is Call.Registered -> {
                 debugLog(
                         TAG,
-                        "[service] updateServiceState: Call registered - Active: ${call.isActive}, OnHold: ${call.isOnHold}, Muted: ${call.isMuted}"
+                        "[service] onCallStateChanged[$callId]: Call registered - Active: ${call.isActive}, OnHold: ${call.isOnHold}, Muted: ${call.isMuted}"
                 )
 
+                val shouldStopExecution = processPendingActions(call)
+                if (shouldStopExecution) {
+                    return
+                }
+
                 if (call.isIncoming()) {
-                    if (!call.isActive) notificationManager.startRingtone()
-                    else notificationManager.stopRingtone()
+                    // Play ringtone only if there is no active call
+                    if (!call.isActive && !callRepository.hasActiveCall(excludeCallId = callId)) {
+                        notificationManager.startRingtone()
+                    } else {
+                        notificationManager.stopRingtone()
+                    }
                 }
-                // Update the call state.
+                // Update the call notification
+                val notificationId = notificationManager.getOrCreateNotificationId(callId)
                 if (isInForeground) {
-                    notificationManager.updateCallNotification(call)
+                    notificationManager.updateCallNotification(callId, call)
                 } else {
                     debugLog(
                             TAG,
-                            "[service] updateServiceState: Fallback starting foreground for call: ${call.id}"
+                            "[service] onCallStateChanged[$callId]: Starting foreground for call"
                     )
-                    //fallback if for some reason startForeground method is not called in onStartCommand method
-                    val notification = notificationManager.createNotification(call)
-                    startForegroundSafely(notification)
+                    notificationManager.resetOptimisticState(callId)
+                    val notification = notificationManager.createNotification(callId, call)
+                    startForegroundSafely(notificationId, notification)
                 }
             }
-            is Call.Unregistered -> {
-                notificationManager.updateCallNotification(call)
+            is Call.None, is Call.Unregistered -> {
+                repromoteForegroundIfNeeded(callId)
+                if (!callRepository.hasRingingCall()) notificationManager.stopRingtone()
 
-                if (isInForeground) {
-                    stopForeground(STOP_FOREGROUND_REMOVE)
-                    isInForeground = false
-                }
-
-                notificationManager.stopRingtone()
-                stopSelf()
-            }
-            is Call.None -> {
-                notificationManager.updateCallNotification(call)
-
-                if (isInForeground) {
-                    stopForeground(STOP_FOREGROUND_REMOVE)
-                    isInForeground = false
+                // Stop service only when no calls remain
+                if (!callRepository.hasAnyCalls()) {
+                    debugLog(
+                            TAG,
+                            "[service] onCallStateChanged[$callId]: No more calls, stopping service"
+                    )
+                    if (isInForeground) {
+                        stopForeground(STOP_FOREGROUND_REMOVE)
+                        isInForeground = false
+                    }
+                    stopSelf()
                 }
-                notificationManager.stopRingtone()
             }
         }
     }
@@ -219,8 +369,6 @@ class CallService : Service(), CallRepository.Listener {
             cause: DisconnectCause,
             source: CallRepository.EventSource
     ) {
-        // we're not passing the callId here to prevent infinite loops
-        // callEnd event with callId will sent only when after interaction with notification buttons
         sendBroadcastEvent(CallingxModuleImpl.CALL_END_ACTION) {
             if (callId != null) {
                 putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
@@ -268,21 +416,34 @@ class CallService : Service(), CallRepository.Listener {
         }
     }
 
-    public fun hasRegisteredCall(): Boolean {
-        val currentCall = callRepository.currentCall.value
-        return currentCall is Call.Registered
-    }
-
     public fun processAction(callId: String, action: CallAction) {
-        debugLog(TAG, "[service] processAction: Processing action: ${action::class.simpleName}")
-        val currentCall = callRepository.currentCall.value
-        if (currentCall is Call.Registered && currentCall.id == callId) {
-            currentCall.processAction(action)
-        } else {
-            Log.e(
-                    TAG,
-                    "[service] processAction: Call not registered or not the current call, ignoring action"
-            )
+        debugLog(
+                TAG,
+                "[service] processAction[$callId]: Processing action: ${action::class.simpleName}"
+        )
+        synchronized(actionProcessingLock) {
+            val call = callRepository.getCall(callId)
+            if (call != null && !call.isPending) {
+                call.processAction(action)
+            } else {
+                // this solves race condition, when action is requested before the call is
+                // registered in Telecom
+                if (action is CallAction.Disconnect) {
+                    debugLog(TAG, "[service] storing pending disconnect for $callId")
+                    CallRegistrationStore.setPendingDisconnect(callId, action.cause.code)
+                } else if (action is CallAction.Answer) {
+                    debugLog(TAG, "[service] storing pending answer for $callId")
+                    CallRegistrationStore.setPendingAnswer(callId, action.isAudioCall)
+                } else if (action is CallAction.ToggleMute) {
+                    debugLog(TAG, "[service] storing pending mute for $callId")
+                    CallRegistrationStore.setPendingMute(callId, action.isMute)
+                } else {
+                    Log.w(
+                            TAG,
+                            "[service] processAction[$callId]: Call not registered, ignoring action"
+                    )
+                }
+            }
         }
     }
 
@@ -299,12 +460,16 @@ class CallService : Service(), CallRepository.Listener {
 
     private fun registerCall(intent: Intent, incoming: Boolean) {
         debugLog(TAG, "[service] registerCall: ${if (incoming) "in" else "out"} call")
+
         val callInfo = extractIntentParams(intent)
 
-        // If we have an ongoing call, notify the module that registration is
-        // already done (so the pending promise resolves) and skip re-registration.
-        if (callRepository.currentCall.value is Call.Registered) {
-            Log.w(TAG, "[service] registerCall: Call already registered, ignoring new call request")
+        // If this specific call is already registered, just notify
+        val existingCall = callRepository.getCall(callInfo.callId)
+        if (existingCall != null) {
+            Log.w(
+                    TAG,
+                    "[service] registerCall: Call ${callInfo.callId} already registered, notifying"
+            )
             if (incoming) {
                 sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTERED_INCOMING_ACTION) {
                     putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
@@ -316,17 +481,8 @@ class CallService : Service(), CallRepository.Listener {
             }
             return
         }
-        val tempCall = callRepository.getTempCall(callInfo, incoming)
 
-        //it is better to invoke startForeground method synchronously inside onStartCommand method
-        if (!isInForeground) {
-            debugLog(
-                    TAG,
-                    "[service] registerCall: Starting foreground for call: ${callInfo.callId}"
-            )
-            val notification = notificationManager.createNotification(tempCall)
-            startForegroundSafely(notification)
-        }
+        startForegroundForCall(callInfo, incoming)
 
         scope.launch {
             try {
@@ -345,34 +501,66 @@ class CallService : Service(), CallRepository.Listener {
                     putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
                 }
 
-                if (isInForeground) {
-                    stopForeground(STOP_FOREGROUND_REMOVE)
-                    isInForeground = false
+                repromoteForegroundIfNeeded(callInfo.callId)
+
+                // Only stop foreground/service when no other calls remain
+                if (!callRepository.hasAnyCalls()) {
+                    if (isInForeground) {
+                        stopForeground(STOP_FOREGROUND_REMOVE)
+                        isInForeground = false
+                    }
+                    notificationManager.stopRingtone()
+                    stopSelf()
                 }
+            }
+        }
+    }
 
-                notificationManager.cancelNotifications()
-                notificationManager.stopRingtone()
-                stopSelf()
+    private fun processPendingActions(call: Call.Registered): Boolean {
+        synchronized(actionProcessingLock) {
+            val pendingCauseCode = CallRegistrationStore.takePendingDisconnect(call.id)
+            val pendingAnswer = CallRegistrationStore.takePendingAnswer(call.id)
+            val pendingMute = CallRegistrationStore.takePendingMute(call.id)
+
+            if (pendingCauseCode != null) {
+                debugLog(
+                        TAG,
+                        "[service] onCallStateChanged: Executing pending disconnect for ${call.id}"
+                )
+                call.processAction(CallAction.Disconnect(DisconnectCause(pendingCauseCode)))
+                return true
             }
+
+            if (pendingAnswer != null) {
+                debugLog(
+                        TAG,
+                        "[service] onCallStateChanged: Executing pending answer for ${call.id}"
+                )
+                call.processAction(CallAction.Answer(pendingAnswer))
+            }
+
+            if (pendingMute != null) {
+                debugLog(TAG, "[service] onCallStateChanged: Executing pending mute for ${call.id}")
+                call.processAction(CallAction.ToggleMute(pendingMute))
+            }
+
+            return false
         }
     }
 
-    private fun startForegroundSafely(notification: Notification) {
+    private fun startForegroundSafely(notificationId: Int, notification: Notification) {
         try {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                 startForeground(
-                        CallNotificationManager.NOTIFICATION_ID,
+                        notificationId,
                         notification,
                         ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL
                 )
             } else {
-                startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
+                startForeground(notificationId, notification)
             }
             isInForeground = true
         } catch (e: Exception) {
-            // If starting the foreground service fails (for example due to background start
-            // restrictions or notification issues), we log the error but avoid crashing the
-            // process so the rest of the call flow can continue and be recovered by Telecom.
             Log.e(
                     TAG,
                     "[service] startForegroundSafely: Failed to start foreground service: ${e.message}",
@@ -381,6 +569,40 @@ class CallService : Service(), CallRepository.Listener {
         }
     }
 
+    /**
+     * Cancels the notification for [callId]. If that notification was the foreground one
+     * and other calls remain, re-promotes the service with the next call's notification.
+     */
+    private fun repromoteForegroundIfNeeded(callId: String) {
+        val newForegroundNotificationId = notificationManager.cancelNotification(callId)
+        if (newForegroundNotificationId != null && isInForeground) {
+            val newForegroundCallId = notificationManager.getForegroundCallId()
+            val call = if (newForegroundCallId != null) callRepository.getCall(newForegroundCallId) else null
+            if (call != null && newForegroundCallId != null) {
+                debugLog(TAG, "[service] repromoteForegroundIfNeeded: Re-promoting with call $newForegroundCallId (notificationId=$newForegroundNotificationId)")
+                val notification = notificationManager.createNotification(newForegroundCallId, call)
+                startForegroundSafely(newForegroundNotificationId, notification)
+            }
+        }
+    }
+
+    private fun startForegroundForCall(callInfo: CallInfo, incoming: Boolean) {
+        val tempCall = callRepository.getTempCall(callInfo, incoming)
+        val notificationId = notificationManager.getOrCreateNotificationId(callInfo.callId)
+        if (!isInForeground) {
+            debugLog(
+                    TAG,
+                    "[service] registerCall: Starting foreground for call: ${callInfo.callId}"
+            )
+            val notification = notificationManager.createNotification(callInfo.callId, tempCall)
+            startForegroundSafely(notificationId, notification)
+        } else {
+            // Already in foreground from another call — just post the notification
+            val notification = notificationManager.createNotification(callInfo.callId, tempCall)
+            notificationManager.postNotification(callInfo.callId, notification)
+        }
+    }
+
     private fun updateCall(intent: Intent) {
         val callInfo = extractIntentParams(intent)
         callRepository.updateCall(