feat(auto): Android Auto communications app with local stats

app/build.gradle.kts

@@ -235,6 +235,7 @@ dependencies {
     implementation(projects.feature.settings)
     implementation(projects.feature.firmware)
     implementation(projects.feature.wifiProvision)
+    implementation(projects.feature.auto)
     implementation(projects.feature.widget)
 
     implementation(libs.jetbrains.compose.material3.adaptive)

app/proguard-rules.pro

@@ -34,6 +34,14 @@
 # for auditing. Inspect this file after a release build to see what libraries inject.
 -printconfiguration build/outputs/mapping/r8-merged-config.txt
 
+# ---- Android Auto / Car App Library -----------------------------------------
+
+# MeshtasticCarAppService and MeshtasticCarSession are instantiated by class name
+# by the Android Auto host. Keep both classes (and their no-arg constructors) so
+# release builds aren't broken by R8 tree-shaking.
+-keep class org.meshtastic.feature.auto.MeshtasticCarAppService { <init>(); }
+-keep class org.meshtastic.feature.auto.MeshtasticCarSession { <init>(); }
+
 # ---- Networking (transitive references from Ktor on Android) ----------------
 
 -dontwarn org.conscrypt.**

app/src/test/kotlin/org/meshtastic/app/service/Fakes.kt

@@ -74,6 +74,10 @@ class FakeMeshServiceNotifications : MeshServiceNotifications {
 
     override fun cancelMessageNotification(contactKey: String) {}
 
+    override suspend fun markConversationRead(contactKey: String) {}
+
+    override suspend fun appendOutgoingMessage(contactKey: String, text: String) {}
+
     override fun cancelLowBatteryNotification(node: Node) {}
 
     override fun clearClientNotification(notification: ClientNotification) {}

core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/MeshDataHandlerImpl.kt

@@ -357,7 +357,7 @@ class MeshDataHandlerImpl(
                     read = fromLocal || isFiltered,
                     filtered = isFiltered,
                 )
-                if (!isFiltered) {
+                if (!isFiltered && !fromLocal) {
                     handlePacketNotification(dataPacket, contactKey, updateNotification)
                 }
             }

core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/MeshServiceNotifications.kt

@@ -67,6 +67,20 @@ interface MeshServiceNotifications {
 
     fun cancelMessageNotification(contactKey: String)
 
+    /**
+     * Marks the conversation for [contactKey] as read: clears its unread count in the packet repository and cancels the
+     * posted message notification (and the group summary). Intended for use by notification action receivers (reply,
+     * mark-as-read, reaction) to keep behavior consistent.
+     */
+    suspend fun markConversationRead(contactKey: String)
+
+    /**
+     * Appends an outgoing [text] message attributed to the local user to the currently posted conversation notification
+     * for [contactKey]. Used so that assistants such as Android Auto can briefly observe the reply in the
+     * MessagingStyle history before the notification is cancelled. No-op when there is nothing to update.
+     */
+    suspend fun appendOutgoingMessage(contactKey: String, text: String)
+
     fun cancelLowBatteryNotification(node: Node)
 
     fun clearClientNotification(notification: ClientNotification)

core/service/src/androidHostTest/kotlin/org/meshtastic/core/service/MarkAsReadReceiverTest.kt

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 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 org.meshtastic.core.service
+
+import android.content.Context
+import android.content.Intent
+import androidx.test.core.app.ApplicationProvider
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.koin.core.context.startKoin
+import org.koin.core.context.stopKoin
+import org.koin.dsl.module
+import org.meshtastic.core.di.CoroutineDispatchers
+import org.meshtastic.core.repository.MeshServiceNotifications
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import kotlin.test.assertEquals
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class MarkAsReadReceiverTest {
+
+    private lateinit var context: Context
+    private lateinit var notifications: RecordingNotifications
+
+    @Before
+    fun setUp() {
+        context = ApplicationProvider.getApplicationContext()
+        notifications = RecordingNotifications(mutableListOf())
+        val dispatcher = UnconfinedTestDispatcher()
+        startKoin {
+            modules(
+                module {
+                    single<MeshServiceNotifications> { notifications }
+                    single { CoroutineDispatchers(io = dispatcher, main = dispatcher, default = dispatcher) }
+                },
+            )
+        }
+    }
+
+    @After
+    fun tearDown() {
+        stopKoin()
+    }
+
+    @Test
+    fun `markAsRead action invokes markConversationRead`() {
+        val contactKey = "0!deadbeef"
+        val intent =
+            Intent(context, MarkAsReadReceiver::class.java).apply {
+                action = MarkAsReadReceiver.MARK_AS_READ_ACTION
+                putExtra(MarkAsReadReceiver.CONTACT_KEY, contactKey)
+            }
+
+        MarkAsReadReceiver().onReceive(context, intent)
+
+        assertEquals(listOf(contactKey), notifications.markReadCalls)
+    }
+
+    @Test
+    fun `missing contactKey does not invoke markConversationRead`() {
+        val intent =
+            Intent(context, MarkAsReadReceiver::class.java).apply { action = MarkAsReadReceiver.MARK_AS_READ_ACTION }
+
+        MarkAsReadReceiver().onReceive(context, intent)
+
+        assertEquals(emptyList(), notifications.markReadCalls)
+    }
+
+    @Test
+    fun `wrong action is ignored`() {
+        val intent =
+            Intent(context, MarkAsReadReceiver::class.java).apply {
+                action = "some.other.ACTION"
+                putExtra(MarkAsReadReceiver.CONTACT_KEY, "0!abcd")
+            }
+
+        MarkAsReadReceiver().onReceive(context, intent)
+
+        assertEquals(emptyList(), notifications.markReadCalls)
+    }
+}

core/service/src/androidHostTest/kotlin/org/meshtastic/core/service/MeshServiceNotificationsImplTest.kt

@@ -59,6 +59,7 @@ class MeshServiceNotificationsImplTest {
                 context = context,
                 packetRepository = lazy<PacketRepository> { error("Not used in this test") },
                 nodeRepository = lazy<NodeRepository> { error("Not used in this test") },
+                shortcutManager = lazy<ConversationShortcutManager> { error("Not used in this test") },
             )
 
         notifications.initChannels()

core/service/src/androidHostTest/kotlin/org/meshtastic/core/service/ReactionReceiverTest.kt

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 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 org.meshtastic.core.service
+
+import android.content.Context
+import android.content.Intent
+import androidx.test.core.app.ApplicationProvider
+import dev.mokkery.MockMode
+import dev.mokkery.answering.calls
+import dev.mokkery.answering.returns
+import dev.mokkery.everySuspend
+import dev.mokkery.matcher.any
+import dev.mokkery.mock
+import dev.mokkery.verify.VerifyMode
+import dev.mokkery.verifySuspend
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.koin.core.context.startKoin
+import org.koin.core.context.stopKoin
+import org.koin.dsl.module
+import org.meshtastic.core.di.CoroutineDispatchers
+import org.meshtastic.core.model.service.ServiceAction
+import org.meshtastic.core.repository.MeshServiceNotifications
+import org.meshtastic.core.repository.ServiceRepository
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import kotlin.test.assertEquals
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class ReactionReceiverTest {
+
+    private lateinit var context: Context
+    private lateinit var notifications: RecordingNotifications
+    private lateinit var serviceRepository: ServiceRepository
+
+    @Before
+    fun setUp() {
+        context = ApplicationProvider.getApplicationContext()
+        notifications = RecordingNotifications(mutableListOf())
+        serviceRepository = mock(MockMode.autofill)
+        val dispatcher = UnconfinedTestDispatcher()
+        startKoin {
+            modules(
+                module {
+                    single<ServiceRepository> { serviceRepository }
+                    single<MeshServiceNotifications> { notifications }
+                    single { CoroutineDispatchers(io = dispatcher, main = dispatcher, default = dispatcher) }
+                },
+            )
+        }
+    }
+
+    @After
+    fun tearDown() {
+        stopKoin()
+    }
+
+    @Test
+    fun `reaction dispatches ServiceAction and marks conversation read`() {
+        val contactKey = "0!cafebabe"
+        val emoji = "👍"
+        val replyId = 42
+        everySuspend { serviceRepository.onServiceAction(any()) } returns Unit
+
+        val intent =
+            Intent(context, ReactionReceiver::class.java).apply {
+                action = ReactionReceiver.REACT_ACTION
+                putExtra(ReactionReceiver.EXTRA_CONTACT_KEY, contactKey)
+                putExtra(ReactionReceiver.EXTRA_EMOJI, emoji)
+                putExtra(ReactionReceiver.EXTRA_REPLY_ID, replyId)
+            }
+
+        ReactionReceiver().onReceive(context, intent)
+
+        verifySuspend(VerifyMode.exactly(1)) {
+            serviceRepository.onServiceAction(ServiceAction.Reaction(emoji, replyId, contactKey))
+        }
+        assertEquals(listOf(contactKey), notifications.markReadCalls)
+    }
+
+    @Test
+    fun `reaction does not markRead when ServiceAction dispatch throws`() {
+        val contactKey = "0!feedface"
+        val throwingRepo = mock<ServiceRepository>(MockMode.autofill)
+        everySuspend { throwingRepo.onServiceAction(any()) } calls { throw IllegalStateException("boom") }
+        stopKoin()
+        val dispatcher = UnconfinedTestDispatcher()
+        startKoin {
+            modules(
+                module {
+                    single<ServiceRepository> { throwingRepo }
+                    single<MeshServiceNotifications> { notifications }
+                    single { CoroutineDispatchers(io = dispatcher, main = dispatcher, default = dispatcher) }
+                },
+            )
+        }
+
+        val intent =
+            Intent(context, ReactionReceiver::class.java).apply {
+                action = ReactionReceiver.REACT_ACTION
+                putExtra(ReactionReceiver.EXTRA_CONTACT_KEY, contactKey)
+                putExtra(ReactionReceiver.EXTRA_REACTION, "🎉")
+                putExtra(ReactionReceiver.EXTRA_PACKET_ID, 7)
+            }
+
+        ReactionReceiver().onReceive(context, intent)
+
+        assertEquals(emptyList(), notifications.markReadCalls)
+    }
+
+    @Test
+    fun `reaction without contactKey is dropped`() {
+        val intent =
+            Intent(context, ReactionReceiver::class.java).apply {
+                action = ReactionReceiver.REACT_ACTION
+                putExtra(ReactionReceiver.EXTRA_EMOJI, "👍")
+            }
+
+        ReactionReceiver().onReceive(context, intent)
+
+        assertEquals(emptyList(), notifications.markReadCalls)
+    }
+
+    @Test
+    fun `wrong action is ignored`() {
+        val intent =
+            Intent(context, ReactionReceiver::class.java).apply {
+                action = "other.ACTION"
+                putExtra(ReactionReceiver.EXTRA_CONTACT_KEY, "0!abcd")
+                putExtra(ReactionReceiver.EXTRA_EMOJI, "👍")
+            }
+
+        ReactionReceiver().onReceive(context, intent)
+
+        assertEquals(emptyList(), notifications.markReadCalls)
+    }
+}