Show Pin/Unpin snackbar with Undo action

Surfaces a snackbar after the per-row Pin/Unpin overflow action so the
user can recover from a mistap. The toggle still fires immediately; the
snackbar is purely informational + an Undo affordance that re-issues
setPinned with the previous value.

Also fixes a pre-existing build break in RecordingRenameRepository,
which was missing the setPinned override added in b3157b9.

Author: GerardPaligot

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/history/ChatHistoryFragment.kt

@@ -125,6 +125,11 @@ class ChatHistoryFragment : DuckDuckGoFragment(R.layout.fragment_chat_history) {
             .flowWithLifecycle(viewLifecycleOwner.lifecycle, Lifecycle.State.STARTED)
             .onEach(::onNavigationEvent)
             .launchIn(viewLifecycleOwner.lifecycleScope)
+
+        viewModel.messageEvents
+            .flowWithLifecycle(viewLifecycleOwner.lifecycle, Lifecycle.State.STARTED)
+            .onEach(::onMessageEvent)
+            .launchIn(viewLifecycleOwner.lifecycleScope)
     }
 
     private fun onNavigationEvent(event: ChatHistoryViewModel.NavigationEvent) {
@@ -133,6 +138,25 @@ class ChatHistoryFragment : DuckDuckGoFragment(R.layout.fragment_chat_history) {
         }
     }
 
+    private fun onMessageEvent(event: ChatHistoryViewModel.MessageEvent) {
+        when (event) {
+            is ChatHistoryViewModel.MessageEvent.PinToggled -> showPinToggledSnackbar(event)
+        }
+    }
+
+    private fun showPinToggledSnackbar(event: ChatHistoryViewModel.MessageEvent.PinToggled) {
+        val messageRes = if (event.wasPinned) {
+            R.string.duck_ai_chat_history_unpin_snackbar
+        } else {
+            R.string.duck_ai_chat_history_pin_snackbar
+        }
+        Snackbar.make(binding.root, messageRes, Snackbar.LENGTH_LONG)
+            .setAction(R.string.duck_ai_chat_history_undo) {
+                viewModel.onUndoTogglePin(event.chatId, restorePinned = event.wasPinned)
+            }
+            .show()
+    }
+
     private fun openRenameScreen(chatId: String, currentTitle: String) {
         parentFragmentManager.beginTransaction()
             .replace(R.id.chatHistoryFragmentContainer, RenameChatFragment.newInstance(chatId, currentTitle))

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/history/ChatHistoryViewModel.kt

@@ -57,6 +57,9 @@ class ChatHistoryViewModel @Inject constructor(
     private val navigationChannel = Channel<NavigationEvent>(capacity = Channel.BUFFERED, onBufferOverflow = BufferOverflow.DROP_OLDEST)
     val navigationEvents: Flow<NavigationEvent> = navigationChannel.receiveAsFlow()
 
+    private val messageChannel = Channel<MessageEvent>(capacity = Channel.BUFFERED, onBufferOverflow = BufferOverflow.DROP_OLDEST)
+    val messageEvents: Flow<MessageEvent> = messageChannel.receiveAsFlow()
+
     /** Cached snapshot so non-suspend action methods can read Recent without re-subscribing. */
     private var latestItems: List<ChatHistoryItem> = emptyList()
 
@@ -136,7 +139,13 @@ class ChatHistoryViewModel @Inject constructor(
 
     fun onTogglePin(chatId: String) {
         val current = latestItems.firstOrNull { it.chatId == chatId } ?: return
-        appScope.launch { chatHistoryRepository.setPinned(chatId, !current.pinned) }
+        val wasPinned = current.pinned
+        appScope.launch { chatHistoryRepository.setPinned(chatId, !wasPinned) }
+        messageChannel.trySend(MessageEvent.PinToggled(chatId = chatId, wasPinned = wasPinned))
+    }
+
+    fun onUndoTogglePin(chatId: String, restorePinned: Boolean) {
+        appScope.launch { chatHistoryRepository.setPinned(chatId, restorePinned) }
     }
 
     private fun dispatchSelectedClear(chatIds: Set<String>) {
@@ -267,6 +276,10 @@ class ChatHistoryViewModel @Inject constructor(
         data class OpenRename(val chatId: String, val currentTitle: String) : NavigationEvent
     }
 
+    sealed interface MessageEvent {
+        data class PinToggled(val chatId: String, val wasPinned: Boolean) : MessageEvent
+    }
+
     private companion object {
         const val STOP_TIMEOUT_MILLIS = 5_000L
     }

duckchat/duckchat-impl/src/main/res/values/donottranslate.xml

@@ -107,4 +107,7 @@
     <string name="duck_ai_chat_history_rename_confirm_title">Save</string>
     <string name="duck_ai_chat_history_rename_confirm_content_description">Save chat title</string>
     <string name="duck_ai_chat_history_rename_error">Couldn\'t rename chat</string>
+    <string name="duck_ai_chat_history_pin_snackbar">Chat pinned</string>
+    <string name="duck_ai_chat_history_unpin_snackbar">Chat unpinned</string>
+    <string name="duck_ai_chat_history_undo">Undo</string>
 </resources>

duckchat/duckchat-impl/src/test/kotlin/com/duckduckgo/duckchat/impl/history/ChatHistoryViewModelTest.kt

@@ -858,6 +858,66 @@ class ChatHistoryViewModelTest {
         assertTrue(repository.pinnedChats.isEmpty())
     }
 
+    @Test
+    fun `onTogglePin emits PinToggled message event with previous pinned state false`() = coroutineRule.testScope.runTest {
+        source.value = listOf(item("a", pinned = false))
+
+        viewModel.messageEvents.test {
+            // Drain the initial Loaded state so latestItems is primed.
+            viewModel.uiState.test { awaitInitialLoaded() }
+            viewModel.onTogglePin("a")
+
+            val event = awaitItem()
+            assertTrue(event is ChatHistoryViewModel.MessageEvent.PinToggled)
+            event as ChatHistoryViewModel.MessageEvent.PinToggled
+            assertEquals("a", event.chatId)
+            assertEquals(false, event.wasPinned)
+        }
+    }
+
+    @Test
+    fun `onTogglePin emits PinToggled message event with previous pinned state true`() = coroutineRule.testScope.runTest {
+        source.value = listOf(item("a", pinned = true))
+
+        viewModel.messageEvents.test {
+            viewModel.uiState.test { awaitInitialLoaded() }
+            viewModel.onTogglePin("a")
+
+            val event = awaitItem()
+            assertTrue(event is ChatHistoryViewModel.MessageEvent.PinToggled)
+            event as ChatHistoryViewModel.MessageEvent.PinToggled
+            assertEquals("a", event.chatId)
+            assertEquals(true, event.wasPinned)
+        }
+    }
+
+    @Test
+    fun `onTogglePin emits no message event when chatId is unknown`() = coroutineRule.testScope.runTest {
+        source.value = listOf(item("a", pinned = false))
+
+        viewModel.messageEvents.test {
+            viewModel.uiState.test { awaitInitialLoaded() }
+            viewModel.onTogglePin("missing")
+            expectNoEvents()
+        }
+    }
+
+    @Test
+    fun `onUndoTogglePin restores the requested pinned state via the repository`() = coroutineRule.testScope.runTest {
+        source.value = listOf(item("a", pinned = true))
+
+        viewModel.uiState.test {
+            awaitInitialLoaded()
+            viewModel.onTogglePin("a") // a → unpinned
+            awaitItem() // Loaded after the unpin write
+            viewModel.onUndoTogglePin("a", restorePinned = true)
+            val restored = awaitItem() as Loaded
+            assertEquals(listOf("a"), restored.pinned.map { it.chatId })
+            assertEquals(emptyList<String>(), restored.recent.map { it.chatId })
+        }
+        assertEquals(listOf("a" to false, "a" to true), repository.pinnedChats)
+    }
+
     /**
      * `stateIn(WhileSubscribed)` does not guarantee subscribers observe the `Loading` initial
      * value — the upstream may emit before the StateFlow can replay it. Tolerate both orderings.

duckchat/duckchat-impl/src/test/kotlin/com/duckduckgo/duckchat/impl/history/RenameChatViewModelTest.kt

@@ -81,4 +81,6 @@ private class RecordingRenameRepository : ChatHistoryRepository {
         renames += chatId to newTitle
         return nextResult
     }
+
+    override suspend fun setPinned(chatId: String, pinned: Boolean) = Unit
 }