Wire per-row Pin/Unpin in chat history overflow menu

Author: GerardPaligot

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

@@ -29,6 +29,7 @@ import androidx.recyclerview.widget.LinearLayoutManager
 import com.duckduckgo.anvil.annotations.InjectWith
 import com.duckduckgo.common.ui.DuckDuckGoFragment
 import com.duckduckgo.common.ui.menu.PopupMenu
+import com.duckduckgo.common.ui.view.PopupMenuItemView
 import com.duckduckgo.common.ui.view.SearchBar
 import com.duckduckgo.common.ui.view.gone
 import com.duckduckgo.common.ui.view.show
@@ -286,7 +287,10 @@ class ChatHistoryFragment : DuckDuckGoFragment(R.layout.fragment_chat_history) {
     private fun showRowPopup(item: ChatHistoryItem, anchor: View) {
         val popup = PopupMenu(layoutInflater, R.layout.popup_chat_history_row)
         val view = popup.contentView
-        popup.onMenuItemClicked(view.findViewById(R.id.pin)) { showComingSoonSnackbar() }
+        val pinAction = view.findViewById<PopupMenuItemView>(R.id.pin)
+        val pinLabel = if (item.pinned) R.string.duck_ai_chat_history_action_unpin else R.string.duck_ai_chat_history_action_pin
+        pinAction.setPrimaryText(getString(pinLabel))
+        popup.onMenuItemClicked(pinAction) { viewModel.onTogglePin(item.chatId) }
         popup.onMenuItemClicked(view.findViewById(R.id.rename)) {
             viewModel.onRenameRequested(item.chatId, item.displayTitle)
         }

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

@@ -36,6 +36,7 @@ interface ChatHistoryRepository {
     suspend fun deleteChat(chatId: String)
     suspend fun deleteAllChats()
     suspend fun renameChat(chatId: String, newTitle: String)
+    suspend fun setPinned(chatId: String, pinned: Boolean)
 }
 
 @ContributesBinding(AppScope::class)
@@ -64,6 +65,10 @@ class RealChatHistoryRepository @Inject constructor(
         withContext(dispatchers.io()) { chatStore.renameChat(chatId, newTitle) }
     }
 
+    override suspend fun setPinned(chatId: String, pinned: Boolean) {
+        withContext(dispatchers.io()) { chatStore.setPinned(chatId, pinned) }
+    }
+
     private fun toChatHistoryItem(chat: DuckAiChat): ChatHistoryItem = ChatHistoryItem(
         chatId = chat.chatId,
         displayTitle = chat.title.takeIf { it.isNotBlank() && it != UPSTREAM_UNTITLED } ?: fallbackTitle,

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

@@ -150,6 +150,11 @@ class ChatHistoryViewModel @Inject constructor(
         navigationChannel.trySend(NavigationEvent.OpenRename(chatId = chatId, currentTitle = currentTitle))
     }
 
+    fun onTogglePin(chatId: String) {
+        val current = latestItems.firstOrNull { it.chatId == chatId } ?: return
+        appScope.launch { chatHistoryRepository.setPinned(chatId, !current.pinned) }
+    }
+
     private fun dispatchSelectedClear(chatIds: Set<String>) {
         if (chatIds.isEmpty()) return
         val urls = chatIds.mapTo(mutableSetOf()) { duckChat.buildChatUrl(it) }

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

@@ -710,6 +710,46 @@ class ChatHistoryViewModelTest {
         }
     }
 
+    @Test
+    fun `onTogglePin flips pinned to true when row was unpinned`() = coroutineRule.testScope.runTest {
+        source.value = listOf(item("a", pinned = false))
+
+        viewModel.uiState.test {
+            awaitInitialLoaded()
+            viewModel.onTogglePin("a")
+            val updated = awaitItem() as Loaded
+            assertEquals(listOf("a"), updated.pinned.map { it.chatId })
+            assertEquals(emptyList<String>(), updated.recent.map { it.chatId })
+        }
+        assertEquals(listOf("a" to true), repository.pinnedChats)
+    }
+
+    @Test
+    fun `onTogglePin flips pinned to false when row was pinned`() = coroutineRule.testScope.runTest {
+        source.value = listOf(item("a", pinned = true))
+
+        viewModel.uiState.test {
+            awaitInitialLoaded()
+            viewModel.onTogglePin("a")
+            val updated = awaitItem() as Loaded
+            assertEquals(emptyList<String>(), updated.pinned.map { it.chatId })
+            assertEquals(listOf("a"), updated.recent.map { it.chatId })
+        }
+        assertEquals(listOf("a" to false), repository.pinnedChats)
+    }
+
+    @Test
+    fun `onTogglePin is a no-op when chatId is unknown`() = coroutineRule.testScope.runTest {
+        source.value = listOf(item("a", pinned = false))
+
+        viewModel.uiState.test {
+            awaitInitialLoaded()
+            viewModel.onTogglePin("missing")
+            expectNoEvents()
+        }
+        assertTrue(repository.pinnedChats.isEmpty())
+    }
+
     @Test
     fun `concurrent repository emission removing a selected id reconciles the selection`() = runTest {
         source.value = listOf(item("a"), item("b"), item("c"))
@@ -762,6 +802,7 @@ private class FakeChatHistoryRepository(
 ) : ChatHistoryRepository {
     val deletedChatIds: MutableList<String> = mutableListOf()
     val renamedChats: MutableList<Pair<String, String>> = mutableListOf()
+    val pinnedChats: MutableList<Pair<String, Boolean>> = mutableListOf()
     var deleteAllChatsCalled: Boolean = false
         private set
 
@@ -780,6 +821,11 @@ private class FakeChatHistoryRepository(
     override suspend fun renameChat(chatId: String, newTitle: String) {
         renamedChats += chatId to newTitle
     }
+
+    override suspend fun setPinned(chatId: String, pinned: Boolean) {
+        pinnedChats += chatId to pinned
+        source.value = source.value.map { if (it.chatId == chatId) it.copy(pinned = pinned) else it }
+    }
 }
 
 private class RecordingDataClearingTrigger : DataClearingTrigger {

duckchat/duckchat-store/src/main/java/com/duckduckgo/duckchat/store/impl/RealDuckAiChatStore.kt

@@ -66,6 +66,9 @@ interface DuckAiChatStore {
 
     /** Renames [chatId] in the FE-owned JSON blob. Returns true if the chat existed and was updated, false otherwise. */
     suspend fun renameChat(chatId: String, newTitle: String): Boolean
+
+    /** Sets the pinned flag on [chatId]. Returns true if the chat existed and was updated, false otherwise. */
+    suspend fun setPinned(chatId: String, pinned: Boolean): Boolean
 }
 
 @SingleInstanceIn(AppScope::class)
@@ -143,6 +146,17 @@ class RealDuckAiChatStore @Inject constructor(
             true
         }
 
+    override suspend fun setPinned(chatId: String, pinned: Boolean): Boolean =
+        withContext(dispatchers.io()) {
+            logcat { "DuckAI: RealDuckAiChatStore.setPinned($chatId, $pinned)" }
+            val entity = chatsDao.getById(chatId) ?: return@withContext false
+            val updatedJson = runCatching {
+                JSONObject(entity.data).put("pinned", pinned).toString()
+            }.getOrNull() ?: return@withContext false
+            chatsDao.upsert(entity.copy(data = updatedJson))
+            true
+        }
+
     private fun DuckAiBridgeChatEntity.toDuckAiChat(): DuckAiChat? = runCatching {
         val json = JSONObject(data)
         val chatId = json.optString("chatId").takeIf { it.isNotEmpty() } ?: return@runCatching null

duckchat/duckchat-store/src/test/kotlin/com/duckduckgo/duckchat/store/impl/RealDuckAiChatStoreTest.kt

@@ -336,4 +336,43 @@ class RealDuckAiChatStoreTest {
         // traversal file should not be deleted — it's outside filesDir
         verify(chatsDao).deleteAll()
     }
+
+    // --- setPinned ---
+
+    @Test
+    fun `setPinned returns false when chat not found`() = runTest {
+        whenever(chatsDao.getById("missing")).thenReturn(null)
+
+        assertFalse(store.setPinned("missing", true))
+        verify(chatsDao, never()).upsert(any())
+    }
+
+    @Test
+    fun `setPinned updates only the pinned flag and preserves other JSON fields`() = runTest {
+        val originalJson = """
+            {"chatId":"abc","title":"Old","model":"gpt-5-mini","lastEdit":"2026-04-01T21:31:54.260Z","pinned":false,"fileRefs":["uuid1"],"messages":[{"role":"user","text":"hi"}]}
+        """.trimIndent()
+        whenever(chatsDao.getById("abc")).thenReturn(DuckAiBridgeChatEntity("abc", originalJson))
+
+        assertTrue(store.setPinned("abc", true))
+
+        val entityCaptor = argumentCaptor<DuckAiBridgeChatEntity>()
+        verify(chatsDao).upsert(entityCaptor.capture())
+        val json = JSONObject(entityCaptor.firstValue.data)
+        assertTrue(json.getBoolean("pinned"))
+        assertEquals("Old", json.getString("title"))
+        assertEquals("abc", json.getString("chatId"))
+        assertEquals("gpt-5-mini", json.getString("model"))
+        assertEquals("2026-04-01T21:31:54.260Z", json.getString("lastEdit"))
+        assertEquals("uuid1", json.getJSONArray("fileRefs").getString(0))
+        assertEquals("hi", json.getJSONArray("messages").getJSONObject(0).getString("text"))
+    }
+
+    @Test
+    fun `setPinned returns false when stored JSON is malformed`() = runTest {
+        whenever(chatsDao.getById("abc")).thenReturn(DuckAiBridgeChatEntity("abc", "not a json"))
+
+        assertFalse(store.setPinned("abc", true))
+        verify(chatsDao, never()).upsert(any())
+    }
 }