automatically launch the Input Screen when New Tab Page opened (#6604)

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

### Description
With this PR, whenever a New Tab Page is opened, the Input Screen will
be launched automatically.

Implementing this had some challenges given how complex and fragile the
keyboard management implementation is.

I couldn't rely on the `BrowserTabFragment#onViewVisible`, which is
currently used to auto-focus on the omnibar, because that's getting
called whenever the fragment is resumed. So, if the logic to open the
Input Screen was part of this function, closing the Input Screen (which
is a separate activity) would resume the fragment and open the Input
Screen again, resulting in a loop.

Instead, I added the logic to observe whenever the tab changes and
dispatch a command to launch the Input Screen when user switches to a
New Tab Page (this tab has no URL). This logic lives as part of each
`BrowserTabFragment` so that the current active fragment, if it's a new
tab page, can launch the Input Screen and then listen for its results.

### Steps to test this PR

- [x] Install a clean build of the app.
- [x] Verify that opening a new tab page focuses on the omnibar
automatically.
- [x] Open a web page or SERP and verify that switching to a page
doesn't focus on the omnibar automatically.
- [x] Go to Settings -> AI Features and enable the Experimental Address
bar.
- [x] Go back to the browser and verify that creating a New Tab opens
the Input Screen automatically.
- [x] Back out from the Input Screen and verify you can see the New Tab
Page.
- [x] Go to another tab with a web page or SERP and verify that the
Input Screen doesn't open automatically.
- [x] Go back to the existing New Tab card in the tab switcher and
verify that the Input Screen Opens automatically.
- [x] Close the app.
- [x] Reopen the app.
- [x] Verify that the Input Screen launches automatically (because
you're still on a New Tab Page).
- [x] Use the fire button and verify that the Input Screen automatically
opens only after the fire animation finishes and the process restarts.

### UI changes


https://github.com/user-attachments/assets/11bf872d-bc09-46b4-9ecf-77a4a843a064

Author: LukasPaczos

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

@@ -446,6 +446,8 @@ class BrowserTabViewModelTest {
 
     private val mockDuckAiFeatureState: DuckAiFeatureState = mock()
 
+    private val mockDuckAiFeatureStateInputScreenFlow = MutableStateFlow(false)
+
     private val mockAppBuildConfig: AppBuildConfig = mock()
 
     private val mockDuckDuckGoUrlDetector: DuckDuckGoUrlDetector = mock()
@@ -584,6 +586,7 @@ class BrowserTabViewModelTest {
     private val SHORT_EXAMPLE_URL = "example.com"
 
     private val selectedTab = TabEntity("TAB_ID", EXAMPLE_URL, position = 0, sourceTabId = "TAB_ID_SOURCE")
+    private val flowSelectedTab = MutableStateFlow(selectedTab)
 
     private var isFullSiteAddressEnabled = true
 
@@ -620,7 +623,7 @@ class BrowserTabViewModelTest {
         whenever(mockDismissedCtaDao.dismissedCtas()).thenReturn(dismissedCtaDaoChannel.consumeAsFlow())
         whenever(mockTabRepository.flowTabs).thenReturn(flowOf(emptyList()))
         whenever(mockTabRepository.getTabs()).thenReturn(emptyList())
-        whenever(mockTabRepository.flowSelectedTab).thenReturn(flowOf(selectedTab))
+        whenever(mockTabRepository.flowSelectedTab).thenReturn(flowSelectedTab)
         whenever(mockTabRepository.liveTabs).thenReturn(tabsLiveData)
         whenever(mockEmailManager.signedInFlow()).thenReturn(emailStateFlow.asStateFlow())
         whenever(mockSavedSitesRepository.getFavorites()).thenReturn(favoriteListFlow.consumeAsFlow())
@@ -641,7 +644,7 @@ class BrowserTabViewModelTest {
         whenever(mockToggleReports.shouldPrompt()).thenReturn(false)
         whenever(subscriptions.isEligible()).thenReturn(false)
         whenever(mockDuckAiFeatureState.showPopupMenuShortcut).thenReturn(MutableStateFlow(false))
-        whenever(mockDuckAiFeatureState.showInputScreen).thenReturn(MutableStateFlow(false))
+        whenever(mockDuckAiFeatureState.showInputScreen).thenReturn(mockDuckAiFeatureStateInputScreenFlow)
         whenever(mockOnboardingDesignExperimentManager.isModifiedControlEnrolledAndEnabled()).thenReturn(false)
         whenever(mockOnboardingDesignExperimentManager.isBuckEnrolledAndEnabled()).thenReturn(false)
         whenever(mockOnboardingDesignExperimentManager.isBbEnrolledAndEnabled()).thenReturn(false)
@@ -6978,6 +6981,98 @@ class BrowserTabViewModelTest {
         verify(mockOnboardingDesignExperimentManager).fireFireButtonClickedFromOnboardingPixel()
     }
 
+    @Test
+    fun whenInputScreenEnabledAndSwitchToNewTabThenLaunchInputScreenCommandTriggered() = 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(true)
+
+        flowSelectedTab.emit(ntpTab)
+
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        val commands = commandCaptor.allValues
+        assertTrue(
+            "LaunchInputScreen command should be triggered for null URL tab",
+            commands.any { it is Command.LaunchInputScreen },
+        )
+    }
+
+    @Test
+    fun whenInputScreenDisabledAndSwitchToNewTabThenLaunchInputScreenCommandTriggered() = 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)
+
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        val commands = commandCaptor.allValues
+        assertFalse(
+            "LaunchInputScreen command should NOT be triggered when input screen is disabled",
+            commands.any { it is Command.LaunchInputScreen },
+        )
+    }
+
+    @Test
+    fun whenInputScreenEnabledAndSwitchToTabWithUrlThenLaunchInputScreenCommandNotTriggered() = runTest {
+        val initialTabId = "initial-tab"
+        val initialTab = TabEntity(tabId = initialTabId, url = "https://example.com", title = "EX", skipHome = false, viewed = true, position = 0)
+        val targetTabId = "target-tab"
+        val targetTab = TabEntity(tabId = targetTabId, url = "https://duckduckgo.com", title = "DDG", skipHome = false, viewed = true, position = 0)
+        whenever(mockTabRepository.getTab(initialTabId)).thenReturn(initialTab)
+        whenever(mockTabRepository.getTab(targetTabId)).thenReturn(targetTab)
+        flowSelectedTab.emit(initialTab)
+
+        testee.loadData(targetTabId, null, false, false)
+        mockDuckAiFeatureStateInputScreenFlow.emit(true)
+
+        flowSelectedTab.emit(targetTab)
+
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        val commands = commandCaptor.allValues
+        assertFalse(
+            "LaunchInputScreen command should NOT be triggered when switching to tab with existing URL",
+            commands.any { it is Command.LaunchInputScreen },
+        )
+    }
+
+    @Test
+    fun whenInputScreenEnabledAndSwitchToNewTabThatManagedByAnotherViewModelThenLaunchInputScreenCommandNotTriggered() = 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(initialTabId, null, false, false)
+        mockDuckAiFeatureStateInputScreenFlow.emit(true)
+
+        flowSelectedTab.emit(ntpTab)
+
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        val commands = commandCaptor.allValues
+        assertFalse(
+            "LaunchInputScreen command should NOT be triggered when switching to new tab that's managed by another view model",
+            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/BrowserTabFragment.kt

@@ -1100,21 +1100,25 @@ class BrowserTabFragment :
 
     private fun configureInputScreenLauncher() {
         omnibar.configureInputScreenLaunchListener { query ->
-            val intent = globalActivityStarter.startIntent(
-                requireContext(),
-                InputScreenActivityParams(query = query),
-            )
-            val enterTransition = browserAndInputScreenTransitionProvider.getInputScreenEnterAnimation()
-            val exitTransition = browserAndInputScreenTransitionProvider.getBrowserExitAnimation()
-            val options = ActivityOptionsCompat.makeCustomAnimation(
-                requireActivity(),
-                enterTransition,
-                exitTransition,
-            )
-            inputScreenLauncher.launch(intent, options)
+            launchInputScreen(query)
         }
     }
 
+    private fun launchInputScreen(query: String) {
+        val intent = globalActivityStarter.startIntent(
+            requireContext(),
+            InputScreenActivityParams(query = query),
+        )
+        val enterTransition = browserAndInputScreenTransitionProvider.getInputScreenEnterAnimation()
+        val exitTransition = browserAndInputScreenTransitionProvider.getBrowserExitAnimation()
+        val options = ActivityOptionsCompat.makeCustomAnimation(
+            requireActivity(),
+            enterTransition,
+            exitTransition,
+        )
+        inputScreenLauncher.launch(intent, options)
+    }
+
     private fun configureNavigationBar() {
         val observer = object : BrowserNavigationBarObserver {
             override fun onFireButtonClicked() {
@@ -2202,6 +2206,12 @@ class BrowserTabFragment :
 
             is Command.StartTrackersExperimentShieldPopAnimation -> showTrackersExperimentShieldPopAnimation()
             is Command.RefreshOmnibar -> renderer.refreshOmnibar()
+            is Command.LaunchInputScreen -> {
+                // if the fire button is used, prevent automatically launching the input screen until the process reloads
+                if ((requireActivity() as? BrowserActivity)?.isDataClearingInProgress == false) {
+                    launchInputScreen(query = "")
+                }
+            }
             else -> {
                 // NO OP
             }

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

@@ -105,6 +105,7 @@ import com.duckduckgo.app.browser.commands.Command.LaunchAddWidget
 import com.duckduckgo.app.browser.commands.Command.LaunchAutofillSettings
 import com.duckduckgo.app.browser.commands.Command.LaunchBookmarksActivity
 import com.duckduckgo.app.browser.commands.Command.LaunchFireDialogFromOnboardingDialog
+import com.duckduckgo.app.browser.commands.Command.LaunchInputScreen
 import com.duckduckgo.app.browser.commands.Command.LaunchNewTab
 import com.duckduckgo.app.browser.commands.Command.LaunchPopupMenu
 import com.duckduckgo.app.browser.commands.Command.LaunchPrivacyPro
@@ -374,8 +375,11 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.distinctUntilChanged
+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
@@ -394,6 +398,7 @@ import org.json.JSONObject
 
 private const val SCAM_PROTECTION_REPORT_ERROR_URL = "https://duckduckgo.com/malicious-site-protection/report-error?url="
 
+@OptIn(ExperimentalCoroutinesApi::class)
 @ContributesViewModel(FragmentScope::class)
 class BrowserTabViewModel @Inject constructor(
     private val statisticsUpdater: StatisticsUpdater,
@@ -727,6 +732,28 @@ class BrowserTabViewModel @Inject constructor(
                 browserViewState.value = currentBrowserViewState().copy(showSelectDefaultBrowserMenuItem = it)
             }
             .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()
+                }
+            }
+            .flowOn(dispatchers.main()) // don't use the immediate dispatcher so that the tabId field has a chance to initialize
+            .onEach {
+                // whenever an event fires, so the user switched to a new tab page, launch the input screen
+                command.value = LaunchInputScreen
+            }
+            .launchIn(viewModelScope)
     }
 
     fun loadData(

app/src/main/java/com/duckduckgo/app/browser/commands/Command.kt

@@ -279,4 +279,5 @@ sealed class Command {
     data object LaunchBookmarksActivity : Command()
     data object StartTrackersExperimentShieldPopAnimation : Command()
     data object RefreshOmnibar : Command()
+    data object LaunchInputScreen : Command()
 }