Merge pull request #1119 from torlando-tech/fix/1079-review-pass

Present incoming calls while backgrounded (issue #1079, replaces #1118)

Author: torlando-tech

app/src/debug/java/network/columba/app/test/TestReceiver.kt

@@ -276,6 +276,26 @@ class TestReceiver : BroadcastReceiver() {
                 }
             }
 
+            "network.columba.test.SHOW_INCOMING_CALL_TEST" -> {
+                // Debug-only: post the real incoming-call FSI notification on demand
+                // (issue #1079 diagnostics) so the full-screen takeover can be
+                // reproduced without placing a real call. Optional extras:
+                //   hash - identity hash to carry (default: a test hash)
+                //   name - caller display name (default: "E2E Test Caller")
+                val hash = intent.getStringExtra("hash") ?: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                val name = intent.getStringExtra("name") ?: "E2E Test Caller"
+                try {
+                    val helper = network.columba.app.notifications.CallNotificationHelper(app)
+                    helper.showIncomingCallNotification(hash, name)
+                    Log.i(
+                        TestController.LOGCAT_TAG,
+                        "fsi_test_posted hash=${hash.take(8)} name=$name",
+                    )
+                } catch (e: Exception) {
+                    Log.e(TestController.LOGCAT_TAG, "fsi_test_err ${e.message}")
+                }
+            }
+
             else ->
                 Log.i(TestController.LOGCAT_TAG, "rx_broadcast_unknown action=$action")
         }

app/src/main/AndroidManifest.xml

@@ -79,6 +79,8 @@
     <!-- Voice call permissions (LXST Telephony) -->
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
     <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <!-- Incoming call screen vibration (IncomingCallActivity) -->
+    <uses-permission android:name="android.permission.VIBRATE" />
     <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
     <!-- Required to show incoming call screen over other apps when phone is unlocked -->

app/src/main/java/network/columba/app/AppMainThread.kt

@@ -0,0 +1,24 @@
+package network.columba.app
+
+import android.os.Handler
+import android.os.Looper
+
+/**
+ * Minimal seam onto the application main looper for fire-and-forget work that
+ * must share a single execution thread with the activity lifecycle callbacks
+ * (see [MainActivityVisibility] for why confinement, not locking).
+ *
+ * A `post`d block runs on the main thread after any already-queued work,
+ * preserving enqueue order. Unit tests replace [post] and [isMainThread] with a
+ * synchronous fake (the real main looper does not exist on the JVM), the same
+ * way `Dispatchers.setMain` swaps the coroutine main dispatcher.
+ */
+object AppMainThread {
+    /** Test seam: replaced wholesale by unit tests; production uses the looper. */
+    @Volatile
+    var post: ((Runnable) -> Unit) = { runnable -> Handler(Looper.getMainLooper()).post(runnable) }
+
+    /** Test seam: whether the calling thread is the (faked) main thread. */
+    @Volatile
+    var isMainThread: () -> Boolean = { Looper.myLooper() == Looper.getMainLooper() }
+}

app/src/main/java/network/columba/app/ColumbaApplication.kt

@@ -73,6 +73,9 @@ class ColumbaApplication : Application() {
     @Inject
     lateinit var messageCollector: MessageCollector
 
+    @Inject
+    lateinit var incomingCallPresenter: network.columba.app.service.IncomingCallPresenter
+
     @Inject
     lateinit var conversationRepository: ConversationRepository
 
@@ -167,6 +170,13 @@ class ColumbaApplication : Application() {
 
         android.util.Log.d("ColumbaApplication", "Main app process detected ($processName) - proceeding with auto-initialization")
 
+        // Present incoming calls even when the app is backgrounded or the device is
+        // locked: the presenter posts the full-screen-intent notification on
+        // CallState.Incoming (issue #1079). Started before backend init because the
+        // bound callState flow is safe to observe before the service is ready - it
+        // just stays Idle until the service connection syncs state.
+        incomingCallPresenter.start()
+
         // Preload theme preference into DataStore's in-memory cache
         // This eliminates theme flash on app startup by ensuring the theme is cached
         // before MainActivity renders. Combined with SplashScreen API for zero-flash UX.

app/src/main/java/network/columba/app/IncomingCallActivity.kt

@@ -2,10 +2,7 @@ package network.columba.app
 
 import android.content.Context
 import android.content.Intent
-import android.media.AudioAttributes
 import android.media.AudioManager
-import android.media.Ringtone
-import android.media.RingtoneManager
 import android.os.Build
 import android.os.Bundle
 import android.os.VibrationEffect
@@ -33,10 +30,7 @@ import network.columba.app.notifications.CallNotificationHelper
 import network.columba.app.repository.SettingsRepository
 import network.columba.app.ui.screens.IncomingCallActivityScreen
 import network.columba.app.ui.theme.ThemeMode
-import kotlinx.coroutines.Job
 import dagger.hilt.android.EntryPointAccessors
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import network.columba.app.di.RnsTelephonyEntryPoint
 import network.columba.app.rns.api.RnsTelephony
@@ -53,7 +47,7 @@ import network.columba.app.rns.api.model.CallState
  * - Shows over lock screen (showWhenLocked / FLAG_SHOW_WHEN_LOCKED)
  * - Turns screen on (turnScreenOn / FLAG_TURN_SCREEN_ON)
  * - Dismisses keyguard when answering
- * - Plays default ringtone and vibrates in a call pattern
+ * - Vibrates in a call pattern (the ringtone is owned by the :reticulum service process)
  * - Retrieves the singleton [RnsTelephony] via Hilt's
  *   [RnsTelephonyEntryPoint] (the Activity itself is kept Hilt-free so
  *   cold start stays under the lock-screen ringing latency budget — see
@@ -75,8 +69,6 @@ class IncomingCallActivity : ComponentActivity() {
             .fromApplication(applicationContext, RnsTelephonyEntryPoint::class.java)
             .settingsRepository()
     }
-    private var ringtone: Ringtone? = null
-    private var ringtoneLoopJob: Job? = null
     private var vibrator: Vibrator? = null
 
     // Compose-observable state so UI updates when onNewIntent delivers a new call
@@ -100,8 +92,11 @@ class IncomingCallActivity : ComponentActivity() {
         // Show over lock screen and turn screen on
         configureWindowForIncomingCall()
 
-        // Start ringtone and vibration
-        startRingtoneAndVibration()
+        // Vibrate in a phone-call pattern. The ringtone itself is played by the
+        // :reticulum service process (LXST Telephone) which owns the call
+        // lifecycle; playing a second ringtone here would double-ring while the
+        // call screen is up.
+        startVibration()
 
         enableEdgeToEdge()
 
@@ -160,7 +155,7 @@ class IncomingCallActivity : ComponentActivity() {
     }
 
     override fun onDestroy() {
-        stopRingtoneAndVibration()
+        stopVibration()
         super.onDestroy()
     }
 
@@ -173,9 +168,9 @@ class IncomingCallActivity : ComponentActivity() {
         if (newHash != null) {
             currentIdentityHash.value = newHash
             currentCallerName.value = newName
-            // Restart ringtone/vibration for the new call
-            stopRingtoneAndVibration()
-            startRingtoneAndVibration()
+            // Restart vibration for the new call
+            stopVibration()
+            startVibration()
         }
     }
 
@@ -204,47 +199,15 @@ class IncomingCallActivity : ComponentActivity() {
     }
 
     /**
-     * Start playing the default ringtone and vibrating in a phone-call pattern.
-     * Respects the device's ringer mode (silent/vibrate/normal).
+     * Vibrate in a phone-call pattern. Respects the device's ringer mode (no
+     * vibration in silent mode). The ringtone itself is played by the
+     * :reticulum service process (LXST Telephone), which owns the call
+     * lifecycle and stops it on answer/hangup.
      */
-    private fun startRingtoneAndVibration() {
+    private fun startVibration() {
         val audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager
         val ringerMode = audioManager.ringerMode
 
-        // Play ringtone (only if not in silent/vibrate mode)
-        if (ringerMode == AudioManager.RINGER_MODE_NORMAL) {
-            try {
-                val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
-                ringtone =
-                    RingtoneManager.getRingtone(this, ringtoneUri)?.apply {
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-                            isLooping = true
-                        }
-                        audioAttributes =
-                            AudioAttributes
-                                .Builder()
-                                .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                                .build()
-                        play()
-                    }
-                // On pre-P devices, isLooping is not available; manually restart
-                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P && ringtone != null) {
-                    ringtoneLoopJob =
-                        lifecycleScope.launch {
-                            val rt = ringtone ?: return@launch
-                            while (isActive) {
-                                delay(1000)
-                                if (!rt.isPlaying) rt.play()
-                            }
-                        }
-                }
-                Log.d(TAG, "Ringtone started")
-            } catch (e: Exception) {
-                Log.e(TAG, "Error starting ringtone", e)
-            }
-        }
-
         // Vibrate (in normal or vibrate mode, not silent)
         if (ringerMode != AudioManager.RINGER_MODE_SILENT) {
             try {
@@ -275,18 +238,9 @@ class IncomingCallActivity : ComponentActivity() {
     }
 
     /**
-     * Stop ringtone and vibration.
+     * Stop vibration.
      */
-    private fun stopRingtoneAndVibration() {
-        ringtoneLoopJob?.cancel()
-        ringtoneLoopJob = null
-        try {
-            ringtone?.stop()
-            ringtone = null
-            Log.d(TAG, "Ringtone stopped")
-        } catch (e: Exception) {
-            Log.e(TAG, "Error stopping ringtone", e)
-        }
+    private fun stopVibration() {
         try {
             vibrator?.cancel()
             vibrator = null
@@ -306,7 +260,7 @@ class IncomingCallActivity : ComponentActivity() {
      */
     private fun answerCall() {
         Log.i(TAG, "Answering call")
-        stopRingtoneAndVibration()
+        stopVibration()
         dismissKeyguardAndAnswer()
     }
 
@@ -358,7 +312,7 @@ class IncomingCallActivity : ComponentActivity() {
      */
     private fun declineCall() {
         Log.i(TAG, "Declining call")
-        stopRingtoneAndVibration()
+        stopVibration()
         lifecycleScope.launch {
             try {
                 telephony.declineCall()

app/src/main/java/network/columba/app/MainActivity.kt

@@ -60,6 +60,7 @@ import androidx.core.content.ContextCompat
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.navigation.NavType
@@ -174,6 +175,9 @@ class MainActivity : ComponentActivity() {
     @Inject
     lateinit var transportAdmin: RnsTransportAdmin
 
+    @Inject
+    lateinit var mainActivityVisibility: MainActivityVisibility
+
     // State to hold pending navigation from intent
     private val pendingNavigation = mutableStateOf<PendingNavigation?>(null)
 
@@ -278,6 +282,28 @@ class MainActivity : ComponentActivity() {
             }
         }
 
+    override fun onStart() {
+        super.onStart()
+        // Issue #1079: while the main UI is visible it owns incoming-call
+        // presentation (in-app call screen); the background presenter stays
+        // quiet so it can never duplicate or resurrect the notification. The
+        // flag flip and this cancel run as one main-thread sequence (atomic
+        // claim), so a background post can never land after this cancel and
+        // survive it.
+        mainActivityVisibility.claimForeground {
+            CallNotificationHelper(this).cancelIncomingCallNotification()
+        }
+    }
+
+    override fun onStop() {
+        // Rotation keeps the foreground claim (isChangingConfigurations) so the
+        // background presenter never gets a post window mid-rotation; a real
+        // backgrounding releases ownership, which lets the presenter take the
+        // call back if it is still ringing (see IncomingCallPresenter).
+        mainActivityVisibility.releaseForeground(isChangingConfigurations)
+        super.onStop()
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         // Install splash screen before super.onCreate()
         // Splash screen will be displayed until theme is loaded, preventing flash
@@ -1167,7 +1193,16 @@ fun ColumbaNavigation(
             .fromApplication(context.applicationContext, RnsTelephonyEntryPoint::class.java)
             .telephony()
     }
-    val callState by telephony.callState.collectAsState()
+    // Lifecycle-gated collection (issue #1079): a plain collectAsState() keeps
+    // updating while the activity is STOPPED, so the effect below would fire
+    // for a backgrounded app, navigate to the (invisible) IncomingCallScreen,
+    // and cancel the presenter's full-screen-intent notification before the
+    // system can show it. With collectAsStateWithLifecycle the observation
+    // pauses while the activity is not visible, leaving background
+    // presentation to IncomingCallPresenter; when the app is brought to the
+    // front mid-call, collection resumes on the current state and this effect
+    // takes over normally.
+    val callState by telephony.callState.collectAsStateWithLifecycle()
 
     LaunchedEffect(callState) {
         when (val state = callState) {