From 359f1bf5d2abb96a9940d28c2b362a75f2102ff4 Mon Sep 17 00:00:00 2001
From: Diego Mello <diegolmello@gmail.com>
Date: Tue, 21 Apr 2026 21:29:27 -0300
Subject: [PATCH 1/2] feat(android): create VoipCallService with
 FOREGROUND_SERVICE_MICROPHONE

New `VoipCallService` extends `Service` and runs as a foreground service with
`foregroundServiceType="microphone"`. Keeps VoIP audio calls alive when the app moves
to the background (Android terminates background processes without a foreground service).

- Service starts via `VoipCallService.startService(context, callId)` with ACTION_START
- Service stops via `VoipCallService.stopService(context)` with ACTION_STOP
- Starts with `ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE` on API 29+
- Creates low-priority notification channel and ongoing notification
- Manifest declares service with `foregroundServiceType="microphone"`

Fixes: C2 (missing VoipCallService with FOREGROUND_SERVICE_MICROPHONE)
---
 android/app/src/main/AndroidManifest.xml      |   7 +
 .../reactnative/voip/VoipCallService.kt       | 156 ++++++++++++++++++
 2 files changed, 163 insertions(+)
 create mode 100644 android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt

diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
index eb755ca9953..acea030650c 100644
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -147,6 +147,13 @@
 
         <service android:name="io.wazo.callkeep.RNCallKeepBackgroundMessagingService" />
 
+        <!-- VoIP foreground service for keeping audio calls alive in the background. -->
+        <service
+            android:name="chat.rocket.reactnative.voip.VoipCallService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="microphone" />
+
         <!-- react-native-webrtc ships MediaProjectionService (foregroundServiceType=mediaProjection)
              for screen sharing. We don't use screen sharing, and Android 15+ forbids starting
              restricted foreground service types from BOOT_COMPLETED receivers (expo-notifications
diff --git a/android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt b/android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt
new file mode 100644
index 00000000000..ccff99cd952
--- /dev/null
+++ b/android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt
@@ -0,0 +1,156 @@
+package chat.rocket.reactnative.voip
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import chat.rocket.reactnative.MainActivity
+
+/**
+ * Foreground service that keeps the VoIP call alive when the app moves to the background.
+ * Required because Android terminates background processes without a foreground service,
+ * which would drop the active audio session.
+ *
+ * Started on call accept, stopped on hangup.
+ */
+class VoipCallService : Service() {
+
+    companion object {
+        private const val TAG = "RocketChat.VoipCallService"
+        private const val CHANNEL_ID = "voip-call-service"
+        private const val CHANNEL_NAME = "VoIP Call"
+        private const val NOTIFICATION_ID = 1
+
+        private const val ACTION_START = "chat.rocket.reactnative.voip.START_SERVICE"
+        private const val ACTION_STOP = "chat.rocket.reactnative.voip.STOP_SERVICE"
+        const val EXTRA_CALL_ID = "callId"
+
+        private var isRunning = false
+
+        @JvmStatic
+        fun startService(context: android.content.Context, callId: String) {
+            val intent = Intent(context, VoipCallService::class.java).apply {
+                action = ACTION_START
+                putExtra(EXTRA_CALL_ID, callId)
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+
+        @JvmStatic
+        fun stopService(context: android.content.Context) {
+            val intent = Intent(context, VoipCallService::class.java).apply {
+                action = ACTION_STOP
+            }
+            context.startService(intent)
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        createNotificationChannel()
+        Log.d(TAG, "VoipCallService created")
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_STOP -> {
+                Log.d(TAG, "Stopping VoipCallService")
+                stopSelf()
+                return START_NOT_STICKY
+            }
+            ACTION_START -> {
+                val callId = intent.getStringExtra(EXTRA_CALL_ID) ?: "unknown"
+                Log.d(TAG, "Starting VoipCallService for callId: $callId")
+                if (!isRunning) {
+                    isRunning = true
+                    startForegroundWithNotification(callId)
+                } else {
+                    Log.d(TAG, "Service already running, skipping duplicate start")
+                }
+                return START_STICKY
+            }
+            else -> {
+                Log.w(TAG, "Unknown action: ${intent?.action}")
+                return START_NOT_STICKY
+            }
+        }
+    }
+
+    private fun startForegroundWithNotification(callId: String) {
+        val notification = buildNotification(callId)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(
+                NOTIFICATION_ID,
+                notification,
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+            )
+        } else {
+            startForeground(NOTIFICATION_ID, notification)
+        }
+
+        Log.d(TAG, "Started foreground with notification for callId: $callId")
+    }
+
+    private fun buildNotification(callId: String): Notification {
+        // Pending intent: tapping the notification opens the app.
+        val pendingIntent = PendingIntent.getActivity(
+            this,
+            0,
+            Intent(this, MainActivity::class.java).apply {
+                flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
+            },
+            PendingIntent.FLAG_UPDATE_CURRENT or if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                PendingIntent.FLAG_IMMUTABLE
+            } else {
+                0
+            }
+        )
+
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle("VoIP Call")
+            .setContentText("Call in progress")
+            .setSmallIcon(getApplicationInfo().icon)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setCategory(NotificationCompat.CATEGORY_SERVICE)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .build()
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                CHANNEL_NAME,
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "VoIP call in progress"
+                setShowBadge(false)
+            }
+            val notificationManager = getSystemService(NotificationManager::class.java)
+            notificationManager?.createNotificationChannel(channel)
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onDestroy() {
+        isRunning = false
+        Log.d(TAG, "VoipCallService destroyed")
+        super.onDestroy()
+    }
+}
\ No newline at end of file

From 4d9feb246ba9fa9e2630106d3e4c1f254ecbfa75 Mon Sep 17 00:00:00 2001
From: Diego Mello <diegolmello@gmail.com>
Date: Wed, 22 Apr 2026 11:02:17 -0300
Subject: [PATCH 2/2] fix(android): use stopService() and START_NOT_STICKY in
 VoipCallService

- Companion stopService() now calls Context.stopService() instead of
  startService(): calling startService() from a background context on
  Android 8+ throws IllegalStateException. stopService() with the same
  Intent is always safe and also respects the service component.
- onStartCommand now returns START_NOT_STICKY for ACTION_START so the
  system does not redeliver a null Intent after process death (which
  could not recover the WebRTC call state anyway).
- ACTION_STOP uses stopSelf(startId) so only the matching start token
  is released; the unknown-action branch also calls stopSelf(startId)
  before returning to prevent leaked start counts.
---
 .../java/chat/rocket/reactnative/voip/VoipCallService.kt   | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt b/android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt
index ccff99cd952..5098980a990 100644
--- a/android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt
+++ b/android/app/src/main/java/chat/rocket/reactnative/voip/VoipCallService.kt
@@ -52,7 +52,7 @@ class VoipCallService : Service() {
             val intent = Intent(context, VoipCallService::class.java).apply {
                 action = ACTION_STOP
             }
-            context.startService(intent)
+            context.stopService(intent)
         }
     }
 
@@ -66,7 +66,7 @@ class VoipCallService : Service() {
         when (intent?.action) {
             ACTION_STOP -> {
                 Log.d(TAG, "Stopping VoipCallService")
-                stopSelf()
+                stopSelf(startId)
                 return START_NOT_STICKY
             }
             ACTION_START -> {
@@ -78,10 +78,11 @@ class VoipCallService : Service() {
                 } else {
                     Log.d(TAG, "Service already running, skipping duplicate start")
                 }
-                return START_STICKY
+                return START_NOT_STICKY
             }
             else -> {
                 Log.w(TAG, "Unknown action: ${intent?.action}")
+                stopSelf(startId)
                 return START_NOT_STICKY
             }
         }