@poolse/react-native-calls 0.1.3 → 0.3.0

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

@@ -2,11 +2,17 @@ package dev.poolse.callcore.android
 
 import android.animation.ValueAnimator
 import android.app.Activity
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
 import android.graphics.Color
 import android.graphics.Typeface
 import android.graphics.drawable.GradientDrawable
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.view.Gravity
 import android.view.View
 import android.view.WindowManager
@@ -14,6 +20,10 @@ import android.view.animation.LinearInterpolator
 import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.TextView
+import androidx.core.content.ContextCompat
+import dev.poolse.callcore.RingContext
+import dev.poolse.callcore.android.AndroidRingSurface.Companion.ACTION_RING_CLOSED
+import dev.poolse.callcore.android.AndroidRingSurface.Companion.EXTRA_CALL_ID
 import dev.poolse.callcore.android.AndroidRingSurface.Companion.EXTRA_RING
 
 /**
@@ -23,41 +33,118 @@ import dev.poolse.callcore.android.AndroidRingSurface.Companion.EXTRA_RING
  * ground, brand glow, a breathing ring) in plain views. The buttons
  * resolve into [CallCore], the same entry point every other surface
  * uses; answering brings the app forward over the keyguard.
+ *
+ * It closes itself when the ring ends anywhere else (caller cancelled,
+ * answered on another device, deadline) via the package-local
+ * [ACTION_RING_CLOSED] broadcast — before, a remotely-ended ring left
+ * this screen up with dead buttons.
  */
 class IncomingCallActivity : Activity() {
 
   private var pulse: ValueAnimator? = null
   private val density by lazy { resources.displayMetrics.density }
   private fun px(v: Int): Int = (v * density).toInt()
+  private val main = Handler(Looper.getMainLooper())
+
+  /** The ring on screen. */
+  private var ring: RingContext? = null
+
+  /**
+   * Answered: we are only waiting for the app to come forward over us.
+   * Our own DISMISS_RING broadcast must not close us before it does —
+   * finishing first left the app behind the keyguard.
+   */
+  private var awaitingForward = false
+
+  private val ringClosed = object : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+      val callId = intent.getStringExtra(EXTRA_CALL_ID) ?: return
+      if (callId == ring?.callId && !awaitingForward) finish()
+    }
+  }
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
     showOverKeyguard()
+    ContextCompat.registerReceiver(
+      this,
+      ringClosed,
+      IntentFilter(ACTION_RING_CLOSED),
+      ContextCompat.RECEIVER_NOT_EXPORTED,
+    )
+    handle(intent)
+  }
 
-    val ring = intent.getBundleExtra(EXTRA_RING)?.toRingContext()
-    if (ring == null) { finish(); return }
+  /** singleInstance: a new ring (or the answer action) arrives here, not in onCreate. */
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+    handle(intent)
+  }
+
+  private fun handle(intent: Intent) {
+    val next = intent.getBundleExtra(EXTRA_RING)?.toRingContext()
+    if (next == null) { if (ring == null) finish(); return }
+    val core = CallCore.getOrNull(this)
+    if (core == null) { finish(); return }
 
     // Answered from the notification: this activity exists only to be the
     // foreground context that is ALLOWED to bring the app up (a
-    // background receiver is not). Answer and get out before drawing —
-    // onUserAnswer launches the app over the keyguard.
+    // background receiver is not).
     if (intent.getBooleanExtra(AndroidRingSurface.EXTRA_AUTO_ANSWER, false)) {
-      CallCore.get(this).onUserAnswer(ring)
-      finish()
+      ring = next
+      answerAndForward(core, next)
+      return
+    }
+
+    // A stale tap (the ring resolved, or the process restarted after it
+    // ended): there is nothing to answer.
+    if (!core.isRingLive(next)) {
+      if (ring == null || ring?.callId == next.callId) finish()
       return
     }
+    ring = next
+    awaitingForward = false
+    pulse?.cancel()
+    val title = next.conversationName ?: next.callerName ?: "Incoming call"
+    val body = if (next.media == "video") "Incoming video call" else "Incoming call"
+    setContentView(buildScene(title, body, next))
+  }
+
+  /**
+   * Answer, then bring the app forward FROM THIS ACTIVITY, and stay
+   * (as a plain dark window) until the app is in front — finishing at
+   * once dropped the start on some OEMs and left the call audible
+   * behind the lock screen. onStop (we got covered) finishes us; a
+   * timer is the fallback.
+   */
+  private fun answerAndForward(core: CallCore, ring: RingContext) {
+    awaitingForward = true
+    pulse?.cancel()
+    pulse = null
+    setContentView(View(this).apply { setBackgroundColor(Color.parseColor("#0B0B14")) })
+    val launched = core.onUserAnswer(ring, this)
+    if (!launched) { finish(); return }
+    main.postDelayed({ if (!isFinishing) finish() }, FORWARD_FALLBACK_MS)
+  }
 
-    val title = ring.conversationName ?: ring.callerName ?: "Incoming call"
-    val body = if (ring.media == "video") "Incoming video call" else "Incoming call"
-    setContentView(buildScene(title, body, ring))
+  override fun onStop() {
+    super.onStop()
+    if (awaitingForward && !isFinishing) finish()
   }
 
   override fun onDestroy() {
+    main.removeCallbacksAndMessages(null)
+    runCatching { unregisterReceiver(ringClosed) }
     pulse?.cancel()
     pulse = null
     super.onDestroy()
   }
 
+  private companion object {
+    const val FORWARD_FALLBACK_MS = 4_000L
+  }
+
   private fun showOverKeyguard() {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
       setShowWhenLocked(true)
@@ -72,7 +159,7 @@ class IncomingCallActivity : Activity() {
     window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
   }
 
-  private fun buildScene(title: String, body: String, ring: dev.poolse.callcore.RingContext): View {
+  private fun buildScene(title: String, body: String, ring: RingContext): View {
     val root = FrameLayout(this).apply { setBackgroundColor(Color.parseColor("#0B0B14")) }
 
     root.addView(
@@ -147,10 +234,11 @@ class IncomingCallActivity : Activity() {
       layoutParams = LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, wrap())
     }
     val decline = actionButton("Decline", "✕", "#EF4444") {
-      CallCore.get(this).onUserDecline(ring); finish()
+      CallCore.getOrNull(this)?.onUserDecline(ring); finish()
     }
     val accept = actionButton("Answer", "✓", "#22C55E") {
-      CallCore.get(this).onUserAnswer(ring); finish()
+      val core = CallCore.getOrNull(this)
+      if (core == null) finish() else answerAndForward(core, ring)
     }
     buttons.addView(decline, LinearLayout.LayoutParams(wrap(), wrap()).apply { rightMargin = px(52) })
     buttons.addView(accept, LinearLayout.LayoutParams(wrap(), wrap()).apply { leftMargin = px(52) })

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

@@ -20,8 +20,23 @@ internal fun MachineState.toSnapshot(
   audioRoute: String = "earpiece",
   mutedSelf: Boolean = false,
   cameraOn: Boolean = false,
+  cameraFacing: String? = null,
 ): Map<String, Any?>? {
   if (phase == Phase.IDLE) return null
+  return buildMap {
+    putAll(snapshotCore(conversationName, participants, audioRoute, mutedSelf, cameraOn))
+    // Optional in the contract: present only while a camera is published.
+    if (cameraFacing != null) put("cameraFacing", cameraFacing)
+  }
+}
+
+private fun MachineState.snapshotCore(
+  conversationName: String?,
+  participants: List<Map<String, Any>>,
+  audioRoute: String,
+  mutedSelf: Boolean,
+  cameraOn: Boolean,
+): Map<String, Any?> {
   return mapOf(
     "cv" to 1,
     "callId" to callId,

package/android/src/main/java/expo/modules/poolsecalls/PoolseCallVideoView.kt

@@ -0,0 +1,64 @@
+package expo.modules.poolsecalls
+
+import android.content.Context
+import android.view.ViewGroup
+import dev.poolse.callcore.android.CallCore
+import dev.poolse.callcore.android.CallVideoSurface
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.views.ExpoView
+
+/**
+ * `<CallVideoView>` on Android: a thin host for the core's
+ * [CallVideoSurface]. All binding logic (which track, rebinds on
+ * subscribe/mute/rejoin) lives in the media adapter; this view only
+ * forwards props and ties the surface's lifetime to the window.
+ */
+class PoolseCallVideoView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+
+  // The renderer is a native child React does not lay out: let Android
+  // measure it (and re-measure when the video's size changes).
+  override val shouldUseAndroidLayout = true
+
+  private var surface: CallVideoSurface? = null
+
+  var participantId: String? = null
+    set(v) { field = v; apply() }
+  var local: Boolean = false
+    set(v) { field = v; apply() }
+  var mirror: Boolean? = null
+    set(v) { field = v; apply() }
+  var fit: String = "cover"
+    set(v) { field = v; apply() }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    attachSurface()
+  }
+
+  override fun onDetachedFromWindow() {
+    detachSurface()
+    super.onDetachedFromWindow()
+  }
+
+  private fun attachSurface() {
+    if (surface != null) return
+    // No core yet (never configured) or no video-capable SFU: stay empty.
+    val s = CallCore.peek()?.createVideoSurface(context) ?: return
+    surface = s
+    addView(s.view, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+    apply()
+  }
+
+  internal fun detachSurface() {
+    val s = surface ?: return
+    surface = null
+    s.release()
+    removeView(s.view)
+  }
+
+  private fun apply() {
+    // Mounted before the core existed (configure still pending): try again.
+    val s = surface ?: run { if (isAttachedToWindow) attachSurface(); return }
+    s.configure(participantId, local, mirror, if (fit == "contain") "contain" else "cover")
+  }
+}

package/android/src/main/java/expo/modules/poolsecalls/PoolseCallsModule.kt

@@ -1,7 +1,13 @@
 package expo.modules.poolsecalls
 
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import android.util.Log
 import dev.poolse.callcore.android.CallCore
-import dev.poolse.callcore.android.toSnapshot
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 
@@ -15,6 +21,9 @@ import expo.modules.kotlin.modules.ModuleDefinition
  * the JS side needs no R references. The SFU factory defaults to the
  * shipped LiveKit adapter when present, else a no-op (audio-less), so a
  * build without the LiveKit source set still rings and signals.
+ *
+ * Nothing here throws before `configure`: reads return idle, commands
+ * no-op (a fresh install renders its UI before JS has configured).
  */
 class PoolseCallsModule : Module() {
 
@@ -23,45 +32,104 @@ class PoolseCallsModule : Module() {
 
     Events("onCallState")
 
+    // <CallVideoView>: renders a participant's (or our own) camera.
+    View(PoolseCallVideoView::class) {
+      Name("PoolseCallVideo")
+      Prop("participantId") { view: PoolseCallVideoView, id: String? -> view.participantId = id }
+      Prop("local") { view: PoolseCallVideoView, local: Boolean? -> view.local = local ?: false }
+      Prop("mirror") { view: PoolseCallVideoView, mirror: Boolean? -> view.mirror = mirror }
+      Prop("fit") { view: PoolseCallVideoView, fit: String? -> view.fit = fit ?: "cover" }
+      OnViewDestroys { view: PoolseCallVideoView -> view.detachSurface() }
+    }
+
     // Snapshots → the single JS event. Null (idle) becomes an explicit
-    // cleared payload so the JS side always has a definite state.
+    // cleared payload so the JS side always has a definite state. The
+    // listener is process-level, so subscribing before configure works.
     OnStartObserving {
-      CallCore.get(context).snapshotListener = { state ->
-        sendEvent("onCallState", mapOf("snapshot" to state.toSnapshot()))
-      }
+      CallCore.listener = { snapshot -> sendEvent("onCallState", mapOf("snapshot" to snapshot)) }
     }
     OnStopObserving {
-      CallCore.get(context).snapshotListener = null
+      CallCore.listener = null
     }
 
     AsyncFunction("configure") { apiBaseUrl: String, options: Map<String, Any?>? ->
+      val ctx = context ?: return@AsyncFunction null
       // Resource NAMES go to the core, which resolves + persists them —
       // so a killed app woken by a ring can rebuild this without JS.
       CallCore.configure(
-        context,
+        ctx,
         apiBaseUrl,
         options?.get("smallIcon") as? String,
         options?.get("ringback") as? String,
       )
+      // Materialise the core now, so a call already in flight (cold
+      // answer) is visible to the first getCallState.
+      CallCore.getOrNull(ctx)
+      null
     }
 
     Function("getCallState") {
-      mapOf("snapshot" to CallCore.get(context).snapshot().toSnapshot())
+      mapOf("snapshot" to (CallCore.peek() ?: context?.let(CallCore::getOrNull))?.snapshot())
     }
 
     AsyncFunction("place") { conversationId: String, media: String, sessionToken: String ->
-      CallCore.get(context).place(conversationId, media, sessionToken)
+      core()?.place(conversationId, media, sessionToken)
     }
     AsyncFunction("join") { callId: String, conversationId: String?, sessionToken: String ->
-      CallCore.get(context).join(callId, conversationId, sessionToken)
+      core()?.join(callId, conversationId, sessionToken)
+    }
+    Function("answer") { core()?.answer() }
+    Function("decline") { core()?.decline() }
+    Function("hangUp") { core()?.hangUp() }
+    Function("setMuted") { muted: Boolean -> core()?.setMuted(muted) }
+    Function("setCamera") { on: Boolean -> core()?.setCamera(on) }
+    Function("switchCamera") { core()?.switchCamera() }
+    Function("setSpeaker") { on: Boolean -> core()?.setSpeaker(on) }
+
+    // Socket forwarding (open app): idempotent with the FCM path.
+    Function("onRingEnded") { callId: String, reason: String -> core()?.onRingEnded(callId, reason) }
+    Function("onCallFinished") { callId: String, reason: String? ->
+      core()?.onCallFinished(callId, reason?.ifEmpty { null })
+    }
+
+    // Android 14+: full-screen intents need a user grant for non-dialer apps.
+    Function("canUseFullScreenIntent") {
+      val ctx = context ?: return@Function true
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        ctx.getSystemService(NotificationManager::class.java).canUseFullScreenIntent()
+      } else {
+        true
+      }
+    }
+    Function("openFullScreenIntentSettings") {
+      val ctx = context ?: return@Function null
+      val pkg = Uri.parse("package:${ctx.packageName}")
+      val intents = buildList {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+          add(Intent(Settings.ACTION_MANAGE_APP_USE_FULL_SCREEN_INTENT, pkg))
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          add(Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).putExtra(Settings.EXTRA_APP_PACKAGE, ctx.packageName))
+        }
+        add(Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, pkg))
+      }
+      val opener = appContext.currentActivity
+      for (intent in intents) {
+        val ok = runCatching {
+          if (opener != null) opener.startActivity(intent)
+          else ctx.startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
+        }.onFailure { Log.w(TAG, "settings intent ${intent.action} unavailable", it) }.isSuccess
+        if (ok) break
+      }
+      null
     }
-    Function("answer") { CallCore.get(context).answer() }
-    Function("decline") { CallCore.get(context).decline() }
-    Function("hangUp") { CallCore.get(context).hangUp() }
-    Function("setMuted") { muted: Boolean -> CallCore.get(context).setMuted(muted) }
-    Function("setCamera") { on: Boolean -> CallCore.get(context).setCamera(on) }
-    Function("switchCamera") { CallCore.get(context).switchCamera() }
   }
 
-  private val context get() = requireNotNull(appContext.reactContext) { "no react context" }
+  private val context: Context? get() = appContext.reactContext
+
+  private fun core(): CallCore? = context?.let(CallCore::getOrNull)
+
+  private companion object {
+    const val TAG = "PoolseCalls"
+  }
 }