feat: word-based message filtering with quarantine approach (stored but hidden)

.github/workflows/reusable-android-build.yml

@@ -86,6 +86,8 @@ jobs:
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           report_type: test_results
+          directory: .
+          files: "**/build/test-results/**/TEST-*.xml"
 
       - name: Upload F-Droid debug artifact
         if: ${{ inputs.upload_artifacts }}

.github/workflows/reusable-android-test.yml

@@ -101,6 +101,8 @@ jobs:
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           report_type: test_results
+          directory: .
+          files: "**/build/outputs/androidTest-results/**/TEST-*.xml"
 
       - name: Upload Test Results
         if: ${{ always() && inputs.upload_artifacts }}

.gitignore

@@ -45,3 +45,6 @@ keystore.properties
 # Personal build scripts
 build-and-install-android.sh
 wireless-install.sh
+
+# Git worktrees
+.worktrees/

app/build.gradle.kts

@@ -244,7 +244,9 @@ dependencies {
     fdroidImplementation(libs.osmdroid.geopackage) { exclude(group = "com.j256.ormlite") }
 
     androidTestImplementation(libs.androidx.test.runner)
+    androidTestImplementation(libs.androidx.test.ext.junit)
     androidTestImplementation(libs.hilt.android.testing)
+    androidTestImplementation(libs.kotlinx.coroutines.test)
 
     testImplementation(libs.junit)
     testImplementation(libs.kotlinx.coroutines.test)

app/src/androidTest/java/com/geeksville/mesh/filter/MessageFilterIntegrationTest.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.geeksville.mesh.filter
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.meshtastic.core.prefs.filter.FilterPrefs
+import org.meshtastic.core.service.filter.MessageFilterService
+import javax.inject.Inject
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class MessageFilterIntegrationTest {
+
+    @get:Rule var hiltRule = HiltAndroidRule(this)
+
+    @Inject lateinit var filterPrefs: FilterPrefs
+
+    @Inject lateinit var filterService: MessageFilterService
+
+    @Before
+    fun setup() {
+        hiltRule.inject()
+    }
+
+    @Test
+    fun filterPrefsIntegration() = runTest {
+        filterPrefs.filterEnabled = true
+        filterPrefs.filterWords = setOf("test", "spam")
+        filterService.rebuildPatterns()
+
+        assertTrue(filterService.shouldFilter("this is a test message"))
+        assertTrue(filterService.shouldFilter("spam content"))
+    }
+}

app/src/main/java/com/geeksville/mesh/navigation/SettingsNavigation.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,7 +14,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 @file:Suppress("Wrapping", "SpacingAroundColon")
 
 package com.geeksville.mesh.navigation
@@ -35,6 +34,7 @@ import org.meshtastic.core.navigation.SettingsRoutes
 import org.meshtastic.feature.settings.AboutScreen
 import org.meshtastic.feature.settings.SettingsScreen
 import org.meshtastic.feature.settings.debugging.DebugScreen
+import org.meshtastic.feature.settings.filter.FilterSettingsScreen
 import org.meshtastic.feature.settings.navigation.ConfigRoute
 import org.meshtastic.feature.settings.navigation.ModuleRoute
 import org.meshtastic.feature.settings.radio.CleanNodeDatabaseScreen
@@ -175,6 +175,8 @@ fun NavGraphBuilder.settingsGraph(navController: NavHostController) {
         }
 
         composable<SettingsRoutes.About> { AboutScreen(onNavigateUp = navController::navigateUp) }
+
+        composable<SettingsRoutes.FilterSettings> { FilterSettingsScreen(onBack = navController::navigateUp) }
     }
 }
 

app/src/main/java/com/geeksville/mesh/service/MeshDataHandler.kt

@@ -41,6 +41,7 @@ import org.meshtastic.core.prefs.mesh.MeshPrefs
 import org.meshtastic.core.service.MeshServiceNotifications
 import org.meshtastic.core.service.RetryEvent
 import org.meshtastic.core.service.ServiceRepository
+import org.meshtastic.core.service.filter.MessageFilterService
 import org.meshtastic.core.strings.Res
 import org.meshtastic.core.strings.critical_alert
 import org.meshtastic.core.strings.error_duty_cycle
@@ -81,6 +82,7 @@ constructor(
     private val tracerouteHandler: MeshTracerouteHandler,
     private val neighborInfoHandler: MeshNeighborInfoHandler,
     private val radioConfigRepository: RadioConfigRepository,
+    private val messageFilterService: MessageFilterService,
 ) {
     private var scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
@@ -631,20 +633,6 @@ constructor(
         // contactKey: unique contact key filter (channel)+(nodeId)
         val contactKey = "${dataPacket.channel}$contactId"
 
-        val packetToSave =
-            Packet(
-                uuid = 0L,
-                myNodeNum = myNodeNum,
-                packetId = dataPacket.id,
-                port_num = dataPacket.dataType,
-                contact_key = contactKey,
-                received_time = System.currentTimeMillis(),
-                read = fromLocal,
-                data = dataPacket,
-                snr = dataPacket.snr,
-                rssi = dataPacket.rssi,
-                hopsAway = dataPacket.hopsAway,
-            )
         scope.handledLaunch {
             packetRepository.get().apply {
                 // Check for duplicates before inserting
@@ -658,23 +646,59 @@ constructor(
                     return@handledLaunch
                 }
 
-                insert(packetToSave)
-                val conversationMuted = getContactSettings(contactKey).isMuted
-                val nodeMuted = nodeManager.nodeDBbyID[dataPacket.from]?.isMuted == true
-                val isSilent = conversationMuted || nodeMuted
-                if (packetToSave.port_num == Portnums.PortNum.ALERT_APP_VALUE && !isSilent) {
-                    serviceNotifications.showAlertNotification(
-                        contactKey,
-                        getSenderName(dataPacket),
-                        dataPacket.alert ?: getString(Res.string.critical_alert),
+                // Check if message should be filtered
+                val isFiltered = shouldFilterMessage(dataPacket, contactKey)
+
+                val packetToSave =
+                    Packet(
+                        uuid = 0L,
+                        myNodeNum = myNodeNum,
+                        packetId = dataPacket.id,
+                        port_num = dataPacket.dataType,
+                        contact_key = contactKey,
+                        received_time = System.currentTimeMillis(),
+                        read = fromLocal || isFiltered,
+                        data = dataPacket,
+                        snr = dataPacket.snr,
+                        rssi = dataPacket.rssi,
+                        hopsAway = dataPacket.hopsAway,
+                        filtered = isFiltered,
                     )
-                } else if (updateNotification) {
-                    scope.handledLaunch { updateNotification(contactKey, dataPacket, isSilent) }
+
+                insert(packetToSave)
+                if (!isFiltered) {
+                    handlePacketNotification(packetToSave, dataPacket, contactKey, updateNotification)
                 }
             }
         }
     }
 
+    private suspend fun PacketRepository.shouldFilterMessage(dataPacket: DataPacket, contactKey: String): Boolean {
+        if (dataPacket.dataType != Portnums.PortNum.TEXT_MESSAGE_APP_VALUE) return false
+        val isFilteringDisabled = getContactSettings(contactKey).filteringDisabled
+        return messageFilterService.shouldFilter(dataPacket.text.orEmpty(), isFilteringDisabled)
+    }
+
+    private suspend fun handlePacketNotification(
+        packet: Packet,
+        dataPacket: DataPacket,
+        contactKey: String,
+        updateNotification: Boolean,
+    ) {
+        val conversationMuted = packetRepository.get().getContactSettings(contactKey).isMuted
+        val nodeMuted = nodeManager.nodeDBbyID[dataPacket.from]?.isMuted == true
+        val isSilent = conversationMuted || nodeMuted
+        if (packet.port_num == Portnums.PortNum.ALERT_APP_VALUE && !isSilent) {
+            serviceNotifications.showAlertNotification(
+                contactKey,
+                getSenderName(dataPacket),
+                dataPacket.alert ?: getString(Res.string.critical_alert),
+            )
+        } else if (updateNotification) {
+            scope.handledLaunch { updateNotification(contactKey, dataPacket, isSilent) }
+        }
+    }
+
     private fun getSenderName(packet: DataPacket): String {
         if (packet.from == DataPacket.ID_LOCAL) {
             val myId = nodeManager.getMyId()
@@ -758,6 +782,9 @@ constructor(
 
         // Find the original packet to get the contactKey
         packetRepository.get().getPacketByPacketId(packet.decoded.replyId)?.let { original ->
+            // Skip notification if the original message was filtered
+            if (original.packet.filtered) return@let
+
             val contactKey = original.packet.contact_key
             val conversationMuted = packetRepository.get().getContactSettings(contactKey).isMuted
             val nodeMuted = nodeManager.nodeDBbyID[fromId]?.isMuted == true

app/src/main/java/com/geeksville/mesh/ui/contact/ContactsViewModel.kt

@@ -187,6 +187,10 @@ constructor(
 
     fun getContactSettings() = packetRepository.getContactSettings()
 
+    fun setContactFilteringDisabled(contactKey: String, disabled: Boolean) {
+        viewModelScope.launch(Dispatchers.IO) { packetRepository.setContactFilteringDisabled(contactKey, disabled) }
+    }
+
     /**
      * Get the total message count for a list of contact keys. This queries the repository directly, so it works even if
      * contacts aren't loaded in the paged list.

app/src/test/java/com/geeksville/mesh/service/Fakes.kt

@@ -56,10 +56,10 @@ class FakeNodeInfoWriteDataSource : NodeInfoWriteDataSource {
 
     override suspend fun installConfig(mi: MyNodeEntity, nodes: List<NodeEntity>) {}
 
-    override suspend fun clearNodeDB(preserveFavorites: Boolean) {}
-
     override suspend fun clearMyNodeInfo() {}
 
+    override suspend fun clearNodeDB(preserveFavorites: Boolean) {}
+
     override suspend fun deleteNode(num: Int) {}
 
     override suspend fun deleteNodes(nodeNums: List<Int>) {}

core/data/src/main/kotlin/org/meshtastic/core/data/repository/PacketRepository.kt

@@ -286,6 +286,43 @@ constructor(
     suspend fun findReactionsWithId(packetId: Int) =
         withContext(dispatchers.io) { dbManager.currentDb.value.packetDao().findReactionsWithId(packetId) }
 
+    fun getFilteredCountFlow(contactKey: String): Flow<Int> =
+        dbManager.currentDb.flatMapLatest { db -> db.packetDao().getFilteredCountFlow(contactKey) }
+
+    suspend fun getFilteredCount(contactKey: String): Int =
+        withContext(dispatchers.io) { dbManager.currentDb.value.packetDao().getFilteredCount(contactKey) }
+
+    fun getMessagesFromPaged(
+        contactKey: String,
+        includeFiltered: Boolean,
+        getNode: suspend (String?) -> Node,
+    ): Flow<PagingData<Message>> = Pager(
+        config =
+        PagingConfig(
+            pageSize = MESSAGES_PAGE_SIZE,
+            enablePlaceholders = false,
+            initialLoadSize = MESSAGES_PAGE_SIZE,
+        ),
+        pagingSourceFactory = {
+            dbManager.currentDb.value.packetDao().getMessagesFromPaged(contactKey, includeFiltered)
+        },
+    )
+        .flow
+        .map { pagingData ->
+            pagingData.map { packet ->
+                val message = packet.toMessage(getNode)
+                message.replyId
+                    .takeIf { it != null && it != 0 }
+                    ?.let { getPacketByPacketId(it) }
+                    ?.toMessage(getNode)
+                    ?.let { originalMessage -> message.copy(originalMessage = originalMessage) } ?: message
+            }
+        }
+
+    suspend fun setContactFilteringDisabled(contactKey: String, disabled: Boolean) = withContext(dispatchers.io) {
+        dbManager.currentDb.value.packetDao().setContactFilteringDisabled(contactKey, disabled)
+    }
+
     suspend fun clearPacketDB() = withContext(dispatchers.io) { dbManager.currentDb.value.packetDao().deleteAll() }
 
     suspend fun migrateChannelsByPSK(oldSettings: List<ChannelSettings>, newSettings: List<ChannelSettings>) =