fix(ui): keep launch request ids counting across activity recreation

A refuting review of the blocked-log routing found that a recreated
MainActivity restarted its request ids at 0 while the tab and Blocked-log
guards restored the ids they had already handled. The next shortcut or
summary tap could reuse a handled id and be ignored; on the emulator a cold
start from the summary, a font-scale relaunch and a second tap left the
user on Home (reproduced on the pre-fix build, fixed on this one). The
saved state now carries the current id, so numbering continues.

A launch request that switches tabs also closes an open search. Switching
to the tab already selected never fired the tab-change effect, so the
search kept covering the Blocked log.

MainActivityIntentTest gains a regression test for the restored id; no
existing test changed.

Author: SysAdminDoc

CHANGELOG.md

@@ -176,6 +176,9 @@ All notable changes to CallShield will be documented in this file.
 
 - Tapping the "blocked recently" notification opens the Blocked log now. It
   used to do nothing at all.
+- After the screen rotated or the font size changed, the next tap on an app
+  shortcut or on that notification could be ignored. It opens its tab every
+  time now, and it closes an open search, which used to cover the tab.
 
 - Setup now says what to do when Android won't let a permission through. Apps
   installed outside an app store run into Android's restricted settings. The

app/src/main/java/com/sysadmindoc/callshield/ui/MainActivity.kt

@@ -78,20 +78,15 @@ class MainActivity : AppCompatActivity() {
         // deep link / shortcut was handled in a previous incarnation and must
         // not re-run a scan, re-open a closed detail screen, or yank the
         // user's tab back to the shortcut target.
-        launchRequest =
-            if (savedInstanceState?.getBoolean(KEY_LAUNCH_CONSUMED) == true) {
-                LaunchRequest(id = 0)
-            } else {
-                intent.toLaunchRequest(nextId = 1)
-            }
+        launchRequest = launchRequestFor(intent, savedInstanceState)
         consumeLaunchIntent()
 
         setContent { CallShieldRoot(launchRequest = launchRequest) }
     }
 
     override fun onSaveInstanceState(outState: Bundle) {
         super.onSaveInstanceState(outState)
-        outState.putBoolean(KEY_LAUNCH_CONSUMED, true)
+        outState.putLaunchState(launchRequest)
     }
 
     override fun onNewIntent(intent: Intent) {
@@ -104,17 +99,13 @@ class MainActivity : AppCompatActivity() {
     /**
      * Strip the consumed launch payload (deep-link number, shortcut action)
      * after it has been folded into [launchRequest]. Defense-in-depth next to
-     * the [KEY_LAUNCH_CONSUMED] saved-state flag (which is what actually
-     * survives recreation — see onCreate).
+     * the saved-state flag (which is what actually survives recreation, see
+     * [launchRequestFor]).
      */
     private fun consumeLaunchIntent() {
         intent = Intent(this, MainActivity::class.java)
     }
 
-    private companion object {
-        const val KEY_LAUNCH_CONSUMED = "callshield_launch_consumed"
-    }
-
     override fun onResume() {
         super.onResume()
         // Re-evaluate protection health whenever the user returns to the app —
@@ -220,6 +211,12 @@ fun CallShieldApp(
         if (tabRequestId != null && tabRequestId != handledTabRequest) {
             handledTabRequest = tabRequestId
             selectedTab = startTab
+            // A search left open would cover the tab this request asked for,
+            // and switching to the tab already selected doesn't close it.
+            if (showSearch) {
+                showSearch = false
+                viewModel.setSearchQuery("")
+            }
         }
     }
 
@@ -874,6 +871,30 @@ internal fun launchTab(shortcutAction: String?): Int =
 /** This request's id when it asks for the blocked log, so Activity can switch to it once. */
 internal fun LaunchRequest.blockedLogRequestId(): Int? = id.takeIf { shortcutAction == ACTION_OPEN_BLOCKED_LOG }
 
+private const val KEY_LAUNCH_CONSUMED = "callshield_launch_consumed"
+private const val KEY_LAUNCH_REQUEST_ID = "callshield_launch_request_id"
+
+/**
+ * The request a (re)created activity starts with. A recreation keeps the id
+ * it had instead of restarting the count: the tab and Blocked-log guards saved
+ * the ids they already handled, and a later tap numbered from scratch could
+ * land on one of those and be ignored.
+ */
+internal fun launchRequestFor(
+    intent: Intent?,
+    savedInstanceState: Bundle?,
+): LaunchRequest =
+    if (savedInstanceState?.getBoolean(KEY_LAUNCH_CONSUMED) == true) {
+        LaunchRequest(id = savedInstanceState.getInt(KEY_LAUNCH_REQUEST_ID))
+    } else {
+        intent.toLaunchRequest(nextId = 1)
+    }
+
+internal fun Bundle.putLaunchState(request: LaunchRequest) {
+    putBoolean(KEY_LAUNCH_CONSUMED, true)
+    putInt(KEY_LAUNCH_REQUEST_ID, request.id)
+}
+
 private val KNOWN_SHORTCUT_ACTIONS =
     setOf(
         "com.sysadmindoc.callshield.LOOKUP",

app/src/test/java/com/sysadmindoc/callshield/ui/MainActivityIntentTest.kt

@@ -2,6 +2,7 @@ package com.sysadmindoc.callshield.ui
 
 import android.content.Intent
 import android.net.Uri
+import android.os.Bundle
 import com.sysadmindoc.callshield.ui.screens.activity.ACTIVITY_BLOCKED
 import com.sysadmindoc.callshield.ui.screens.activity.ACTIVITY_RECENT
 import com.sysadmindoc.callshield.ui.screens.activity.initialActivityView
@@ -81,6 +82,24 @@ class MainActivityIntentTest {
         assertEquals(ACTIVITY_BLOCKED, initialActivityView(request.blockedLogRequestId()))
     }
 
+    @Test
+    fun `a recreated activity keeps counting request ids instead of starting over`() {
+        // Three summary taps: the first launch, then two onNewIntent calls.
+        val first = launchRequestFor(Intent(ACTION_OPEN_BLOCKED_LOG), savedInstanceState = null)
+        val third = Intent(ACTION_OPEN_BLOCKED_LOG).toLaunchRequest(nextId = first.id + 2)
+
+        // Rotation or a theme change replays the original intent into onCreate.
+        val saved = Bundle().apply { putLaunchState(third) }
+        val recreated = launchRequestFor(Intent(ACTION_OPEN_BLOCKED_LOG), saved)
+
+        assertEquals(3, recreated.id)
+        assertNull(recreated.shortcutAction)
+        assertNull(recreated.deepLinkNumber)
+        // The tab and Blocked-log guards saved ids 1 to 3, so the next tap must get 4.
+        val next = Intent(ACTION_OPEN_BLOCKED_LOG).toLaunchRequest(nextId = recreated.id + 1)
+        assertEquals(4, next.blockedLogRequestId())
+    }
+
     @Test
     fun `other launches leave Activity on Recent`() {
         val lookup = Intent("com.sysadmindoc.callshield.LOOKUP").toLaunchRequest(nextId = 2)