do not open the Input Screen when user pref toggled on and immediately off (#6615)

Task/Issue URL:
https://app.asana.com/1/137249556945/project/1208671518894266/task/1211091584703241?focus=true

### Description
Fixes an issue where toggling the experimental address bar on and then
immediately off again in "AI Features" settings still caused the Input
Screen to open when returning to the browser (if left on a New Tab
Page).

#### Root Cause
The Input Screen preferences flow in the `BrowserTabViewModel` (and its
nested flow that launches the Input Screen on NTP) was being restarted
every time the preference changed. As a result, toggling the setting
caused a re-evaluation, which queued a command to launch the Input
Screen when returning to the browser.

#### Fix
Instead of observing the Input Screen preference flow directly, we now
filter out events when the preference is disabled. This prevents
unnecessary re-evaluations on every toggle, while still ensuring that
whenever the tab changes, the current preference state is correctly
respected.

### Steps to test this PR

- [x] Install a clean build of the app.
- [x] Open a new tab and ensure that the address bar gets focused but
the Input Screen doesn't open.
- [x] Go to Settings -> AI Features
- [x] Enabled Experimental Address Bar
- [x] Disabled Experimental Address Bar
- [x] Go back to the browser and verify that Input Screen is not opened
- [x] (optional) Try some additional test steps from
#6604 to ensure that the
feature still works as expected otherwise

Author: LukasPaczos

.maestro/input_screen/input_screen_preference_management.yaml

@@ -26,7 +26,7 @@ tags:
       - action: back
       - action: back
 
-      # verify that the Input Screen doesn't automatically open when on new tab page
+      # verify that the Input Screen doesn't automatically open when coming back from settings
       - assertNotVisible:
           id: "inputModeWidget"
       - assertVisible:
@@ -39,6 +39,16 @@ tags:
       - assertVisible:
           id: "inputModeWidget"
 
+      # verify that opening new tab automatically opens the input screen
+      - inputText: "eff.org"
+      - tapOn:
+          id: "actionSend"
+      - runFlow: ../shared/browser_screen/click_on_tabs_button.yaml
+      - tapOn: "New Tab"
+      - assertVisible:
+          id: "inputModeWidget"
+      - action: back
+
       # disable global AI setting and verify the Input Screen is disabled
       - action: back
       - runFlow: ../shared/open_ai_settings_screen.yaml

.rules/maestro-ui-tests.md

@@ -28,7 +28,8 @@ The Maestro tests are organized into the following (non-exhaustive) main categor
 - `custom_tabs` - Custom tabs functionality tests 
 - `duckplayer` - DuckPlayer tests. Some of these can only be run locally.
 - `favorites` - Favorites management tests 
-- `fire_button` - Fire button (data clearing) tests 
+- `fire_button` - Fire button (data clearing) tests
+- `input_screen` - Input Screen and Experimental Address Bar that provides Search and Duck.ai toggle switch tests
 - `notifications_permissions_android13_plus` - Notification permission tests (Android 13+ only)
 - `onboarding` - User onboarding flow tests 
 - `ppro` - Privacy Pro subscription tests 

app/src/androidTest/java/com/duckduckgo/app/browser/BrowserTabViewModelTest.kt

@@ -7073,6 +7073,30 @@ class BrowserTabViewModelTest {
         )
     }
 
+    @Test
+    fun whenInputScreenPrefChangesToEnabledThenLaunchInputScreenCommandNotTriggered() = runTest {
+        val initialTabId = "initial-tab"
+        val initialTab = TabEntity(tabId = initialTabId, url = "https://example.com", title = "EX", skipHome = false, viewed = true, position = 0)
+        val ntpTabId = "ntp-tab"
+        val ntpTab = TabEntity(tabId = ntpTabId, url = null, title = "", skipHome = false, viewed = true, position = 0)
+        whenever(mockTabRepository.getTab(initialTabId)).thenReturn(initialTab)
+        whenever(mockTabRepository.getTab(ntpTabId)).thenReturn(ntpTab)
+        flowSelectedTab.emit(initialTab)
+
+        testee.loadData(ntpTabId, null, false, false)
+        mockDuckAiFeatureStateInputScreenFlow.emit(false)
+
+        flowSelectedTab.emit(ntpTab)
+        mockDuckAiFeatureStateInputScreenFlow.emit(true)
+
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        val commands = commandCaptor.allValues
+        assertFalse(
+            "LaunchInputScreen command should NOT be triggered when preference is toggled",
+            commands.any { it is Command.LaunchInputScreen },
+        )
+    }
+
     private fun aCredential(): LoginCredentials {
         return LoginCredentials(domain = null, username = null, password = null)
     }

app/src/main/java/com/duckduckgo/app/browser/BrowserTabViewModel.kt

@@ -379,7 +379,6 @@ import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
@@ -733,20 +732,13 @@ class BrowserTabViewModel @Inject constructor(
             }
             .launchIn(viewModelScope)
 
-        // observe when user open a new tab page and launch the input screen
-        duckAiFeatureState.showInputScreen
-            .flatMapLatest { inputScreenEnabled ->
-                if (inputScreenEnabled) {
-                    tabRepository.flowSelectedTab
-                        .distinctUntilChangedBy { selectedTab -> selectedTab?.tabId } // only observe when the tab changes and ignore further updates
-                        .filter { selectedTab ->
-                            // if the tab managed by this view model has just been activated, and it's a new tab (it has no URL), then fire an event
-                            val isActiveTab = selectedTab?.tabId == tabId
-                            isActiveTab && selectedTab?.url.isNullOrBlank()
-                        }
-                } else {
-                    flowOf()
-                }
+        // observe when user opens a new tab and launch the input screen, if the feature is enabled
+        tabRepository.flowSelectedTab
+            .distinctUntilChangedBy { selectedTab -> selectedTab?.tabId } // only observe when the tab changes and ignore further updates
+            .filter { selectedTab ->
+                // if the tab managed by this view model has just been activated, and it's a new tab (it has no URL), then fire an event
+                val isActiveTab = ::tabId.isInitialized && selectedTab?.tabId == tabId
+                duckAiFeatureState.showInputScreen.value && isActiveTab && selectedTab?.url.isNullOrBlank()
             }
             .flowOn(dispatchers.main()) // don't use the immediate dispatcher so that the tabId field has a chance to initialize
             .onEach {