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

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

@@ -48,13 +48,15 @@ class CallService : Service(), CallRepository.Listener {
     companion object {
         private const val TAG = "[Callingx] CallService"
 
+        internal const val DEFAULT_DISPLAY_NAME = "Unknown Caller"
+
         internal const val EXTRA_CALL_ID = "extra_call_id"
         internal const val EXTRA_NAME = "extra_name"
         internal const val EXTRA_URI = "extra_uri"
         internal const val EXTRA_IS_VIDEO = "extra_is_video"
         internal const val EXTRA_DISPLAY_TITLE = "displayTitle"
-        internal const val EXTRA_DISPLAY_SUBTITLE = "displaySubtitle"
         internal const val EXTRA_DISPLAY_OPTIONS = "display_options"
+        internal const val EXTRA_ACTION = "action_name"
         // Background task extras
         internal const val EXTRA_TASK_NAME = "task_name"
         internal const val EXTRA_TASK_DATA = "task_data"
@@ -66,6 +68,7 @@ class CallService : Service(), CallRepository.Listener {
         internal const val ACTION_START_BACKGROUND_TASK = "start_background_task"
         internal const val ACTION_STOP_BACKGROUND_TASK = "stop_background_task"
         internal const val ACTION_STOP_SERVICE = "stop_service"
+        internal const val ACTION_PROCESS_ACTION = "execute_action"
         internal const val ACTION_REGISTRATION_FAILED = "registration_failed"
 
         fun startIncomingCallFromPush(context: Context, data: Map<String, String>) {
@@ -103,8 +106,12 @@ class CallService : Service(), CallRepository.Listener {
                 )
                 return
             }
+            
+            val createdById = data["created_by_id"]
+            val createdName = data["created_by_display_name"].orEmpty()
+            val displayName = data["call_display_name"].orEmpty()
+            val callDisplayName = displayName.ifEmpty { createdName.ifEmpty { DEFAULT_DISPLAY_NAME } }
 
-            val callName = data["created_by_display_name"].orEmpty()
             val isVideo = data["video"] == "true"
 
             CallRegistrationStore.trackCallRegistration(callCid, null)
@@ -113,8 +120,8 @@ class CallService : Service(), CallRepository.Listener {
                     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_URI, createdById?.toUri() ?: callDisplayName.toUri())
+                        putExtra(EXTRA_NAME, callDisplayName)
                         putExtra(EXTRA_IS_VIDEO, isVideo)
                     }
 
@@ -218,8 +225,6 @@ class CallService : Service(), CallRepository.Listener {
             @Suppress("UnspecifiedRegisterReceiverFlag")
             registerReceiver(optimisticNotificationReceiver, filter)
         }
-
-        sendBroadcastEvent(CallingxModuleImpl.SERVICE_READY_ACTION)
     }
 
     override fun onDestroy() {
@@ -272,6 +277,9 @@ class CallService : Service(), CallRepository.Listener {
             ACTION_UPDATE_CALL -> {
                 updateCall(intent)
             }
+            ACTION_PROCESS_ACTION -> {
+                processAction(intent)
+            }
             ACTION_STOP_SERVICE -> {
                 if (isInForeground) {
                     stopForeground(STOP_FOREGROUND_REMOVE)
@@ -416,7 +424,18 @@ class CallService : Service(), CallRepository.Listener {
         }
     }
 
-    public fun processAction(callId: String, action: CallAction) {
+    fun processAction(intent: Intent) {
+        val callId = intent.getStringExtra(EXTRA_CALL_ID) ?: return
+        val action = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+          intent.getParcelableExtra(EXTRA_ACTION, CallAction::class.java)
+        } else {
+          @Suppress("DEPRECATION") intent.getParcelableExtra(EXTRA_ACTION)
+        } ?: return
+
+        processAction(callId, action)
+    }
+
+    fun processAction(callId: String, action: CallAction) {
         debugLog(
                 TAG,
                 "[service] processAction[$callId]: Processing action: ${action::class.simpleName}"
@@ -428,33 +447,23 @@ class CallService : Service(), CallRepository.Listener {
             } 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"
-                    )
-                }
+              debugLog(
+                             TAG,
+                             "[service] processAction: Add pending action for ${call?.id} to queue"
+                     )
+                CallRegistrationStore.addPendingAction(callId, action)
             }
         }
     }
 
-    public fun startBackgroundTask(intent: Intent) {
+    fun startBackgroundTask(intent: Intent) {
         val taskName = intent.getStringExtra(EXTRA_TASK_NAME)!!
         val data = intent.getBundleExtra(EXTRA_TASK_DATA)!!
         val timeout = intent.getLongExtra(EXTRA_TASK_TIMEOUT, 0)
         headlessJSManager.startHeadlessTask(taskName, data, timeout)
     }
 
-    public fun stopBackgroundTask() {
+    fun stopBackgroundTask() {
         headlessJSManager.stopHeadlessTask()
     }
 
@@ -518,30 +527,23 @@ class CallService : Service(), CallRepository.Listener {
 
     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)
+            val pendingActions = CallRegistrationStore.takePendingActions(call.id)
 
-            if (pendingCauseCode != null) {
-                debugLog(
-                        TAG,
-                        "[service] onCallStateChanged: Executing pending disconnect for ${call.id}"
-                )
-                call.processAction(CallAction.Disconnect(DisconnectCause(pendingCauseCode)))
+            val disconnectAction = pendingActions.find { it is CallAction.Disconnect }
+            if (disconnectAction != null) {
+                // if queue contains Disconnect, execute it and ignore rest of the queue
+                debugLog(TAG, "[service] processPendingActions: Executing pending disconnect for ${call.id}")
+                call.processAction(disconnectAction)
                 return true
             }
 
-            if (pendingAnswer != null) {
+            // process pending actions in the order they were added
+            for (action in pendingActions) {
+                call.processAction(action)
                 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))
+                             TAG,
+                             "[service] processPendingActions: Executing pending action: $action for ${call.id}"
+                     )
             }
 
             return false

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

@@ -1,14 +1,11 @@
 package io.getstream.rn.callingx
 
 import android.content.BroadcastReceiver
-import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.ServiceConnection
 import android.os.Build
 import android.os.Bundle
-import android.os.IBinder
 import android.telecom.DisconnectCause
 import android.util.Log
 import androidx.core.content.ContextCompat
@@ -42,6 +39,7 @@ class CallingxModuleImpl(
         const val EXTRA_DISCONNECT_CAUSE = "disconnect_cause"
         const val EXTRA_AUDIO_ENDPOINT = "audio_endpoint"
         const val EXTRA_SOURCE = "source"
+        const val EXTRA_ACTION = "action_name"
 
         // Action names must match intent-filter entries in AndroidManifest.xml
         const val CALL_REGISTERED_ACTION = "io.getstream.CALL_REGISTERED"
@@ -56,61 +54,19 @@ class CallingxModuleImpl(
         const val CALL_OPTIMISTIC_ACCEPT_ACTION = "io.getstream.ACCEPT_CALL_OPTIMISTIC"
         // Background task name
         const val HEADLESS_TASK_NAME = "HandleCallBackgroundState"
-        const val SERVICE_READY_ACTION = "io.getstream.SERVICE_READY"
     }
 
-    private enum class BindingState {
-        UNBOUND,
-        BINDING,
-        BOUND
-    }
-
-    private var callService: CallService? = null
-    private var bindingState = BindingState.UNBOUND
-
     private var delayedEvents = WritableNativeArray()
     private var isModuleInitialized = false
     private var canSendEvents = false
-    private var isHeadlessTaskRegistered = false
 
     private val notificationChannelsManager = NotificationChannelsManager(reactApplicationContext)
-    private val serviceReadyBroadcastReceiver = ServiceReadyBroadcastReceiver()
-    private val appStateListener =
-            object : LifecycleEventListener {
-                override fun onHostResume() {}
-
-                override fun onHostPause() {}
-
-                override fun onHostDestroy() {
-                    // App destroyed - force unbind
-                    debugLog(TAG, "[module] onHostDestroy: App destroyed")
-                    unbindServiceSafely()
-                }
-            }
 
     init {
         CallEventBus.subscribe(this)
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            reactApplicationContext.registerReceiver(
-                    serviceReadyBroadcastReceiver,
-                    getServiceReadyReceiverFilter(),
-                    Context.RECEIVER_NOT_EXPORTED
-            )
-        } else {
-            @Suppress("UnspecifiedRegisterReceiverFlag")
-            reactApplicationContext.registerReceiver(
-                    serviceReadyBroadcastReceiver,
-                    getServiceReadyReceiverFilter()
-            )
-        }
     }
 
     fun initialize() {
-        reactApplicationContext.addLifecycleEventListener(appStateListener)
-
-        tryToBindIfNeeded()
-
         debugLog(TAG, "[module] initialize: Initializing module")
     }
 
@@ -118,12 +74,8 @@ class CallingxModuleImpl(
         debugLog(TAG, "[module] invalidate: Invalidating module")
 
         CallRegistrationStore.clearAll()
-        unbindServiceSafely()
-
         CallEventBus.unsubscribe(this)
 
-        reactApplicationContext.removeLifecycleEventListener(appStateListener)
-        reactApplicationContext.unregisterReceiver(serviceReadyBroadcastReceiver)
         isModuleInitialized = false
     }
 
@@ -372,7 +324,6 @@ class CallingxModuleImpl(
                     }
                     .also { reactApplicationContext.startService(it) }
 
-            isHeadlessTaskRegistered = false
             promise.resolve(true)
         } catch (e: Exception) {
             Log.e(TAG, "[module] stopBackgroundTask: Failed to start service: ${e.message}", e)
@@ -382,7 +333,6 @@ class CallingxModuleImpl(
 
     fun registerBackgroundTaskAvailable() {
         debugLog(TAG, "[module] registerBackgroundTaskAvailable: Headless task registered")
-        isHeadlessTaskRegistered = true
     }
 
 
@@ -423,54 +373,16 @@ class CallingxModuleImpl(
                 .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
     }
 
-    private fun startBackgroundTaskAutomatically(taskName: String, timeout: Long) {
-        if (!isHeadlessTaskRegistered) {
-            debugLog(
-                    TAG,
-                    "[module] startBackgroundTaskAutomatically: Headless task is not registered"
-            )
-            return
-        }
-
-        try {
-            Intent(reactApplicationContext, CallService::class.java)
-                    .apply {
-                        this.action = CallService.ACTION_START_BACKGROUND_TASK
-                        putExtra(CallService.EXTRA_TASK_NAME, taskName)
-                        putExtra(CallService.EXTRA_TASK_DATA, Bundle())
-                        putExtra(CallService.EXTRA_TASK_TIMEOUT, timeout.toLong())
-                    }
-                    .also { reactApplicationContext.startService(it) }
-        } catch (e: Exception) {
-            Log.e(TAG, "[module] startBackgroundTaskAutomatically: Failed to start service: ${e.message}", e)
-        }
-    }
-
     private fun executeServiceAction(callId: String, action: CallAction, promise: Promise) {
         debugLog(TAG, "[module] executeServiceAction: Executing service action: $action")
-        when (bindingState) {
-            BindingState.BOUND -> {
-                if (callService != null) {
-                    callService?.processAction(callId, action)
-                    promise.resolve(true)
-                } else {
-                    promise.reject("ERROR", "Service reference lost")
+        Intent(reactApplicationContext, CallService::class.java)
+                .apply {
+                    this.action = CallService.ACTION_PROCESS_ACTION
+                    putExtra(CallService.EXTRA_CALL_ID, callId)
+                    putExtra(CallService.EXTRA_ACTION, action)
                 }
-            }
-            BindingState.BINDING -> {
-                debugLog(TAG, "executeServiceAction: Service binding, queueing action")
-                promise.reject(
-                        "SERVICE_BINDING",
-                        "Service is connecting, please try again in a moment"
-                )
-            }
-            BindingState.UNBOUND -> {
-                promise.reject(
-                        "SERVICE_NOT_CONNECTED",
-                        "Service not connected. Call may not be active."
-                )
-            }
-        }
+                .also { reactApplicationContext.startService(it) }
+                .also { promise.resolve(true) }
     }
 
     private fun sendJSEvent(eventName: String, params: WritableMap? = null) {
@@ -509,96 +421,11 @@ class CallingxModuleImpl(
         }
     }
 
-    private fun getServiceReadyReceiverFilter(): IntentFilter =
-            IntentFilter().apply {
-                addAction(SERVICE_READY_ACTION)
-            }
-
-    private fun bindToServiceIfNeeded() {
-        when (bindingState) {
-            BindingState.BOUND -> {
-                debugLog(TAG, "[module] bindToServiceIfNeeded: Already bound")
-                return
-            }
-            BindingState.BINDING -> {
-                debugLog(TAG, "[module] bindToServiceIfNeeded: Already binding")
-                return
-            }
-            BindingState.UNBOUND -> {
-                debugLog(TAG, "[module] bindToServiceIfNeeded: Attempting to bind")
-                val intent = Intent(reactApplicationContext, CallService::class.java)
-                try {
-                    val success =
-                            reactApplicationContext.bindService(
-                                    intent,
-                                    serviceConnection,
-                                    Context.BIND_AUTO_CREATE or Context.BIND_IMPORTANT
-                            )
-                    if (success) {
-                        bindingState = BindingState.BINDING
-                        debugLog(TAG, "[module] bindToServiceIfNeeded: Bind request successful")
-                    } else {
-                        Log.e(TAG, "[module] bindToServiceIfNeeded: Bind request failed")
-                        bindingState = BindingState.UNBOUND
-                    }
-                } catch (e: Exception) {
-                    Log.e(TAG, "[module] bindToServiceIfNeeded: Exception during bind", e)
-                    bindingState = BindingState.UNBOUND
-                }
-            }
-        }
-    }
-
-    private fun unbindServiceSafely() {
-        debugLog(TAG, "[module] unbindServiceSafely: Unbinding service")
-        if (bindingState == BindingState.BOUND || bindingState == BindingState.BINDING) {
-            try {
-                reactApplicationContext.unbindService(serviceConnection)
-                debugLog(TAG, "[module] unbindServiceSafely: Successfully unbound")
-            } catch (e: IllegalArgumentException) {
-                Log.w(
-                        TAG,
-                        "[module] unbindServiceSafely: Service not registered or already unbound"
-                )
-            } catch (e: Exception) {
-                Log.e(TAG, "[module] unbindServiceSafely: Error unbinding service", e)
-            } finally {
-                bindingState = BindingState.UNBOUND
-                callService = null
-            }
-        }
-    }
-
-    private fun tryToBindIfNeeded() {
-        val intent = Intent(reactApplicationContext, CallService::class.java)
-        try {
-            val success =
-                    reactApplicationContext.bindService(
-                            intent,
-                            serviceConnection,
-                            0 // No flags - only bind if service exists
-                    )
-            if (success) {
-                bindingState = BindingState.BINDING
-                debugLog(TAG, "[module] checkForExistingService: Service exists, binding")
-            } else {
-                debugLog(TAG, "[module] checkForExistingService: No existing service")
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "[module] checkForExistingService: Error checking for service", e)
-        }
-    }
-
     override fun onCallEvent(event: CallEvent) {
         val action = event.action
         val extras = event.extras
         val callId = extras.getString(EXTRA_CALL_ID)
 
-        debugLog(
-                TAG,
-                "[module] onCallEvent: Received event: $action callId: $callId callService: ${callService != null}"
-        )
-
         val params = Arguments.createMap()
         if (callId != null) {
             params.putString("callId", callId)
@@ -637,10 +464,6 @@ class CallingxModuleImpl(
                     if (callId != null) {
                         CallRegistrationStore.removeTrackedCall(callId)
                     }
-                    // Only unbind when no more calls are tracked
-                    if (!CallRegistrationStore.hasRegisteredCall()) {
-                        unbindServiceSafely()
-                    }
                 }
                 params.putString("cause", extras.getString(EXTRA_DISCONNECT_CAUSE))
                 sendJSEvent("endCall", params)
@@ -667,54 +490,4 @@ class CallingxModuleImpl(
             }
         }
     }
-
-    private inner class ServiceReadyBroadcastReceiver : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-          val action = intent.action ?: return
-
-          if (action == SERVICE_READY_ACTION) {
-                debugLog(
-                        TAG,
-                        "[module] ServiceReadyBroadcastReceiver: Service is ready, initiating binding, isHeadlessTaskRegistered: $isHeadlessTaskRegistered"
-                )
-                bindToServiceIfNeeded()
-                startBackgroundTaskAutomatically(HEADLESS_TASK_NAME, 0L)
-            }
-        }
-    }
-
-    private val serviceConnection =
-            object : ServiceConnection {
-                override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
-                    debugLog(TAG, "[module] onServiceConnected: Service connected")
-                    val binder = service as? CallService.CallServiceBinder
-                    callService = binder?.getService()
-                    bindingState = BindingState.BOUND
-                }
-
-                override fun onServiceDisconnected(name: ComponentName?) {
-                    debugLog(TAG, "onServiceDisconnected: Service disconnected unexpectedly")
-                    callService = null
-                    bindingState = BindingState.UNBOUND
-                }
-
-                override fun onBindingDied(name: ComponentName?) {
-                    Log.e(TAG, "[module] onBindingDied: Service binding died")
-                    callService = null
-                    bindingState = BindingState.UNBOUND
-
-                    // Must unbind to clean up the dead binding
-                    try {
-                        reactApplicationContext.unbindService(this)
-                    } catch (e: Exception) {
-                        Log.w(TAG, "[module] onBindingDied: Error unbinding dead connection", e)
-                    }
-                }
-
-                override fun onNullBinding(name: ComponentName?) {
-                    Log.e(TAG, "[module] onNullBinding: Service returned null binding")
-                    bindingState = BindingState.UNBOUND
-                    callService = null
-                }
-            }
 }

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

@@ -86,7 +86,6 @@ class CallNotificationManager(
         val isIncoming: Boolean,
         val optimisticState: OptimisticState,
         val displayTitle: String?,
-        val displaySubtitle: String?,
         val displayName: CharSequence,
         val address: Uri
     )
@@ -101,7 +100,6 @@ class CallNotificationManager(
         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
     )
@@ -192,14 +190,6 @@ class CallNotificationManager(
                 else -> null
             }
             if (text != null) builder.setContentText(text)
-        } else {
-            // If the call is active, we need to set the notification text
-            // based on the call display options (defined on js side)
-            call.displayOptions?.let {
-                if (it.containsKey(CallService.EXTRA_DISPLAY_SUBTITLE)) {
-                    builder.setContentText(it.getString(CallService.EXTRA_DISPLAY_SUBTITLE))
-                }
-            }
         }
 
         return builder.build()
@@ -327,25 +317,19 @@ class CallNotificationManager(
         if (call.isIncoming() && !call.isActive && optimisticState == OptimisticState.NONE) {
             return NotificationCompat.CallStyle.forIncomingCall(
                     caller,
-                    NotificationIntentFactory.getPendingBroadcastIntent(
-                            context,
-                            CallingxModuleImpl.CALL_END_ACTION,
-                            call.id
-                    ) {
-                        putExtra(
-                                CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE,
-                                getDisconnectCauseString(DisconnectCause(DisconnectCause.REJECTED))
-                        )
-                        putExtra(
-                                CallingxModuleImpl.EXTRA_SOURCE,
-                                CallRepository.EventSource.SYS.name.lowercase()
-                        )
-                    },
+                    NotificationIntentFactory.getPendingNotificationIntent(
+                        context,
+                        CallingxModuleImpl.CALL_END_ACTION,
+                        call.id,
+                        CallRepository.EventSource.SYS.name.lowercase(),
+                        false
+                    ),
                     NotificationIntentFactory.getPendingNotificationIntent(
                             context,
                             CallingxModuleImpl.CALL_ANSWERED_ACTION,
                             call.id,
-                            CallRepository.EventSource.SYS.name.lowercase()
+                            CallRepository.EventSource.SYS.name.lowercase(),
+                            true
                     )
             )
         }

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

@@ -22,10 +22,11 @@ object NotificationIntentFactory {
     context: Context,
     action: String,
     callId: String,
-    source: String
+    source: String,
+    includeLaunchActivity: Boolean
   ): PendingIntent {
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-      getReceiverActivityIntent(context, action, callId, source)
+      getReceiverActivityIntent(context, action, callId, source, includeLaunchActivity)
     } else {
       getPendingServiceIntent(context, action, callId, source)
     }
@@ -47,7 +48,7 @@ object NotificationIntentFactory {
     )
   }
 
-  fun getReceiverActivityIntent(context: Context, action: String, callId: String, source: String): PendingIntent {
+  fun getReceiverActivityIntent(context: Context, action: String, callId: String, source: String, includeLaunchActivity: Boolean): PendingIntent {
     val receiverIntent =
       Intent(context, NotificationReceiverActivity::class.java).apply {
         this.action = action
@@ -57,14 +58,25 @@ object NotificationIntentFactory {
 
     val launchActivity = context.packageManager.getLaunchIntentForPackage(context.packageName)
     val launchActivityIntent =
-      Intent(launchActivity).apply {
-        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+      launchActivity?.let { base ->
+        Intent(base).apply {
+          addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        }
+      }
+
+    // intents are started in order and build a synthetic back stack
+    // the last intent is the one on top, so the launch activity should come first
+    val intents =
+      if (includeLaunchActivity && launchActivityIntent != null) {
+        arrayOf(launchActivityIntent, receiverIntent)
+      } else {
+        arrayOf(receiverIntent)
       }
 
     return PendingIntent.getActivities(
       context,
       requestCodeFor(callId, REQUEST_CODE_RECEIVER_ACTIVITY),
-      arrayOf(launchActivityIntent, receiverIntent),
+      intents,
       PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
     )
   }