@poolse/react-native-calls 0.1.0 → 0.1.2

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

@@ -106,27 +106,97 @@ class CallCore private constructor(context: Context) {
 
   companion object {
     const val EXTRA_LAUNCH_CALL = "poolse_launch_call"
+    private const val PREFS = "dev.poolse.callcore"
 
     @Volatile private var instance: CallCore? = null
     @Volatile private var config: CallCoreConfig? = null
 
     /**
-     * Host apps call this once (the bridge does it on configure, or an
-     * app can do it in Application.onCreate) before any ring can arrive.
+     * Configure the core and PERSIST the inputs. A ring can wake a killed
+     * app: the OS spawns the process cold to run [CallMessagingService],
+     * with no React context and no chance for the JS bridge to call this.
+     * Persisting lets [restoreConfig] rebuild the same config from disk on
+     * that cold start, so closed-app ringing works. The bridge calls this
+     * each time the app opens; the resource names (not the resolved ids)
+     * are stored, since ids are not stable across installs.
      */
-    fun configure(config: CallCoreConfig) {
-      this.config = config
+    fun configure(context: Context, apiBaseUrl: String, smallIconName: String?, ringbackName: String?) {
+      val ctx = context.applicationContext
+      ctx.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
+        .putString("apiBaseUrl", apiBaseUrl)
+        .putString("smallIcon", smallIconName)
+        .putString("ringback", ringbackName)
+        .apply()
+      config = build(ctx, apiBaseUrl, smallIconName, ringbackName)
     }
 
     fun get(context: Context): CallCore =
       instance ?: synchronized(this) {
-        instance ?: CallCore(context).also { instance = it }
+        instance ?: run {
+          if (config == null) restoreConfig(context.applicationContext)
+          CallCore(context).also { instance = it }
+        }
       }
 
     internal fun peekConfig(): CallCoreConfig? = config
 
     internal fun requireConfig(): CallCoreConfig =
       config ?: error("CallCore.configure() must be called before use")
+
+    // Rebuild config from the persisted inputs on a cold start. Leaves
+    // config null if the app was never configured — impossible in
+    // practice, since registering for pushes requires opening the app.
+    private fun restoreConfig(context: Context) {
+      val p = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+      val url = p.getString("apiBaseUrl", null) ?: return
+      config = build(context, url, p.getString("smallIcon", null), p.getString("ringback", null))
+    }
+
+    private fun build(
+      context: Context,
+      apiBaseUrl: String,
+      smallIconName: String?,
+      ringbackName: String?,
+    ): CallCoreConfig {
+      val iconId = smallIconName
+        ?.let { context.resources.getIdentifier(it, "drawable", context.packageName) } ?: 0
+      val ringbackId = ringbackName
+        ?.let { context.resources.getIdentifier(it, "raw", context.packageName) } ?: 0
+      return CallCoreConfig(
+        apiBaseUrl = apiBaseUrl.trimEnd('/'),
+        // Fall back to the app's launcher icon rather than crash on a typo.
+        smallIcon = if (iconId != 0) iconId else context.applicationInfo.icon,
+        ringbackRawRes = ringbackId,
+        mediaFactory = resolveMediaFactory(),
+      )
+    }
+
+    /**
+     * The shipped LiveKit adapter is loaded reflectively so the core
+     * library carries no static dependency on the SFU source set. Absent
+     * (LiveKit not built in), calls still ring and signal; there is just
+     * no media — a supported degraded mode, not a crash.
+     */
+    @Suppress("UNCHECKED_CAST")
+    private fun resolveMediaFactory(): (Context, MediaEvents) -> MediaPort =
+      runCatching {
+        val companion = Class.forName("dev.poolse.callcore.livekit.LiveKitMediaPort\$Companion")
+        val livekit = Class.forName("dev.poolse.callcore.livekit.LiveKitMediaPort")
+          .getField("Companion").get(null)
+        companion.getMethod("getFactory").invoke(livekit) as (Context, MediaEvents) -> MediaPort
+      }.getOrElse {
+        { _, _ -> NoMediaPort }
+      }
+
+    /** Signalling-only fallback: the call rings and the state machine
+     *  runs, there is simply no audio/video transport. */
+    private object NoMediaPort : MediaPort {
+      override fun join(bundle: dev.poolse.callcore.CallSessionBundle) {}
+      override fun leave() {}
+      override fun setMuted(muted: Boolean) {}
+      override fun setCamera(on: Boolean) {}
+      override fun switchCamera() {}
+    }
   }
 }
 

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

@@ -25,6 +25,23 @@ class CallForegroundService : Service() {
 
   override fun onBind(intent: Intent?): IBinder? = null
 
+  // The ongoing-call notification has its own channel, created here so it
+  // exists on an OUTGOING call too — the incoming ring surface's channel
+  // is only made when a ring shows, so a placed call would otherwise post
+  // to a missing channel and startForeground would crash.
+  private fun ensureChannel() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+    val manager = getSystemService(android.app.NotificationManager::class.java)
+    if (manager.getNotificationChannel(CHANNEL_ID) != null) return
+    manager.createNotificationChannel(
+      android.app.NotificationChannel(
+        CHANNEL_ID,
+        "Ongoing calls",
+        android.app.NotificationManager.IMPORTANCE_LOW,
+      ).apply { setSound(null, null) },
+    )
+  }
+
   override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
     val media = intent?.getStringExtra(EXTRA_MEDIA) ?: "audio"
     startInForeground(media)
@@ -34,8 +51,9 @@ class CallForegroundService : Service() {
   }
 
   private fun startInForeground(media: String) {
+    ensureChannel()
     val config = CallCore.peekConfig()
-    val notification: Notification = NotificationCompat.Builder(this, AndroidRingSurface.CHANNEL_ID)
+    val notification: Notification = NotificationCompat.Builder(this, CHANNEL_ID)
       .setSmallIcon(config?.smallIcon ?: android.R.drawable.sym_call_outgoing)
       .setContentTitle("Ongoing call")
       .setContentText(if (media == "video") "Video call" else "Voice call")
@@ -58,6 +76,7 @@ class CallForegroundService : Service() {
   companion object : CallSessionPort {
     private const val NOTIFICATION_ID = 0x9C0FE
     private const val EXTRA_MEDIA = "media"
+    private const val CHANNEL_ID = "poolse_ongoing_call"
 
     private lateinit var appContext: Context
 

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

@@ -35,7 +35,14 @@ class PoolseCallsModule : Module() {
     }
 
     AsyncFunction("configure") { apiBaseUrl: String, options: Map<String, Any?>? ->
-      CallCore.configure(buildConfig(apiBaseUrl, options))
+      // 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,
+        apiBaseUrl,
+        options?.get("smallIcon") as? String,
+        options?.get("ringback") as? String,
+      )
     }
 
     Function("getCallState") {
@@ -57,53 +64,4 @@ class PoolseCallsModule : Module() {
   }
 
   private val context get() = requireNotNull(appContext.reactContext) { "no react context" }
-
-  private fun buildConfig(apiBaseUrl: String, options: Map<String, Any?>?) =
-    dev.poolse.callcore.android.CallCoreConfig(
-      apiBaseUrl = apiBaseUrl.trimEnd('/'),
-      smallIcon = resolveDrawable(options?.get("smallIcon") as? String),
-      ringbackRawRes = resolveRaw(options?.get("ringback") as? String),
-      mediaFactory = resolveMediaFactory(),
-    )
-
-  private fun resolveDrawable(name: String?): Int {
-    val ctx = context
-    val id = name?.let { ctx.resources.getIdentifier(it, "drawable", ctx.packageName) } ?: 0
-    // Fall back to the app's launcher icon rather than crash on a typo.
-    return if (id != 0) id else ctx.applicationInfo.icon
-  }
-
-  private fun resolveRaw(name: String?): Int {
-    val ctx = context
-    return name?.let { ctx.resources.getIdentifier(it, "raw", ctx.packageName) } ?: 0
-  }
-
-  /**
-   * The shipped LiveKit adapter is loaded reflectively so the core
-   * library does not statically depend on the SFU source set. Absent
-   * (LiveKit not built in), calls still ring and signal; there is just
-   * no media — a supported degraded mode, not a crash.
-   */
-  @Suppress("UNCHECKED_CAST")
-  private fun resolveMediaFactory(): (android.content.Context, dev.poolse.callcore.android.MediaEvents) -> dev.poolse.callcore.MediaPort {
-    return runCatching {
-      val companion = Class.forName("dev.poolse.callcore.livekit.LiveKitMediaPort\$Companion")
-      val instance = Class.forName("dev.poolse.callcore.livekit.LiveKitMediaPort")
-        .getField("Companion").get(null)
-      val getter = companion.getMethod("getFactory")
-      getter.invoke(instance) as (android.content.Context, dev.poolse.callcore.android.MediaEvents) -> dev.poolse.callcore.MediaPort
-    }.getOrElse {
-      { _, _ -> NoMediaPort }
-    }
-  }
-
-  /** Signalling-only fallback: the call rings and the state machine
-   *  runs, there is simply no audio/video transport. */
-  private object NoMediaPort : dev.poolse.callcore.MediaPort {
-    override fun join(bundle: dev.poolse.callcore.CallSessionBundle) {}
-    override fun leave() {}
-    override fun setMuted(muted: Boolean) {}
-    override fun setCamera(on: Boolean) {}
-    override fun switchCamera() {}
-  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolse/react-native-calls",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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",