@poolse/react-native-calls 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,94 @@
+package dev.poolse.callcore
+
+/**
+ * The seams between the pure machine and the platform. Each adapter
+ * lives in the bridge/Android layer; the core knows only these shapes.
+ * Every port call corresponds 1:1 to an Effect — the runtime below is
+ * the only place effects are executed.
+ */
+
+/** CONTRACT.md §4 — the three doors. Tokens are opaque strings. */
+interface HttpPort {
+  /** POST /calls/:id/answer with the ring grant. */
+  fun answer(callId: String, grant: String, cb: (HttpResult) -> Unit)
+  /** POST /calls/:id/join with a session token. */
+  fun join(callId: String, sessionToken: String, cb: (HttpResult) -> Unit)
+  /** POST /conversations/:id/calls with a session token. */
+  fun place(conversationId: String, media: String, sessionToken: String, cb: (HttpResult) -> Unit)
+  /** POST /calls/:id/decline — grant or session; fire-and-forget with retry. */
+  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)
+}
+
+sealed interface HttpResult {
+  /** 2xx: the CallSessionBundle (or reconnect's token refresh). */
+  data class Ok(val bundle: CallSessionBundle) : HttpResult
+  /** 410 — the call is finished (or this device was superseded). */
+  data object Gone : HttpResult
+  /** Timeout / transient network failure. */
+  data object Timeout : HttpResult
+  /** 401/403 — grant spent, expired, or wrong device. Terminal. */
+  data class AuthFailed(val code: String) : HttpResult
+}
+
+data class CallSessionBundle(
+  val callId: String,
+  val conversationId: String,
+  val conversationName: String?,
+  val media: String,
+  val created: Boolean,
+  val livekitUrl: String,
+  val livekitToken: String,
+  val controlToken: String,
+)
+
+/** LiveKit (or any SFU) — media only, no lifecycle opinions. */
+interface MediaPort {
+  fun join(bundle: CallSessionBundle)
+  fun leave()
+  fun setMuted(muted: Boolean)
+  fun setCamera(on: Boolean)
+  fun switchCamera()
+}
+
+/** The ring UX: CallStyle notification + full-screen activity + tones. */
+interface RingSurfacePort {
+  fun show(ring: RingContext)
+  fun dismiss(callId: String)
+  fun ringtoneStart()
+  fun ringtoneStop()
+  fun ringbackStart()
+  fun ringbackStop()
+}
+
+data class RingContext(
+  val callId: String,
+  val conversationId: String,
+  val conversationName: String?,
+  val callerName: String?,
+  val media: String,
+  val grant: String,
+  val ringDeadlineEpochMs: Long,
+)
+
+/** Android: the phoneCall foreground service. iOS: the CallKit session. */
+interface CallSessionPort {
+  fun start(callId: String, media: String)
+  fun stop()
+}
+
+/** Snapshots out — the bridge turns these into JS events. */
+fun interface SnapshotSink {
+  fun emit(state: MachineState)
+}
+
+/** Time, injectable: real adapters use a Handler/looper; tests a fake. */
+interface TimerPort {
+  fun nowMs(): Long
+  /** Scheduling an existing key replaces it. */
+  fun schedule(key: String, delayMs: Long, fire: () -> Unit)
+  fun cancel(key: String)
+}

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

@@ -0,0 +1,183 @@
+package dev.poolse.callcore.android
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.media.AudioAttributes
+import android.media.MediaPlayer
+import android.media.Ringtone
+import android.media.RingtoneManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.Person
+import dev.poolse.callcore.RingContext
+import dev.poolse.callcore.RingSurfacePort
+
+/**
+ * The incoming-call UX: a CallStyle notification with a full-screen
+ * intent, so a locked phone lights up with a call screen the way the
+ * dialer does, plus the ringtone and the caller's ringback.
+ *
+ * Tones are owned here, not delegated to react-native-incall-manager,
+ * whose stream handling without its full lifecycle played the ringback
+ * 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).
+ *
+ * Tap actions resolve to broadcasts handled by [CallActionReceiver],
+ * which forwards into the single native entry point so that notification
+ * button, full-screen button and app-closed cold-launch all funnel to
+ * one place.
+ */
+internal class AndroidRingSurface(
+  private val context: Context,
+  private val config: RingSurfaceConfig,
+) : RingSurfacePort {
+
+  private var ringtone: Ringtone? = null
+  private var ringback: MediaPlayer? = null
+
+  override fun show(ring: RingContext) {
+    ensureChannel()
+    val extras = ring.toBundle()
+
+    fun actionPending(action: String, requestOffset: Int): PendingIntent {
+      val intent = Intent(context, CallActionReceiver::class.java)
+        .setAction("$ACTION_PREFIX.$action")
+        .putExtra(EXTRA_RING, extras)
+      return PendingIntent.getBroadcast(
+        context,
+        ring.callId.hashCode() + requestOffset,
+        intent,
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+      )
+    }
+
+    val fullScreen = PendingIntent.getActivity(
+      context,
+      ring.callId.hashCode(),
+      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,
+    )
+
+    val caller = Person.Builder()
+      .setName(ring.conversationName ?: ring.callerName ?: "Incoming call")
+      .setImportant(true)
+      .build()
+
+    val notification = NotificationCompat.Builder(context, CHANNEL_ID)
+      .setSmallIcon(config.smallIcon)
+      .setCategory(NotificationCompat.CATEGORY_CALL)
+      .setPriority(NotificationCompat.PRIORITY_MAX)
+      .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+      .setOngoing(true)
+      .setAutoCancel(false)
+      .setFullScreenIntent(fullScreen, true)
+      .setStyle(
+        NotificationCompat.CallStyle.forIncomingCall(
+          caller,
+          actionPending(ACTION_DECLINE, 1),
+          actionPending(ACTION_ANSWER, 2),
+        ),
+      )
+      .build()
+
+    runCatching {
+      NotificationManagerCompat.from(context).notify(ring.callId.notificationId(), notification)
+    }
+  }
+
+  override fun dismiss(callId: String) {
+    NotificationManagerCompat.from(context).cancel(callId.notificationId())
+  }
+
+  override fun ringtoneStart() {
+    ringtoneStop()
+    runCatching {
+      val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE) ?: return
+      ringtone = RingtoneManager.getRingtone(context, uri)?.apply {
+        audioAttributes = AudioAttributes.Builder()
+          .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+          .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+          .build()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) isLooping = true
+        play()
+      }
+    }
+  }
+
+  override fun ringtoneStop() {
+    runCatching { ringtone?.stop() }
+    ringtone = null
+  }
+
+  override fun ringbackStart() {
+    ringbackStop()
+    val resId = config.ringbackRawRes
+    if (resId == 0) return
+    runCatching {
+      ringback = MediaPlayer.create(
+        context,
+        resId,
+        AudioAttributes.Builder()
+          .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+          .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+          .build(),
+        /* audioSessionId = */ 0,
+      )?.apply {
+        isLooping = true
+        start()
+      }
+    }
+  }
+
+  override fun ringbackStop() {
+    runCatching {
+      ringback?.stop()
+      ringback?.release()
+    }
+    ringback = null
+  }
+
+  private fun ensureChannel() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+    val manager = context.getSystemService(NotificationManager::class.java)
+    if (manager.getNotificationChannel(CHANNEL_ID) != null) return
+    // Silent channel: the ringtone is ours (looping, controllable). A
+    // channel sound on top would double-ring and could not be stopped
+    // the instant the ring resolves.
+    manager.createNotificationChannel(
+      NotificationChannel(CHANNEL_ID, "Incoming calls", NotificationManager.IMPORTANCE_HIGH).apply {
+        setSound(null, null)
+        enableVibration(true)
+        vibrationPattern = longArrayOf(0, 400, 300, 400)
+        lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+      },
+    )
+  }
+
+  companion object {
+    const val CHANNEL_ID = "poolse_incoming_calls"
+    const val ACTION_PREFIX = "dev.poolse.callcore.action"
+    const val ACTION_ANSWER = "ANSWER"
+    const val ACTION_DECLINE = "DECLINE"
+    const val ACTION_OPEN = "OPEN"
+    const val EXTRA_RING = "poolse_ring"
+
+    /** Stable per-call notification id, so teardown targets the right one. */
+    fun String.notificationId(): Int = hashCode()
+  }
+}
+
+/** Host-supplied, platform-specific bits the core cannot know. */
+data class RingSurfaceConfig(
+  val smallIcon: Int,
+  /** `R.raw.incallmanager_ringback`, or 0 to fall back to silence. */
+  val ringbackRawRes: Int,
+)

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

@@ -0,0 +1,28 @@
+package dev.poolse.callcore.android
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import dev.poolse.callcore.android.AndroidRingSurface.Companion.ACTION_ANSWER
+import dev.poolse.callcore.android.AndroidRingSurface.Companion.ACTION_DECLINE
+import dev.poolse.callcore.android.AndroidRingSurface.Companion.ACTION_OPEN
+import dev.poolse.callcore.android.AndroidRingSurface.Companion.ACTION_PREFIX
+import dev.poolse.callcore.android.AndroidRingSurface.Companion.EXTRA_RING
+
+/**
+ * Answer / Decline taps on the CallStyle notification land here, as do
+ * programmatic opens. Everything funnels into [CallCore], the one native
+ * entry point — the same place the full-screen activity and a cold
+ * launch resolve to, so there is a single answer/decline path regardless
+ * of how the tap arrived.
+ */
+class CallActionReceiver : BroadcastReceiver() {
+  override fun onReceive(context: Context, intent: Intent) {
+    val ring = intent.getBundleExtra(EXTRA_RING)?.toRingContext() ?: 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)
+    }
+  }
+}

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

@@ -0,0 +1,236 @@
+package dev.poolse.callcore.android
+
+import android.content.Context
+import android.content.Intent
+import dev.poolse.callcore.CallCoreRuntime
+import dev.poolse.callcore.MachineState
+import dev.poolse.callcore.MediaPort
+import dev.poolse.callcore.RingContext
+import dev.poolse.callcore.SnapshotSink
+
+/**
+ * The composition root and the single native entry point.
+ *
+ * Everything that can originate a call action — the FCM service, the
+ * notification receiver, the full-screen activity, the React Native
+ * bridge — comes through here, so there is exactly one runtime and one
+ * answer/decline path on the device. Process-singleton, created lazily
+ * from the first caller's application context.
+ */
+class CallCore private constructor(context: Context) {
+
+  private val appContext = context.applicationContext
+
+  // The SFU is injected, not baked in: the core stays media-engine
+  // agnostic (CONTRACT.md — "LiveKit or any SFU"), and the library
+  // compiles without a specific media SDK on the classpath. The host
+  // supplies the factory; LiveKitMediaPort is the first implementation.
+  private val media: MediaPort = requireConfig().mediaFactory(appContext, mediaEvents())
+  private val surface = AndroidRingSurface(appContext, requireConfig().ringSurface)
+  private val runtime = CallCoreRuntime(
+    http = CallHttpClient(requireConfig().apiBaseUrl),
+    media = media,
+    surface = surface,
+    session = CallForegroundService.also { it.attach(appContext) },
+    timers = HandlerTimerPort(),
+    sink = SnapshotSink { emitSnapshot(it) },
+  )
+
+  // ── native entry points ─────────────────────────────────────────────
+
+  /** A ring arrived — from FCM (closed app) or the socket (open app). */
+  fun onRing(ring: RingContext) = runtime.onRing(ring)
+
+  /** The caller withdrew, or the ring resolved elsewhere. */
+  fun onRingEnded(callId: String, reason: String) = runtime.onRingEnded(callId, reason)
+
+  fun onCallFinished(callId: String) = runtime.onCallFinished(callId)
+
+  fun onUserAnswer(ring: RingContext) {
+    runtime.onRing(ring) // idempotent: dedupes if already showing
+    runtime.answer()
+    bringAppToFront(ring)
+  }
+
+  fun onUserDecline(ring: RingContext) {
+    runtime.onRing(ring)
+    runtime.decline()
+  }
+
+  fun onUserOpen(ring: RingContext) {
+    runtime.onRing(ring)
+    bringAppToFront(ring)
+  }
+
+  // ── bridge-driven actions ───────────────────────────────────────────
+
+  fun answer() = runtime.answer()
+  fun decline() = runtime.decline()
+  fun hangUp() = runtime.hangUp()
+  fun place(conversationId: String, media: String, sessionToken: String) =
+    runtime.place(conversationId, media, sessionToken)
+  fun join(callId: String, conversationId: String?, sessionToken: String) =
+    runtime.join(callId, conversationId, sessionToken)
+  fun setMuted(muted: Boolean) = runtime.setMuted(muted)
+  fun setCamera(on: Boolean) = runtime.setCamera(on)
+  fun switchCamera() = runtime.switchCamera()
+
+  fun snapshot(): MachineState = runtime.currentState()
+
+  /** The bridge subscribes here; replaced each mount, cleared on unmount. */
+  @Volatile var snapshotListener: ((MachineState) -> Unit)? = null
+
+  private fun emitSnapshot(state: MachineState) {
+    snapshotListener?.invoke(state)
+  }
+
+  private fun mediaEvents() = object : MediaEvents {
+    override fun onConnected() = runtime.onMediaConnected()
+    override fun onFailed() = runtime.onMediaFailed()
+    override fun onLost() = runtime.onMediaLost()
+    override fun onRecovered() = runtime.onMediaRecovered()
+    override fun onRemoteJoined() = runtime.onRemoteJoined()
+    override fun onParticipants(participants: List<MediaParticipant>) {
+      // Participant roster flows to the bridge via the snapshot; the
+      // runtime does not need the detail to drive the machine.
+    }
+  }
+
+  private fun bringAppToFront(ring: RingContext) {
+    val launch = appContext.packageManager.getLaunchIntentForPackage(appContext.packageName)
+      ?: return
+    launch.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+    launch.putExtra(EXTRA_LAUNCH_CALL, ring.callId)
+    runCatching { appContext.startActivity(launch) }
+  }
+
+  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
+
+    /**
+     * 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(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 ?: 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() {}
+    }
+  }
+}
+
+/**
+ * The host-supplied configuration: the API base URL the HTTP doors
+ * target, and the drawable/raw resources the surfaces need. Everything
+ * here is knowable only by the app, never by the library.
+ */
+data class CallCoreConfig(
+  val apiBaseUrl: String,
+  val smallIcon: Int,
+  val ringbackRawRes: Int,
+  /**
+   * Builds the media engine for a call. Injected so the core carries no
+   * SFU dependency; pass `::LiveKitMediaPortFactory` (the shipped
+   * implementation) or your own.
+   */
+  val mediaFactory: (Context, MediaEvents) -> MediaPort,
+) {
+  internal val ringSurface get() = RingSurfaceConfig(smallIcon, ringbackRawRes)
+}
+
+/** Media-level signals the SFU adapter reports back to the core. */
+interface MediaEvents {
+  fun onConnected()
+  fun onFailed()
+  fun onLost()
+  fun onRecovered()
+  fun onRemoteJoined()
+  fun onParticipants(participants: List<MediaParticipant>)
+}
+
+data class MediaParticipant(
+  val identity: String,
+  val speaking: Boolean,
+  val muted: Boolean,
+)

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

@@ -0,0 +1,80 @@
+package dev.poolse.callcore.android
+
+import android.app.Notification
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import dev.poolse.callcore.CallSessionPort
+
+/**
+ * Keeps a live call alive when the app is backgrounded or killed:
+ * a `phoneCall|microphone` foreground service that owns the ongoing
+ * notification for the call's whole lifetime. Android will not reclaim
+ * the process while this runs, so media keeps flowing with the screen
+ * off.
+ *
+ * [CallSessionPort] is driven by the runtime (CALL_SESSION_START/STOP);
+ * the service itself holds no call logic — it is the OS contract that
+ * says "a call is happening here".
+ */
+class CallForegroundService : Service() {
+
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    val media = intent?.getStringExtra(EXTRA_MEDIA) ?: "audio"
+    startInForeground(media)
+    // Sticky-less: if the system kills us, the call is already gone with
+    // the process; a relaunched empty service would be a ghost.
+    return START_NOT_STICKY
+  }
+
+  private fun startInForeground(media: String) {
+    val config = CallCore.peekConfig()
+    val notification: Notification = NotificationCompat.Builder(this, AndroidRingSurface.CHANNEL_ID)
+      .setSmallIcon(config?.smallIcon ?: android.R.drawable.sym_call_outgoing)
+      .setContentTitle("Ongoing call")
+      .setContentText(if (media == "video") "Video call" else "Voice call")
+      .setOngoing(true)
+      .setCategory(NotificationCompat.CATEGORY_CALL)
+      .setPriority(NotificationCompat.PRIORITY_LOW)
+      .build()
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      var type = ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        type = type or ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL
+      }
+      startForeground(NOTIFICATION_ID, notification, type)
+    } else {
+      startForeground(NOTIFICATION_ID, notification)
+    }
+  }
+
+  companion object : CallSessionPort {
+    private const val NOTIFICATION_ID = 0x9C0FE
+    private const val EXTRA_MEDIA = "media"
+
+    private lateinit var appContext: Context
+
+    /** Wired once by [CallCore] so the port can start/stop the service. */
+    fun attach(context: Context) { appContext = context.applicationContext }
+
+    override fun start(callId: String, media: String) {
+      val intent = Intent(appContext, CallForegroundService::class.java).putExtra(EXTRA_MEDIA, media)
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        appContext.startForegroundService(intent)
+      } else {
+        appContext.startService(intent)
+      }
+    }
+
+    override fun stop() {
+      appContext.stopService(Intent(appContext, CallForegroundService::class.java))
+    }
+  }
+}