fix(callingx): don't tear down concurrent calls on stop service

packages/react-native-callingx/README.md

@@ -56,6 +56,7 @@ await CallingxModule.displayIncomingCall(
 - `addEventListener(eventName, callback)`.
 - `getInitialEvents()` and `getInitialVoipEvents()`.
 - `acquireBackgroundTask(owner)` / `releaseBackgroundTask(owner)` (Android) — ref-counted keep-alive task that keeps the JS runtime/timers alive in the background; the underlying HeadlessJS task starts on the first acquire and stops once all owners release.
+- `stopService()` (Android) — asks the call service to stop. A request, not a command: the service hosts every call, so it stays alive while any call is registered or is being registered. Use `endCallWithReason(callId, reason)` to tear down an individual call.
 
 ## Event names
 

packages/react-native-callingx/android/src/main/java/io/getstream/rn/callingx/CallRegistrationStore.kt

@@ -137,13 +137,26 @@ object CallRegistrationStore {
         synchronized(list) { return list.toList() }
     }
 
-    fun clearAll() {
+    /** Forgets a call entirely: it is gone, so neither its id nor its queued actions can apply. */
+    fun discardCallState(callId: String) {
+        debugLog(TAG, "[store] discardCallState: Discarding all state for callId: $callId")
+        trackedCallIds.remove(callId)
+        pendingActionsByCallId.remove(callId)
+    }
+
+    /**
+     * Drops the JS-coupled state only: the promises and their timeouts belong to a React context
+     * that is going away, so nothing can resolve them.
+     *
+     * [trackedCallIds] and [pendingActionsByCallId] are deliberately kept. They describe native
+     * calls, which outlive a JS teardown: a tracked id still makes `rejectCallWhenBusy` reject
+     * later pushes, and a queued action still has to be replayed once the call registers.
+     */
+    fun clearPendingPromises() {
         synchronized(pendingPromises) {
             pendingTimeouts.values.forEach { mainHandler.removeCallbacks(it) }
             pendingTimeouts.clear()
             pendingPromises.clear()
         }
-        trackedCallIds.clear()
-        pendingActionsByCallId.clear()
     }
 }

packages/react-native-callingx/android/src/main/java/io/getstream/rn/callingx/CallingxModuleImpl.kt

@@ -74,11 +74,26 @@ class CallingxModuleImpl(
         debugLog(TAG, "[module] invalidate: Invalidating module")
 
         LifecycleListener.unregister()
-        CallRegistrationStore.clearAll()
+        CallRegistrationStore.clearPendingPromises()
         AudioEndpointStore.clearAll()
         CallEventBus.unsubscribe(this)
 
         isModuleInitialized = false
+
+        // The JS runtime is going away, so any keep-alive owner it held is gone with it. A React
+        // context teardown does not finish in-flight headless tasks, so the service would never
+        // otherwise be told to re-check whether it still has a reason to run. Native calls survive
+        // this — both registered ones and those still resolving Telecom endpoints — and veto the
+        // stop inside CallService, which is why the tracked ids above are left intact.
+        if (CallService.isRunning) {
+            try {
+                Intent(reactApplicationContext, CallService::class.java)
+                        .apply { action = CallService.ACTION_STOP_SERVICE }
+                        .also { reactApplicationContext.startService(it) }
+            } catch (e: Exception) {
+                Log.e(TAG, "[module] invalidate: Failed to sweep the call service: ${e.message}", e)
+            }
+        }
     }
 
     fun setShouldRejectCallWhenBusy(shouldReject: Boolean) {
@@ -125,6 +140,15 @@ class CallingxModuleImpl(
 
     fun stopService(promise: Promise) {
         debugLog(TAG, "[module] stopService: Stopping CallService explicitly from JS")
+
+        if (!CallService.isRunning) {
+            // Starting the service just to stop it would construct (and immediately release) a
+            // whole CallRepository, and `startService` from the background can throw on API 26+.
+            debugLog(TAG, "[module] stopService: Service is not running, nothing to stop")
+            promise.resolve(true)
+            return
+        }
+
         try {
             Intent(reactApplicationContext, CallService::class.java)
                     .apply { action = CallService.ACTION_STOP_SERVICE }
@@ -250,20 +274,21 @@ class CallingxModuleImpl(
             return
         }
 
-        // for now only display options will be updated, rest of the parameters will be ignored
         try {
-            startCallService(
-                    CallService.ACTION_UPDATE_CALL,
-                    callId,
-                    callerName,
-                    phoneNumber,
-                    true,
-                    displayOptions,
-            )
+            Intent(reactApplicationContext, CallService::class.java)
+                    .apply {
+                        this.action = CallService.ACTION_UPDATE_CALL
+                        putExtra(CallService.EXTRA_CALL_ID, callId)
+                        putExtra(CallService.EXTRA_NAME, callerName)
+                        putExtra(CallService.EXTRA_URI, phoneNumber.toUri())
+                        putExtra(CallService.EXTRA_IS_VIDEO, true)
+                        putExtra(CallService.EXTRA_DISPLAY_OPTIONS, Arguments.toBundle(displayOptions))
+                    }
+                    .also { reactApplicationContext.startService(it) }
             promise.resolve(true)
         } catch (e: Exception) {
-            Log.e(TAG, "[module] updateDisplay: Failed to start foreground service: ${e.message}", e)
-            promise.reject("START_FOREGROUND_SERVICE_ERROR", e.message, e)
+            Log.e(TAG, "[module] updateDisplay: Failed to start service: ${e.message}", e)
+            promise.reject("START_SERVICE_ERROR", e.message, e)
         }
     }
 

packages/react-native-callingx/android/src/main/java/io/getstream/rn/callingx/HeadlessTaskManager.kt

@@ -14,11 +14,32 @@ import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.jstasks.HeadlessJsTaskConfig
 import com.facebook.react.jstasks.HeadlessJsTaskContext
 import com.facebook.react.jstasks.HeadlessJsTaskEventListener
+import java.lang.ref.WeakReference
 
-class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventListener {
+/**
+ * @param onTaskFinished invoked after the active task finishes, unless the manager is being
+ *   released. [CallService] uses it to re-evaluate whether it still has a reason to run: a
+ *   call-less service is started by `acquireBackgroundTask` alone, and nothing else would ever
+ *   stop it.
+ */
+class HeadlessTaskManager(
+        private val context: Context,
+        private val onTaskFinished: () -> Unit = {},
+) : HeadlessJsTaskEventListener {
 
-  private var activeTaskId: Int? = null
-  private var isStarting: Boolean = false
+  /** Our ownership of the single HeadlessJS task slot. */
+  private sealed interface TaskState {
+    /** Nothing of ours is running or being started. */
+    object None : TaskState
+    /** A start was requested; React Native has not assigned an id yet. */
+    object Starting : TaskState
+    /** React Native is running our task, on [context]. */
+    class Active(val id: Int, val context: WeakReference<ReactContext>) : TaskState
+  }
+
+  /** Guards [state] so an inspection and the replacement that follows it cannot interleave. */
+  private val stateLock = Any()
+  private var state: TaskState = TaskState.None
   private var pendingReactInstanceListener: ReactInstanceEventListener? = null
   @Volatile
   private var released: Boolean = false
@@ -27,6 +48,53 @@ class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventLis
     private const val TAG = "[Callingx] HeadlessTaskManager"
   }
 
+  /**
+   * The running task's id, or null when we have none to act on.
+   *
+   * React Native drops in-flight headless tasks when a React context is reloaded or destroyed —
+   * there is no teardown for them — and these tasks are started with `timeout = 0`, so nothing
+   * would ever finish one. Ids also restart at 1 in a new context, so a stale one can name a
+   * *different* library's task. Both are avoided by trusting [TaskState.Active] only while the
+   * context it was started on is still the live one, and dropping it otherwise.
+   */
+  private fun liveTaskId(): Int? = synchronized(stateLock) {
+    val active = state as? TaskState.Active ?: return@synchronized null
+
+    val startedOn = active.context.get()
+    if (startedOn != null && startedOn === currentReactContextOrNull()) {
+      return@synchronized active.id
+    }
+
+    debugLog(
+            TAG,
+            "[headless] liveTaskId: task ${active.id} was abandoned with its React context, dropping it"
+    )
+    state = TaskState.None
+    return@synchronized null
+  }
+
+  /**
+   * True while we own the task slot, whether or not the task has an id yet. The service treats this
+   * as a reason to stay alive, so a task abandoned by a context reload must not pin it — but a start
+   * that has been requested and not yet acknowledged must, since its id does not exist yet.
+   */
+  fun ownsTaskSlot(): Boolean = synchronized(stateLock) {
+    state is TaskState.Starting || liveTaskId() != null
+  }
+
+  /**
+   * [reactContext] throws when the host is not initialised, and this is read from the service's
+   * stop paths, which run off the main thread. If no context can be resolved there is no task
+   * either, so the caller treats null as "nothing running".
+   */
+  private fun currentReactContextOrNull(): ReactContext? =
+          try {
+            reactContext
+          } catch (t: Throwable) {
+            debugLog(TAG, "[headless] currentReactContextOrNull: unavailable: ${t.message}")
+            null
+          }
+
   private fun hasReactContext(): Boolean = reactContext != null
 
   // ensures the React context is running by booting it via the headless task if not already present
@@ -45,16 +113,18 @@ class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventLis
   public fun startHeadlessTask(taskName: String, data: Bundle, timeout: Long) {
     debugLog(
             TAG,
-            "[headless] startHeadlessTask entry: activeTaskId=$activeTaskId isStarting=$isStarting"
+            "[headless] startHeadlessTask entry: state=${state::class.simpleName}"
     )
-    if (activeTaskId != null || isStarting) {
-      Log.w(
-              TAG,
-              "[headless] startHeadlessTask: Task already starting or active, ignoring new task request"
-      )
-      return
+    synchronized(stateLock) {
+      if (state is TaskState.Starting || liveTaskId() != null) {
+        Log.w(
+                TAG,
+                "[headless] startHeadlessTask: Task already starting or active, ignoring new task request"
+        )
+        return
+      }
+      state = TaskState.Starting
     }
-    isStarting = true
 
     if (UiThreadUtil.isOnUiThread()) {
       startTask(HeadlessJsTaskConfig(taskName, Arguments.fromBundle(data), timeout, true))
@@ -69,7 +139,10 @@ class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventLis
 
   public fun stopHeadlessTask() {
     debugLog(TAG, "[headless] stopHeadlessTask: Stopping headless task")
-    activeTaskId?.let { taskId ->
+    // Deliberately via liveTaskId: HeadlessJsTaskContext.finishTask has no notion of task
+    // ownership, so finishing a stale id after a context reload would cut short whichever
+    // library's task inherited that number.
+    liveTaskId()?.let { taskId ->
       if (UiThreadUtil.isOnUiThread()) {
         stopTask(taskId)
       } else {
@@ -100,14 +173,13 @@ class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventLis
 
     UiThreadUtil.runOnUiThread {
       val taskId = headlessJsTaskContext.startTask(taskConfig)
-      activeTaskId = taskId
+      synchronized(stateLock) { state = TaskState.Active(taskId, WeakReference(reactContext)) }
       debugLog(TAG, "[headless] invokeStartTask: Task started: $taskId")
-      isStarting = false
     }
   }
 
   private fun stopTask(taskId: Int) {
-    reactContext?.let { context ->
+    currentReactContextOrNull()?.let { context ->
       val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(context)
       if (headlessJsTaskContext.isTaskRunning(taskId)) {
         headlessJsTaskContext.finishTask(taskId)
@@ -119,7 +191,8 @@ class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventLis
   fun release() {
     released = true
     stopHeadlessTask()
-    isStarting = false
+    // Give up the slot synchronously: a Starting state would otherwise outlive the service.
+    synchronized(stateLock) { state = TaskState.None }
     // Proactively unregister the pending React-context init listener. Otherwise the callback
     // would fire after CallService is destroyed, invokeStartTask a stale task on this dead
     // manager, and register `this` as a task listener on the live ReactContext (leak).
@@ -131,8 +204,7 @@ class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventLis
     // posted by finishTask() drains first — otherwise we'd unregister the listener before
     // it fires and lose the finish log.
     UiThreadUtil.runOnUiThread {
-      activeTaskId = null
-      reactContext?.let { context ->
+      currentReactContextOrNull()?.let { context ->
         val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(context)
         headlessJsTaskContext.removeTaskEventListener(this)
       }
@@ -156,16 +228,20 @@ class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventLis
   }
 
   override fun onHeadlessJsTaskFinish(taskId: Int) {
-    if (taskId != activeTaskId) {
-      debugLog(
-              TAG,
-              "[headless] onHeadlessJsTaskFinish: IGNORED foreign taskId=$taskId (our=$activeTaskId)"
-      )
+    if (taskId != liveTaskId()) {
+      debugLog(TAG, "[headless] onHeadlessJsTaskFinish: IGNORED foreign taskId=$taskId")
+      return
+    }
+    debugLog(TAG, "[headless] onHeadlessJsTaskFinish: Task finished: $taskId, slot released")
+    synchronized(stateLock) { state = TaskState.None }
+
+    if (released) {
+      // release() runs from CallService.onDestroy and finishes the task itself; the service is
+      // already going down, so re-entering its stop logic here would be noise at best.
+      debugLog(TAG, "[headless] onHeadlessJsTaskFinish: released, skipping onTaskFinished")
       return
     }
-    debugLog(TAG, "[headless] onHeadlessJsTaskFinish Task finished: $taskId state cleared: activeTaskId=null isStarting=false")
-    activeTaskId = null
-    isStarting = false
+    onTaskFinished()
   }
 
   /**