Merge pull request #1122 from torlando-tech/fix/saved-peer-notifications

fix(android): treat saved contacts as saved peers for notifications

Author: torlando-tech

app/src/main/java/network/columba/app/service/MessageCollector.kt

@@ -143,13 +143,7 @@ class MessageCollector
                                 }
                             }
 
-                            val isFavorite =
-                                try {
-                                    announceRepository.getAnnounce(sourceHash)?.isFavorite ?: false
-                                } catch (e: Exception) {
-                                    Log.w(TAG, "Could not check if peer is favorite", e)
-                                    false
-                                }
+                            val isFavorite = isSavedPeer(sourceHash)
 
                             // Only notify if the message hasn't been read yet
                             // This prevents duplicate notifications after service restart
@@ -274,13 +268,7 @@ class MessageCollector
                             Log.d(TAG, "Message saved to database for peer ${sourceHash.take(16)} (hasPublicKey=${publicKey != null})")
 
                             // Check if sender is a saved peer (favorite)
-                            val isFavorite =
-                                try {
-                                    announceRepository.getAnnounce(sourceHash)?.isFavorite ?: false
-                                } catch (e: Exception) {
-                                    Log.w(TAG, "Could not check if peer is favorite", e)
-                                    false
-                                }
+                            val isFavorite = isSavedPeer(sourceHash)
 
                             // Show notification for received message
                             try {
@@ -458,6 +446,39 @@ class MessageCollector
             return PeerNameResolver.formatHashAsFallback(peerHash)
         }
 
+        /**
+         * Determine whether [sourceHash] is a "saved peer" for notification purposes.
+         *
+         * A peer is considered saved if it is either:
+         *  - flagged as a favorite on its announce row (legacy "Save Peer" via the
+         *    announce stream star), OR
+         *  - present in the active identity's contacts table (written by the
+         *    "Save to Contacts" flows in Chats/Messaging, QR import, manual entry,
+         *    and propagation-node relay setup, which do not touch the announce flag).
+         *
+         * Both signals must be checked: the contacts table is the source of truth for
+         * "saved" as the user experiences it, and the legacy flag is kept so peers saved
+         * before the contacts table existed continue to notify. Either signal being true
+         * is sufficient.
+         */
+        private suspend fun isSavedPeer(sourceHash: String): Boolean {
+            val favoriteFlag =
+                try {
+                    announceRepository.getAnnounce(sourceHash)?.isFavorite ?: false
+                } catch (e: Exception) {
+                    Log.w(TAG, "Could not check if peer is favorite", e)
+                    false
+                }
+            if (favoriteFlag) return true
+
+            return try {
+                contactRepository.hasContact(sourceHash)
+            } catch (e: Exception) {
+                Log.w(TAG, "Could not check if peer is a saved contact", e)
+                false
+            }
+        }
+
         /**
          * Get peer name with fallback - uses PeerNameResolver for consistent lookup across the app
          */

app/src/test/java/network/columba/app/service/MessageCollectorTest.kt

@@ -370,6 +370,51 @@ class MessageCollectorTest {
             }
         }
 
+    @Test
+    fun `processMessage treats saved contact without favorite announce as favorite`() =
+        runBlocking {
+            // Given: A message from a peer saved via "Save to Contacts" (Chats/Messaging
+            // screens). Those flows write to the contacts table and never touch the
+            // legacy announce isFavorite flag, so the announce row reports
+            // isFavorite = false even though the peer IS a saved contact.
+            val testMessage =
+                ReceivedMessage(
+                    messageHash = "contact_msg",
+                    content = "Message from saved contact",
+                    sourceHash = testSourceHash,
+                    destinationHash = testDestHash,
+                    timestamp = System.currentTimeMillis(),
+                    fieldsJson = null,
+                    publicKey = null,
+                )
+
+            // Announce row exists but is NOT favorited (Save to Contacts never sets it)
+            coEvery { announceRepository.getAnnounce(testSourceHashHex) } returns
+                mockk {
+                    every { isFavorite } returns false
+                }
+            // But the peer IS in the contacts table
+            coEvery { contactRepository.hasContact(testSourceHashHex) } returns true
+
+            // When: Start collecting and emit
+            val startResult = runCatching { messageCollector.startCollecting() }
+            assertTrue("startCollecting should complete without throwing", startResult.isSuccess)
+            kotlinx.coroutines.delay(50)
+            messageFlow.emit(testMessage)
+            kotlinx.coroutines.delay(200)
+
+            // Then: Notification should be posted with isFavorite = true, so that
+            // "Message from Saved Peer" (with "Received Message" off) still fires.
+            coVerify(timeout = 2000) {
+                notificationHelper.notifyMessageReceived(
+                    destinationHash = testSourceHashHex,
+                    peerName = any(),
+                    messagePreview = any(),
+                    isFavorite = true,
+                )
+            }
+        }
+
     @Test
     fun `processMessage handles announce lookup failure gracefully for notifications`() =
         runBlocking {