Fix widget Duck.ai opening Input Screen when on new tab (#6806)

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

### Description

- Prevents the Input Screen from opening if Duck.ai is opened from the
widget and the app is on new tab

### Steps to test this PR

- [x] Open the app and use Duck.ai (so that Duck.ai shows on the widget)
- [x] Open a new tab
- [x] Kill the app
- [x] Add the widget
- [x] Tap the Duck.ai icon
- [x] Verify that Duck.ai is opened and the Input Screen is not shown

Author: joshliebe

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

@@ -452,6 +452,8 @@ class BrowserTabViewModelTest {
 
     private val mockHasPendingTabLaunchFlow = MutableStateFlow(false)
 
+    private val mockHasPendingDuckAiOpenFlow = MutableStateFlow(false)
+
     private val mockAppBuildConfig: AppBuildConfig = mock()
 
     private val mockDuckDuckGoUrlDetector: DuckDuckGoUrlDetector = mock()
@@ -657,6 +659,7 @@ class BrowserTabViewModelTest {
         whenever(mockDuckAiFeatureState.showInputScreen).thenReturn(mockDuckAiFeatureStateInputScreenFlow)
         whenever(mockDuckAiFeatureState.showInputScreenAutomaticallyOnNewTab).thenReturn(mockDuckAiFeatureStateInputScreenOpenAutomaticallyFlow)
         whenever(mockExternalIntentProcessingState.hasPendingTabLaunch).thenReturn(mockHasPendingTabLaunchFlow)
+        whenever(mockExternalIntentProcessingState.hasPendingDuckAiOpen).thenReturn(mockHasPendingDuckAiOpenFlow)
         whenever(mockOnboardingDesignExperimentManager.isModifiedControlEnrolledAndEnabled()).thenReturn(false)
         whenever(mockOnboardingDesignExperimentManager.isBuckEnrolledAndEnabled()).thenReturn(false)
         whenever(mockOnboardingDesignExperimentManager.isBbEnrolledAndEnabled()).thenReturn(false)
@@ -6995,6 +6998,58 @@ class BrowserTabViewModelTest {
         )
     }
 
+    @Test
+    fun whenInputScreenEnabledAndDuckAiOpenThenLaunchInputScreenCommandSuppressed() = 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(tabId = ntpTabId, initialUrl = null, skipHome = false, isExternal = false)
+        mockDuckAiFeatureStateInputScreenOpenAutomaticallyFlow.emit(true)
+        mockHasPendingDuckAiOpenFlow.emit(true)
+
+        flowSelectedTab.emit(ntpTab)
+
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        val commands = commandCaptor.allValues
+        assertFalse(
+            "LaunchInputScreen command should be suppressed when Duck.ai is opened",
+            commands.any { it is Command.LaunchInputScreen },
+        )
+    }
+
+    @Test
+    fun whenInputScreenEnabledAndDuckAiClosedThenLaunchInputScreenCommandTriggered() = 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(tabId = ntpTabId, initialUrl = null, skipHome = false, isExternal = false)
+        mockDuckAiFeatureStateInputScreenOpenAutomaticallyFlow.emit(true)
+        mockHasPendingDuckAiOpenFlow.emit(true)
+
+        // Switch to a new tab with no URL
+        flowSelectedTab.emit(ntpTab)
+
+        // Close Duck.ai
+        mockHasPendingDuckAiOpenFlow.emit(false)
+
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        val commands = commandCaptor.allValues
+        assertTrue(
+            "LaunchInputScreen command should be triggered when Duck.ai is closed",
+            commands.any { it is Command.LaunchInputScreen },
+        )
+    }
+
     @Test
     fun whenEvaluateSerpLogoStateCalledWithDuckDuckGoUrlAndFeatureEnabledThenExtractSerpLogoCommandIssued() {
         whenever(mockSerpEasterEggLogoToggles.feature()).thenReturn(mockEnabledToggle)

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

@@ -599,6 +599,9 @@ open class BrowserActivity : DuckDuckGoActivity() {
 
         if (intent.getBooleanExtra(OPEN_DUCK_CHAT, false)) {
             isDuckChatVisible = true
+            if (duckAiFeatureState.showInputScreenAutomaticallyOnNewTab.value) {
+                externalIntentProcessingState.onIntentRequestToOpenDuckAi()
+            }
             val duckChatSessionActive = intent.getBooleanExtra(DUCK_CHAT_SESSION_ACTIVE, false)
             viewModel.openDuckChat(intent.getStringExtra(DUCK_CHAT_URL), duckChatSessionActive, withTransition = duckAiShouldAnimate)
             return
@@ -833,6 +836,7 @@ open class BrowserActivity : DuckDuckGoActivity() {
 
     private fun closeDuckChat() {
         isDuckChatVisible = false
+        externalIntentProcessingState.onDuckAiClosed()
         val fragment = duckAiFragment
         if (fragment?.isVisible == true) {
             animateDuckAiFragmentOut {

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

@@ -738,7 +738,12 @@ class BrowserTabViewModel @Inject constructor(
             .launchIn(viewModelScope)
 
         // auto-launch input screen for new, empty tabs (New Tab Page)
-        externalIntentProcessingState.hasPendingTabLaunch.flatMapLatest {
+        combine(
+            externalIntentProcessingState.hasPendingTabLaunch,
+            externalIntentProcessingState.hasPendingDuckAiOpen,
+        ) { hasPendingTabLaunch, hasPendingDuckAiOpen ->
+            hasPendingTabLaunch || hasPendingDuckAiOpen
+        }.flatMapLatest {
             if (it) {
                 // suppress auto-launch while processing external intents (for example, opening links from other apps)
                 // this prevents the New Tab Page from incorrectly triggering the input screen when the app

app/src/main/java/com/duckduckgo/app/dispatchers/ExternalIntentProcessingState.kt

@@ -32,7 +32,10 @@ import kotlinx.coroutines.flow.onEach
 
 interface ExternalIntentProcessingState {
     val hasPendingTabLaunch: StateFlow<Boolean>
+    val hasPendingDuckAiOpen: StateFlow<Boolean>
     fun onIntentRequestToChangeTab()
+    fun onIntentRequestToOpenDuckAi()
+    fun onDuckAiClosed()
 }
 
 @ContributesBinding(AppScope::class)
@@ -44,6 +47,9 @@ class ExternalIntentProcessingStateImpl @Inject constructor(
     private val _hasPendingTabLaunch = MutableStateFlow(false)
     override val hasPendingTabLaunch: StateFlow<Boolean> = _hasPendingTabLaunch.asStateFlow()
 
+    private val _hasPendingDuckAiOpen = MutableStateFlow(false)
+    override val hasPendingDuckAiOpen: StateFlow<Boolean> = _hasPendingDuckAiOpen.asStateFlow()
+
     init {
         tabRepository.flowSelectedTab.filterNotNull().onEach { tab ->
             // if we are switching to a tab that already has a URL, consider tab launch processing complete
@@ -56,4 +62,12 @@ class ExternalIntentProcessingStateImpl @Inject constructor(
     override fun onIntentRequestToChangeTab() {
         _hasPendingTabLaunch.value = true
     }
+
+    override fun onIntentRequestToOpenDuckAi() {
+        _hasPendingDuckAiOpen.value = true
+    }
+
+    override fun onDuckAiClosed() {
+        _hasPendingDuckAiOpen.value = false
+    }
 }

app/src/test/java/com/duckduckgo/app/dispatchers/ExternalIntentProcessingStateTest.kt

@@ -170,4 +170,37 @@ class ExternalIntentProcessingStateTest {
             cancelAndConsumeRemainingEvents()
         }
     }
+
+    @Test
+    fun `when initialized then hasPendingDuckAiOpen is false`() = runTest {
+        testee.hasPendingDuckAiOpen.test {
+            assertFalse(awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `when onIntentRequestToOpenDuckAi called then hasPendingDuckAiOpen is true`() = runTest {
+        testee.hasPendingDuckAiOpen.test {
+            assertFalse(awaitItem())
+            testee.onIntentRequestToOpenDuckAi()
+
+            assertTrue(awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `when onDuckAiClosed called then hasPendingDuckAiOpen is false`() = runTest {
+        testee.onIntentRequestToOpenDuckAi()
+
+        testee.hasPendingDuckAiOpen.test {
+            assertTrue(awaitItem())
+
+            testee.onDuckAiClosed()
+
+            assertFalse(awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
 }