@poolse/react-native-calls 0.10.0 → 0.10.1

package/android/src/main/java/dev/poolse/callcore/android/AndroidRingSurface.kt

@@ -181,6 +181,19 @@ internal class AndroidRingSurface(
       )
     }
 
+    // End & answer launches an ACTIVITY, like the ring's Answer: only an
+    // activity started from the tap may bring the app forward (Android
+    // 10+), and the call that connects should be seen.
+    val answerWaiting = PendingIntent.getActivity(
+      context,
+      ring.callId.hashCode() + 4,
+      Intent(context, IncomingCallActivity::class.java)
+        .putExtra(EXTRA_RING, extras)
+        .putExtra(EXTRA_WAITING_ANSWER, true)
+        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP),
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+    )
+
     val who = ring.conversationName ?: ring.callerName ?: "Someone"
     val what = if (ring.media == "video") "video call" else "call"
     val notification = NotificationCompat.Builder(context, WAITING_CHANNEL_ID)
@@ -195,7 +208,10 @@ internal class AndroidRingSurface(
       .setOnlyAlertOnce(true)
       .apply { if (open != null) setContentIntent(open) }
       .addAction(0, "Decline", actionPending(ACTION_WAITING_DECLINE, 3))
-      .addAction(0, "End & answer", actionPending(ACTION_WAITING_ANSWER, 4))
+      .addAction(0, "End & answer", answerWaiting)
+      // Never outlive the ring: if its ring_ended/finished push is lost,
+      // the system takes the heads-up down at the deadline anyway.
+      .setTimeoutAfter((ring.ringDeadlineEpochMs - System.currentTimeMillis()).coerceAtLeast(10_000L))
       .build()
 
     waitingCallId = ring.callId
@@ -345,6 +361,7 @@ internal class AndroidRingSurface(
     private const val WAITING_BEEP_VOLUME = 70
     const val EXTRA_RING = "poolse_ring"
     const val EXTRA_AUTO_ANSWER = "poolse_auto_answer"
+    const val EXTRA_WAITING_ANSWER = "poolse_waiting_answer"
     /** Package-local broadcast: the ring for [EXTRA_CALL_ID] is over. */
     const val ACTION_RING_CLOSED = "dev.poolse.callcore.RING_CLOSED"
     const val EXTRA_CALL_ID = "poolse_call_id"

package/android/src/main/java/dev/poolse/callcore/android/CallCore.kt

@@ -122,6 +122,23 @@ class CallCore private constructor(context: Context) {
     return bringAppToFront(ring.callId, from)
   }
 
+  /**
+   * End & answer from the call-waiting heads-up. Only for the call still
+   * waiting (a stale notification is just taken down); brings the app
+   * forward from [from], like [onUserAnswer].
+   */
+  fun onUserAnswerWaiting(ring: RingContext, from: Context? = null): Boolean {
+    if (runtime.currentState().waiting?.callId != ring.callId) {
+      runCatching {
+        androidx.core.app.NotificationManagerCompat.from(appContext)
+          .cancel(with(AndroidRingSurface) { ring.callId.notificationId() })
+      }
+      return false
+    }
+    runtime.answerWaiting(ring.callId)
+    return bringAppToFront(ring.callId, from)
+  }
+
   fun onUserDecline(ring: RingContext) {
     runtime.onRing(ring)
     runtime.decline()
@@ -205,8 +222,10 @@ class CallCore private constructor(context: Context) {
       }
       resetExtras(null, null)
     } else if (state.callId != extrasCallId) {
-      // `pending:<conv>` → the server-minted id is the same call.
-      if (extrasCallId?.startsWith("pending:") == true) extrasCallId = state.callId
+      // `pending:<conv>` → the server-minted id is the same call — but
+      // only for that conversation's own placed call: a waiting call
+      // promoted over a still-pending one is a different call.
+      if (isRenameOfPending(extrasCallId, state)) extrasCallId = state.callId
       else resetExtras(state.callId, state.media)
     }
     if (state.phase != Phase.IDLE && state.media != extrasMedia) {
@@ -246,6 +265,11 @@ class CallCore private constructor(context: Context) {
     runCatching { listener?.invoke(snap) }.onFailure { Log.w(TAG, "snapshot listener failed", it) }
   }
 
+  private fun isRenameOfPending(previous: String?, state: MachineState): Boolean =
+    previous != null && previous.startsWith("pending:") &&
+      state.direction != dev.poolse.callcore.Direction.INCOMING &&
+      previous == "pending:${state.conversationId}"
+
   private fun resetExtras(callId: String?, media: String?) {
     extrasCallId = callId
     extrasMedia = media

package/android/src/main/java/dev/poolse/callcore/android/CallForegroundService.kt

@@ -220,14 +220,22 @@ class CallForegroundService : Service() {
 
     override fun start(callId: String, media: String) = onMain {
       desired = Desired(Mode.CALL, callId, media)
-      launch()
+      launchOrSwitch()
     }
 
     override fun stop() = onMain {
       desired = null
-      // Only a started instance with nothing pending may stop now; a
-      // pending start stops itself after startForeground.
-      if (pendingStarts == 0) instance?.stopNow()
+      // Deferred to the end of this main-thread turn: a call handing over
+      // to the next (call waiting: end & answer, or a promoted ring) stops
+      // and starts in one dispatch, and must switch the RUNNING service
+      // in place — a fresh start from the background is refused on
+      // Android 12+ (and loses the microphone type on 14+). A start in
+      // the same turn sets `desired` again and this does nothing.
+      main.post {
+        // Only a started instance with nothing pending may stop now; a
+        // pending start stops itself after startForeground.
+        if (desired == null && pendingStarts == 0) instance?.stopNow()
+      }
     }
 
     /** Ring mode for [callId]; a no-op while a call holds the service. */
@@ -236,7 +244,7 @@ class CallForegroundService : Service() {
       if (d?.mode == Mode.CALL) return@onMain
       if (d?.mode == Mode.RING && d.callId == callId) return@onMain
       desired = Desired(Mode.RING, callId, "audio")
-      launch()
+      launchOrSwitch()
     }
 
     /**
@@ -255,6 +263,12 @@ class CallForegroundService : Service() {
       if (desired?.mode == Mode.RING) stop()
     }
 
+    /** A running, settled instance switches in place; otherwise start one. */
+    private fun launchOrSwitch() {
+      val running = instance
+      if (running != null && pendingStarts == 0) running.reconcile(desired) else launch()
+    }
+
     private fun launch() {
       if (!::appContext.isInitialized) return
       val intent = Intent(appContext, CallForegroundService::class.java)

package/android/src/main/java/dev/poolse/callcore/android/IncomingCallActivity.kt

@@ -93,7 +93,14 @@ class IncomingCallActivity : Activity() {
     // background receiver is not).
     if (intent.getBooleanExtra(AndroidRingSurface.EXTRA_AUTO_ANSWER, false)) {
       ring = next
-      answerAndForward(core, next)
+      answerAndForward { core.onUserAnswer(next, this) }
+      return
+    }
+    // End & answer on a call-waiting heads-up: the same, for the call
+    // waiting beside the current one.
+    if (intent.getBooleanExtra(AndroidRingSurface.EXTRA_WAITING_ANSWER, false)) {
+      ring = next
+      answerAndForward { core.onUserAnswerWaiting(next, this) }
       return
     }
 
@@ -118,12 +125,12 @@ class IncomingCallActivity : Activity() {
    * behind the lock screen. onStop (we got covered) finishes us; a
    * timer is the fallback.
    */
-  private fun answerAndForward(core: CallCore, ring: RingContext) {
+  private fun answerAndForward(answer: () -> Boolean) {
     awaitingForward = true
     pulse?.cancel()
     pulse = null
     setContentView(View(this).apply { setBackgroundColor(Color.parseColor("#0B0B14")) })
-    val launched = core.onUserAnswer(ring, this)
+    val launched = answer()
     if (!launched) { finish(); return }
     main.postDelayed({ if (!isFinishing) finish() }, FORWARD_FALLBACK_MS)
   }
@@ -238,7 +245,7 @@ class IncomingCallActivity : Activity() {
     }
     val accept = actionButton("Answer", "✓", "#22C55E") {
       val core = CallCore.getOrNull(this)
-      if (core == null) finish() else answerAndForward(core, ring)
+      if (core == null) finish() else answerAndForward { core.onUserAnswer(ring, this) }
     }
     buttons.addView(decline, LinearLayout.LayoutParams(wrap(), wrap()).apply { rightMargin = px(52) })
     buttons.addView(accept, LinearLayout.LayoutParams(wrap(), wrap()).apply { leftMargin = px(52) })

package/ios/Platform/CallCore.swift

@@ -234,13 +234,10 @@ final class CallCore {
   }
 
   /// Call waiting: end this call, answer the waiting one. CallKit follows
-  /// from the resulting state (reconcileCallKit ends the old call, then
-  /// answers the new one).
+  /// from the resulting state: reconcileCallKit reports the old call
+  /// ended, then answers the new one.
   func answerWaiting(callId: String? = nil) {
-    onMain { [self] in
-      localEnd = true
-      runtime.answerWaiting(callId: callId)
-    }
+    onMain { [self] in runtime.answerWaiting(callId: callId) }
   }
 
   /// Call waiting: turn the waiting call away (its caller hears busy).
@@ -314,8 +311,13 @@ final class CallCore {
       if extrasCallId != nil { mediaPort.leave() }
       resetExtras(nil, nil)
     } else if state.callId != extrasCallId {
-      if extrasCallId?.hasPrefix("pending:") == true {
-        if let old = extrasCallId, let new = state.callId { callKit.rename(from: old, to: new) }
+      // `pending:<conv>` → the server-minted id is the same call — but only
+      // for that conversation's own placed call: a waiting call promoted
+      // over a still-pending one is a different call (renaming would give
+      // CallKit two calls with one id, and the incoming one never answered).
+      if let old = extrasCallId, old.hasPrefix("pending:"), state.direction != .incoming,
+         old == "pending:\(state.conversationId ?? "")" {
+        if let new = state.callId { callKit.rename(from: old, to: new) }
         extrasCallId = state.callId
       } else {
         // A different call (a waiting one promoted): nothing of the last
@@ -485,7 +487,6 @@ extension CallCore: CallKitActions {
     // End & Accept may answer the waiting call before ending the current
     // one: answering it ends the current call itself.
     if s.waiting?.callId == callId {
-      localEnd = true
       runtime.answerWaiting(callId: callId)
       return
     }
@@ -523,6 +524,9 @@ extension CallCore: CallKitActions {
   func callKitReset() {
     let s = runtime.currentState()
     guard s.phase != .idle && s.phase != .ended else { return }
+    // CallKit dropped every call, the waiting one included: turn it away
+    // first, or ending the current call would ring it afresh.
+    if let w = s.waiting { runtime.declineWaiting(callId: w.callId) }
     localEnd = true
     if s.phase == .ringingIn { runtime.decline() } else { runtime.hangUp() }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolse/react-native-calls",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Native call core for poolse — Kotlin/Swift calling engine with a thin React Native bridge. Ring, answer and carry audio with the app killed and the phone locked.",
   "license": "MIT",
   "type": "module",