@poolse/react-native-calls 0.1.2 → 0.2.0

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

@@ -50,7 +50,12 @@ sealed interface Event {
   ) : Event
 
   data class RingEnded(val callId: String, val reason: String) : Event
-  data class CallFinished(val callId: String) : Event
+  /**
+   * The server finished the call. [reason] is the push's own reason
+   * (`finished`, `declined_all`, `no_answer`, `cancelled`); it only
+   * colours the caller's ended screen when the call never got answered.
+   */
+  data class CallFinished(val callId: String, val reason: String? = null) : Event
 
   data object UserAnswer : Event
   data object UserDecline : Event
@@ -62,10 +67,18 @@ sealed interface Event {
   data class HttpOk(val created: Boolean = true) : Event
   data object HttpGone : Event
   data object HttpTimeout : Event
+  /**
+   * Terminal refusal that is NOT "the call is over": 401/403 (grant
+   * spent, wrong device), 503, or an unparseable 2xx. Ends as `failed`,
+   * never as `finished`, so the UI does not claim the other side hung up.
+   */
+  data class HttpFailed(val code: String = "failed") : Event
 
   data object MediaConnected : Event
   data object MediaFailed : Event
   data object MediaLost : Event
+  /** The SFU is recovering the session on its own (ICE restart, resume). Show it; do not rejoin. */
+  data object MediaReconnecting : Event
   data object MediaRecovered : Event
   data object RemoteJoined : Event
 
@@ -74,6 +87,8 @@ sealed interface Event {
 
   data object RingDeadline : Event
   data object ReconnectBudgetElapsed : Event
+  /** CONNECTING watchdog: neither the server nor the SFU got us in. */
+  data object ConnectTimeout : Event
   data object LingerElapsed : Event
 }
 
@@ -115,17 +130,37 @@ object CallMachine {
 
     is Event.CallFinished ->
       if (e.callId == s.callId) when (s.phase) {
-        Phase.ACTIVE, Phase.RECONNECTING, Phase.RINGING_OUT -> Transition(
+        // The finish push can overtake (or replace) ring_ended: a ring
+        // for a finished call is over either way.
+        Phase.RINGING_IN -> Transition(MachineState.IDLE, listOf(Effect.RingtoneStop, Effect.DismissRing))
+        // Caller still ringing out: nobody ever joined, so the push's
+        // reason (no_answer / declined_all / cancelled) is the truth the
+        // ended screen should show. The server already finished the call
+        // — no hangup to send.
+        Phase.RINGING_OUT -> Transition(
+          s.copy(phase = Phase.ENDED, reason = ringOutcome(e.reason)),
+          listOf(Effect.RingbackStop, Effect.MediaLeave, Effect.CallSessionStop),
+        )
+        Phase.ACTIVE, Phase.RECONNECTING -> Transition(
           s.copy(phase = Phase.ENDED, reason = EndReason.FINISHED),
-          buildList {
-            if (s.phase == Phase.RINGING_OUT) add(Effect.RingbackStop)
-            add(Effect.MediaLeave); add(Effect.CallSessionStop)
-          },
+          listOf(Effect.MediaLeave, Effect.CallSessionStop),
         )
+        // CONNECTING may already have joined media (HTTP_OK came back):
+        // leave it, or the room outlives the call.
         Phase.CONNECTING -> Transition(
           s.copy(phase = Phase.ENDED, reason = EndReason.FINISHED),
-          listOf(Effect.CallSessionStop),
+          listOf(Effect.MediaLeave, Effect.CallSessionStop),
         )
+        // Lingering "ended": a later finish with a real outcome (the FCM
+        // push after a reason-less socket event, or vice versa) corrects
+        // an unanswered outgoing call's generic "finished" to what
+        // actually happened. Display only — nothing left to tear down.
+        Phase.ENDED -> {
+          val outcome = ringOutcome(e.reason)
+          if (s.direction == Direction.OUTGOING && s.reason == EndReason.FINISHED &&
+            outcome != EndReason.FINISHED
+          ) Transition(s.copy(reason = outcome), emptyList()) else noop(s)
+        }
         else -> noop(s)
       } else noop(s)
 
@@ -199,8 +234,9 @@ object CallMachine {
       else -> noop(s)
     }
 
-    Event.HttpTimeout ->
-      if (s.phase == Phase.CONNECTING && s.httpAttempts < 2) Transition(
+    Event.HttpTimeout -> when {
+      s.phase != Phase.CONNECTING -> noop(s)
+      s.httpAttempts < 2 -> Transition(
         s.copy(httpAttempts = s.httpAttempts + 1),
         listOf(
           when (s.direction) {
@@ -209,24 +245,73 @@ object CallMachine {
             else -> Effect.HttpAnswer
           },
         ),
-      ) else noop(s) // out of retries: media join (or its absence) decides
+      )
+      // Out of retries. A timeout only ever answers the CONNECTING
+      // request, so there is no bundle and media can never join:
+      // waiting on it was the "stuck in connecting forever" bug.
+      else -> Transition(
+        s.copy(phase = Phase.ENDED, reason = EndReason.FAILED),
+        listOf(Effect.HttpHangup, Effect.CallSessionStop),
+      )
+    }
+
+    is Event.HttpFailed -> when (s.phase) {
+      // HTTP_HANGUP still runs: with no bundle it resolves the ring
+      // grant, so an incoming caller is not left ringing a dead answer.
+      Phase.CONNECTING -> Transition(
+        s.copy(phase = Phase.ENDED, reason = EndReason.FAILED),
+        listOf(Effect.HttpHangup, Effect.CallSessionStop),
+      )
+      // Reconnect refused for auth: the control token is dead, so a
+      // hangup with it would be refused too — just leave.
+      Phase.RECONNECTING -> Transition(
+        s.copy(phase = Phase.ENDED, reason = EndReason.FAILED),
+        listOf(Effect.MediaLeave, Effect.CallSessionStop),
+      )
+      else -> noop(s)
+    }
+
+    Event.ConnectTimeout ->
+      if (s.phase == Phase.CONNECTING) Transition(
+        s.copy(phase = Phase.ENDED, reason = EndReason.FAILED),
+        listOf(Effect.MediaLeave, Effect.HttpHangup, Effect.CallSessionStop),
+      ) else noop(s)
 
     Event.MediaConnected -> when (s.phase) {
       Phase.CONNECTING -> Transition(s.copy(phase = Phase.ACTIVE), emptyList())
+      // A rejoin after /reconnect lands as a fresh connect.
+      Phase.RECONNECTING -> Transition(s.copy(phase = Phase.ACTIVE), emptyList())
       else -> noop(s) // ringing_out keeps ringing until a remote joins
     }
 
-    Event.MediaFailed ->
-      if (s.phase == Phase.CONNECTING) Transition(
+    Event.MediaFailed -> when (s.phase) {
+      Phase.CONNECTING -> Transition(
         s.copy(phase = Phase.ENDED, reason = EndReason.FAILED),
         listOf(Effect.HttpHangup, Effect.CallSessionStop),
-      ) else noop(s)
+      )
+      // The caller's own media never came up: the callees would answer
+      // into an empty room. Give up and tell the server.
+      Phase.RINGING_OUT -> Transition(
+        s.copy(phase = Phase.ENDED, reason = EndReason.FAILED),
+        listOf(Effect.RingbackStop, Effect.MediaLeave, Effect.HttpHangup, Effect.CallSessionStop),
+      )
+      else -> noop(s) // reconnecting: the budget timer is the backstop
+    }
 
-    Event.MediaLost ->
-      if (s.phase == Phase.ACTIVE) Transition(
-        s.copy(phase = Phase.RECONNECTING),
-        listOf(Effect.HttpReconnect),
-      ) else noop(s)
+    // Lost = the SFU gave up (unexpected disconnect). Ask the server for
+    // a fresh token and rejoin — also from RECONNECTING, where the SFU's
+    // own recovery just failed.
+    Event.MediaLost -> when (s.phase) {
+      Phase.ACTIVE -> Transition(s.copy(phase = Phase.RECONNECTING), listOf(Effect.HttpReconnect))
+      Phase.RECONNECTING -> Transition(s, listOf(Effect.HttpReconnect))
+      else -> noop(s)
+    }
+
+    // The SFU is resuming the same session itself: only reflect it.
+    // Tearing the room down here fought LiveKit's own recovery.
+    Event.MediaReconnecting ->
+      if (s.phase == Phase.ACTIVE) Transition(s.copy(phase = Phase.RECONNECTING), emptyList())
+      else noop(s)
 
     Event.MediaRecovered ->
       if (s.phase == Phase.RECONNECTING) Transition(s.copy(phase = Phase.ACTIVE), emptyList())
@@ -245,6 +330,7 @@ object CallMachine {
           reason = when (e.outcome) {
             "busy_all" -> EndReason.BUSY_ALL
             "no_answer" -> EndReason.NO_ANSWER
+            "cancelled" -> EndReason.CANCELLED
             else -> EndReason.DECLINED_ALL
           },
         ),
@@ -288,5 +374,14 @@ object CallMachine {
     else -> Transition(s, listOf(Effect.HttpDeclineBusy(e.callId)))
   }
 
+  /** A finish push's reason, read as the caller's unanswered outcome. */
+  private fun ringOutcome(reason: String?): EndReason = when (reason) {
+    "no_answer", "timeout" -> EndReason.NO_ANSWER
+    "declined_all", "declined" -> EndReason.DECLINED_ALL
+    "busy_all" -> EndReason.BUSY_ALL
+    "cancelled" -> EndReason.CANCELLED
+    else -> EndReason.FINISHED
+  }
+
   private fun noop(s: MachineState) = Transition(s, emptyList())
 }

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

@@ -19,8 +19,13 @@ interface HttpPort {
   fun decline(callId: String, auth: String, busy: Boolean)
   /** POST /calls/:id/hangup with the call-control token; fire-and-forget with retry. */
   fun hangup(callId: String, controlToken: String)
-  /** POST /calls/:id/reconnect with the call-control token. */
-  fun reconnect(callId: String, controlToken: String, cb: (HttpResult) -> Unit)
+  /**
+   * POST /calls/:id/reconnect with the call-control token. The server
+   * answers with the FULL bundle (same shape as answer/join); [current]
+   * is passed so an older server's `{livekit:{url,token}}` refresh can
+   * still be applied onto it.
+   */
+  fun reconnect(current: CallSessionBundle, cb: (HttpResult) -> Unit)
 }
 
 sealed interface HttpResult {
@@ -32,6 +37,11 @@ sealed interface HttpResult {
   data object Timeout : HttpResult
   /** 401/403 — grant spent, expired, or wrong device. Terminal. */
   data class AuthFailed(val code: String) : HttpResult
+  /**
+   * Terminal but not auth: 503 (no SFU capacity), another 4xx, or a 2xx
+   * whose body would not parse. Retrying would only repeat it.
+   */
+  data class Failed(val code: String) : HttpResult
 }
 
 data class CallSessionBundle(
@@ -52,6 +62,11 @@ interface MediaPort {
   fun setMuted(muted: Boolean)
   fun setCamera(on: Boolean)
   fun switchCamera()
+  /**
+   * Route call audio to the loudspeaker (`true`) or back to the private
+   * route — earpiece, or a connected headset/Bluetooth device (`false`).
+   */
+  fun setSpeaker(on: Boolean)
 }
 
 /** The ring UX: CallStyle notification + full-screen activity + tones. */

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

@@ -10,6 +10,7 @@ import android.media.MediaPlayer
 import android.media.Ringtone
 import android.media.RingtoneManager
 import android.os.Build
+import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.app.Person
@@ -26,7 +27,10 @@ import dev.poolse.callcore.RingSurfacePort
  * on the loudspeaker and the ringtone in the earpiece. Both players use
  * explicit [AudioAttributes]: ringtone on the ringtone stream (loud,
  * speaker), ringback on voice-communication (quiet, follows the call
- * route).
+ * route). The ringback waits for [setCommunicationReady]: before the
+ * SFU's audio handler has switched the device into communication mode,
+ * a voice-communication stream still routes to the loudspeaker — the
+ * "ringback blares from the speaker" bug.
  *
  * Tap actions resolve to broadcasts handled by [CallActionReceiver],
  * which forwards into the single native entry point so that notification
@@ -35,11 +39,25 @@ import dev.poolse.callcore.RingSurfacePort
  */
 internal class AndroidRingSurface(
   private val context: Context,
-  private val config: RingSurfaceConfig,
+  /** Read per use, so a re-configure (icon, ringback) applies at once. */
+  private val configOf: () -> RingSurfaceConfig,
 ) : RingSurfacePort {
 
+  private val config get() = configOf()
+
   private var ringtone: Ringtone? = null
   private var ringback: MediaPlayer? = null
+  private var ringbackWanted = false
+  private var communicationReady = false
+
+  /**
+   * The call's audio path is (or is no longer) in communication mode.
+   * A ringback requested earlier starts now, through the call route.
+   */
+  fun setCommunicationReady(ready: Boolean) {
+    communicationReady = ready
+    if (ready && ringbackWanted && ringback == null) playRingback()
+  }
 
   override fun show(ring: RingContext) {
     ensureChannel()
@@ -57,14 +75,28 @@ internal class AndroidRingSurface(
       )
     }
 
-    val fullScreen = PendingIntent.getActivity(
-      context,
-      ring.callId.hashCode(),
-      Intent(context, IncomingCallActivity::class.java)
+    fun incomingActivity(autoAnswer: Boolean, requestOffset: Int): PendingIntent {
+      val intent = Intent(context, IncomingCallActivity::class.java)
         .putExtra(EXTRA_RING, extras)
-        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP),
-      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-    )
+        .putExtra(EXTRA_AUTO_ANSWER, autoAnswer)
+        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+      return PendingIntent.getActivity(
+        context,
+        ring.callId.hashCode() + requestOffset,
+        intent,
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+      )
+    }
+
+    val fullScreen = incomingActivity(autoAnswer = false, requestOffset = 0)
+
+    // Answer launches an ACTIVITY, not a broadcast: a background receiver
+    // cannot start an activity (Android 10+), so answering from the
+    // notification used to connect audio while the app stayed hidden. An
+    // activity launched from a notification tap is allowed to come
+    // forward — it answers and brings the app up. Decline stays a
+    // broadcast; it needs no UI.
+    val answer = incomingActivity(autoAnswer = true, requestOffset = 2)
 
     val caller = Person.Builder()
       .setName(ring.conversationName ?: ring.callerName ?: "Incoming call")
@@ -79,22 +111,38 @@ internal class AndroidRingSurface(
       .setOngoing(true)
       .setAutoCancel(false)
       .setFullScreenIntent(fullScreen, true)
+      // Tapping the heads-up (not a button) opens the ring screen too;
+      // without this the tap did nothing.
+      .setContentIntent(fullScreen)
       .setStyle(
         NotificationCompat.CallStyle.forIncomingCall(
           caller,
           actionPending(ACTION_DECLINE, 1),
-          actionPending(ACTION_ANSWER, 2),
+          answer,
         ),
       )
       .build()
 
-    runCatching {
+    // The ring-mode foreground service adopts this exact notification.
+    shownRing = ring.callId to notification
+    try {
       NotificationManagerCompat.from(context).notify(ring.callId.notificationId(), notification)
+    } catch (e: SecurityException) {
+      // POST_NOTIFICATIONS denied: the ringtone still plays, but there is
+      // no surface. Loud in the log — this is a support question.
+      Log.e(TAG, "ring notification refused (POST_NOTIFICATIONS?)", e)
     }
   }
 
   override fun dismiss(callId: String) {
-    NotificationManagerCompat.from(context).cancel(callId.notificationId())
+    if (shownRing?.first == callId) shownRing = null
+    runCatching { NotificationManagerCompat.from(context).cancel(callId.notificationId()) }
+    // The full-screen activity is its own window: tell it to close.
+    runCatching {
+      context.sendBroadcast(
+        Intent(ACTION_RING_CLOSED).setPackage(context.packageName).putExtra(EXTRA_CALL_ID, callId),
+      )
+    }
   }
 
   override fun ringtoneStart() {
@@ -119,6 +167,11 @@ internal class AndroidRingSurface(
 
   override fun ringbackStart() {
     ringbackStop()
+    ringbackWanted = true
+    if (communicationReady) playRingback()
+  }
+
+  private fun playRingback() {
     val resId = config.ringbackRawRes
     if (resId == 0) return
     runCatching {
@@ -138,6 +191,7 @@ internal class AndroidRingSurface(
   }
 
   override fun ringbackStop() {
+    ringbackWanted = false
     runCatching {
       ringback?.stop()
       ringback?.release()
@@ -169,6 +223,14 @@ internal class AndroidRingSurface(
     const val ACTION_DECLINE = "DECLINE"
     const val ACTION_OPEN = "OPEN"
     const val EXTRA_RING = "poolse_ring"
+    const val EXTRA_AUTO_ANSWER = "poolse_auto_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"
+    private const val TAG = "PoolseRingSurface"
+
+    /** The CallStyle notification on screen, for the ring-mode service to wear. */
+    @Volatile internal var shownRing: Pair<String, android.app.Notification>? = null
 
     /** Stable per-call notification id, so teardown targets the right one. */
     fun String.notificationId(): Int = hashCode()

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

@@ -19,10 +19,11 @@ import dev.poolse.callcore.android.AndroidRingSurface.Companion.EXTRA_RING
 class CallActionReceiver : BroadcastReceiver() {
   override fun onReceive(context: Context, intent: Intent) {
     val ring = intent.getBundleExtra(EXTRA_RING)?.toRingContext() ?: return
+    val core = CallCore.getOrNull(context) ?: return
     when (intent.action) {
-      "$ACTION_PREFIX.$ACTION_ANSWER" -> CallCore.get(context).onUserAnswer(ring)
-      "$ACTION_PREFIX.$ACTION_DECLINE" -> CallCore.get(context).onUserDecline(ring)
-      "$ACTION_PREFIX.$ACTION_OPEN" -> CallCore.get(context).onUserOpen(ring)
+      "$ACTION_PREFIX.$ACTION_ANSWER" -> core.onUserAnswer(ring)
+      "$ACTION_PREFIX.$ACTION_DECLINE" -> core.onUserDecline(ring)
+      "$ACTION_PREFIX.$ACTION_OPEN" -> core.onUserOpen(ring)
     }
   }
 }