feat(notifications): align message notifications with Android best practices

Message notifications rebuilt the full recent conversation from the database on
every arrival and presented already-read messages as new content, shared a
single integer ID space across all notification types, and never linked to the
conversation shortcuts that feature/car was publishing.

- Read "context" messages now use MessagingStyle.addHistoricMessage() instead of
  addMessage(), so they provide context to Auto/Wear/accessibility without being
  re-presented as freshly-arrived. Unread messages and reactions remain the
  alerting content; a guard keeps the latest message alerting when all are read.
- Every notification type posts via notify(tag, id)/cancel(tag, id), closing
  cross-type ID collisions (e.g. a node whose num == 101 clobbering the
  foreground-service notification, or num == 1 the group summary). The summary is
  now excluded from the active-conversation count by FLAG_GROUP_SUMMARY.
- Conversation-shortcut publishing moves from feature/car (Auto-session only)
  into core/service ConversationShortcutPublisher, owned by the MeshService
  lifecycle so shortcuts exist on phones too. Conversation notifications now set
  setShortcutId/setLocusId for Conversations-section treatment (Android 11+).
- Avatars are cached per node instead of re-rasterizing a bitmap per message;
  PersonIconFactory is shared in core/service (dedupes the car copy).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: jamesarich

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

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

…r/service/ConversationShortcutManager.kt …service/ConversationShortcutPublisher.ktfeature/car/src/main/kotlin/org/meshtastic/feature/car/service/ConversationShortcutManager.kt renamed to core/service/src/androidMain/kotlin/org/meshtastic/core/service/ConversationShortcutPublisher.kt feature/car/src/main/kotlin/org/meshtastic/feature/car/service/ConversationShortcutManager.kt renamed to core/service/src/androidMain/kotlin/org/meshtastic/core/service/ConversationShortcutPublisher.kt

@@ -14,7 +14,7 @@
  * 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.feature.car.service
+package org.meshtastic.core.service
 
 import android.content.Context
 import android.content.Intent
@@ -34,17 +34,26 @@ import kotlinx.coroutines.launch
 import org.koin.core.annotation.Single
 import org.meshtastic.core.model.NodeAddress
 import org.meshtastic.core.model.nodeColorsFromNum
+import org.meshtastic.core.navigation.DEEP_LINK_BASE_URI
 import org.meshtastic.core.repository.NodeRepository
 import org.meshtastic.core.repository.PacketRepository
 import org.meshtastic.core.repository.RadioConfigRepository
-import org.meshtastic.feature.car.util.PersonIconFactory
 
 /**
- * Publishes dynamic shortcuts for active DM conversations and channels so that Android Auto can surface Meshtastic
- * conversations as messaging destinations and link notifications to template conversations via [LocusIdCompat].
+ * Single owner of the dynamic conversation shortcuts that link Meshtastic conversations to their notifications.
+ *
+ * Publishing lives here in `core:service` (rather than in a feature module) so that shortcuts exist whenever the mesh
+ * service is running — not only during an Android Auto session. This is what lets [MeshNotificationManagerImpl] attach
+ * `setShortcutId`/`setLocusId` to message notifications so Android ranks them in the shade's Conversations section and
+ * surfaces them to Android Auto/Wear.
+ *
+ * Two publishing paths, both keyed by `contactKey`:
+ * - [startObserving] keeps a full set of DM + channel shortcuts in sync with the database for the service lifetime.
+ * - [ensureConversationShortcut] publishes a single shortcut on demand when a notification is about to reference one
+ *   that the observer has not emitted yet (e.g. the very first message of a brand-new conversation).
  */
 @Single
-class ConversationShortcutManager(
+class ConversationShortcutPublisher(
     private val context: Context,
     private val nodeRepository: NodeRepository,
     private val packetRepository: PacketRepository,
@@ -136,7 +145,7 @@ class ConversationShortcutManager(
     }
 
     private fun buildChannelShortcut(index: Int, name: String): ShortcutInfoCompat {
-        val contactKey = "${index}${NodeAddress.ID_BROADCAST}"
+        val contactKey = "$index${NodeAddress.ID_BROADCAST}"
         val channelName = name.ifEmpty { "Primary Channel" }
         val person = Person.Builder().setName(channelName).setKey("channel-$index").build()
         return ShortcutInfoCompat.Builder(context, contactKey)
@@ -151,13 +160,15 @@ class ConversationShortcutManager(
     }
 
     private fun conversationIntent(contactKey: String): Intent =
-        Intent(Intent.ACTION_VIEW, "meshtastic://messages/$contactKey".toUri()).apply {
+        Intent(Intent.ACTION_VIEW, "$DEEP_LINK_BASE_URI/messages/$contactKey".toUri()).apply {
             setPackage(context.packageName)
         }
 
     /**
-     * Ensures a long-lived conversation shortcut exists for [contactKey]. Called on demand when a notification is about
-     * to reference a shortcut ID that may not have been pre-published.
+     * Ensures a long-lived conversation shortcut exists for [contactKey] before a notification references it. A no-op
+     * when [startObserving] has already published the shortcut; otherwise publishes a minimal one so the notification's
+     * `setShortcutId`/`setLocusId` resolve immediately (the observer replaces it with a richer version on its next
+     * emission).
      */
     fun ensureConversationShortcut(contactKey: String, displayName: String) {
         val alreadyPublished = ShortcutManagerCompat.getDynamicShortcuts(context).any { it.id == contactKey }

core/service/src/androidMain/kotlin/org/meshtastic/core/service/MeshNotificationManagerImpl.kt

@@ -24,16 +24,14 @@ import android.app.TaskStackBuilder
 import android.content.ContentResolver.SCHEME_ANDROID_RESOURCE
 import android.content.Context
 import android.content.Intent
-import android.graphics.Canvas
 import android.graphics.Color
-import android.graphics.Paint
 import android.media.AudioAttributes
 import android.media.RingtoneManager
 import androidx.core.app.NotificationCompat
 import androidx.core.app.Person
 import androidx.core.app.RemoteInput
+import androidx.core.content.LocusIdCompat
 import androidx.core.content.getSystemService
-import androidx.core.graphics.createBitmap
 import androidx.core.graphics.drawable.IconCompat
 import androidx.core.net.toUri
 import kotlinx.coroutines.flow.first
@@ -96,6 +94,7 @@ import org.meshtastic.proto.ClientNotification
 import org.meshtastic.proto.DeviceMetrics
 import org.meshtastic.proto.LocalStats
 import org.meshtastic.proto.Telemetry
+import java.util.concurrent.ConcurrentHashMap
 import kotlin.time.Duration.Companion.minutes
 
 /**
@@ -110,6 +109,7 @@ class MeshNotificationManagerImpl(
     private val context: Context,
     private val packetRepository: Lazy<PacketRepository>,
     private val nodeRepository: Lazy<NodeRepository>,
+    private val conversationShortcutPublisher: Lazy<ConversationShortcutPublisher>,
 ) : MeshNotificationManager {
 
     private val notificationManager =
@@ -123,13 +123,35 @@ class MeshNotificationManagerImpl(
         private const val SNIPPET_LENGTH = 30
         private const val GROUP_KEY_MESSAGES = "org.meshtastic.app.GROUP_MESSAGES"
         private const val SUMMARY_ID = 1
-        private const val PERSON_ICON_SIZE = 128
-        private const val PERSON_ICON_TEXT_SIZE_RATIO = 0.5f
         private const val STATS_UPDATE_MINUTES = 15
         private val STATS_UPDATE_INTERVAL = STATS_UPDATE_MINUTES.minutes
         private const val BULLET = "• "
+
+        // Notification tags namespace the numeric IDs per notification type. Without them every type shares one
+        // integer ID space, so unrelated notifications can clobber each other (e.g. a node whose num == 101 would
+        // overwrite the foreground-service notification, or num == 1 the group summary). notify()/cancel() must use
+        // the same (tag, id) pair.
+        private const val TAG_MESSAGE = "message"
+        private const val TAG_MESSAGE_SUMMARY = "message_summary"
+        private const val TAG_WAYPOINT = "waypoint"
+        private const val TAG_ALERT = "alert"
+        private const val TAG_NEW_NODE = "new_node"
+        private const val TAG_LOW_BATTERY = "low_battery"
+        private const val TAG_CLIENT = "client"
     }
 
+    /**
+     * Caches generated avatar icons keyed by (person id + initial source + colors) so a conversation rebuild does not
+     * re-rasterize an avatar bitmap for every message on every update. Bounded by the number of distinct nodes seen;
+     * entries are cheap and colors/names rarely change.
+     */
+    private val personIconCache = ConcurrentHashMap<String, IconCompat>()
+
+    private fun cachedPersonIcon(key: String, initialSource: String, backgroundColor: Int, foregroundColor: Int) =
+        personIconCache.getOrPut("$key|$initialSource|$backgroundColor|$foregroundColor") {
+            PersonIconFactory.create(initialSource, backgroundColor, foregroundColor)
+        }
+
     /**
      * Sealed class to define the properties of each notification channel. This centralizes channel configuration and
      * makes it type-safe.
@@ -385,7 +407,7 @@ class MeshNotificationManagerImpl(
         channelName: String?,
         isSilent: Boolean,
     ) {
-        showConversationNotification(contactKey, isBroadcast, channelName, isSilent = isSilent)
+        showConversationNotification(contactKey, isBroadcast, channelName, conversationName = name, isSilent = isSilent)
     }
 
     override suspend fun updateReactionNotification(
@@ -396,7 +418,7 @@ class MeshNotificationManagerImpl(
         channelName: String?,
         isSilent: Boolean,
     ) {
-        showConversationNotification(contactKey, isBroadcast, channelName, isSilent = isSilent)
+        showConversationNotification(contactKey, isBroadcast, channelName, conversationName = name, isSilent = isSilent)
     }
 
     override suspend fun updateWaypointNotification(
@@ -407,15 +429,21 @@ class MeshNotificationManagerImpl(
         isSilent: Boolean,
     ) {
         val notification = createWaypointNotification(name, message, waypointId, isSilent)
-        notificationManager.notify(contactKey.hashCode(), notification)
+        notificationManager.notify(TAG_WAYPOINT, contactKey.hashCode(), notification)
     }
 
     private suspend fun showConversationNotification(
         contactKey: String,
         isBroadcast: Boolean,
         channelName: String?,
+        conversationName: String,
         isSilent: Boolean = false,
     ) {
+        // Publish (or refresh) a long-lived conversation shortcut before the notification references it, so Android can
+        // rank the notification in the shade's Conversations section and expose it to Android Auto/Wear. A channel name
+        // labels a broadcast conversation; a direct message is labelled by the other participant's name.
+        conversationShortcutPublisher.value.ensureConversationShortcut(contactKey, channelName ?: conversationName)
+
         val ourNode = nodeRepository.value.ourNodeInfo.value
         val history =
             packetRepository.value
@@ -446,20 +474,23 @@ class MeshNotificationManagerImpl(
                 history = displayHistory,
                 isSilent = isSilent,
             )
-        notificationManager.notify(contactKey.hashCode(), notification)
+        notificationManager.notify(TAG_MESSAGE, contactKey.hashCode(), notification)
         showGroupSummary()
     }
 
     private fun showGroupSummary() {
+        // Exclude the summary itself by its group-summary flag rather than by id, so a conversation whose
+        // contactKey.hashCode() happens to equal SUMMARY_ID is still counted as an active conversation.
         val activeNotifications =
             notificationManager.activeNotifications.filter {
-                it.id != SUMMARY_ID && it.notification.group == GROUP_KEY_MESSAGES
+                it.notification.group == GROUP_KEY_MESSAGES &&
+                    (it.notification.flags and Notification.FLAG_GROUP_SUMMARY) == 0
             }
 
         // No conversations left — drop the summary too, otherwise it lingers in Android Auto after the
         // last message notification is cancelled (e.g. on reply / mark-as-read).
         if (activeNotifications.isEmpty()) {
-            notificationManager.cancel(SUMMARY_ID)
+            notificationManager.cancel(TAG_MESSAGE_SUMMARY, SUMMARY_ID)
             return
         }
 
@@ -469,7 +500,9 @@ class MeshNotificationManagerImpl(
             Person.Builder()
                 .setName(meName)
                 .setKey(ourNode?.user?.id ?: NodeAddress.ID_LOCAL)
-                .apply { ourNode?.let { setIcon(createPersonIcon(meName, it.colors.second, it.colors.first)) } }
+                .apply {
+                    ourNode?.let { setIcon(cachedPersonIcon(it.user.id, meName, it.colors.second, it.colors.first)) }
+                }
                 .build()
 
         val messagingStyle =
@@ -499,41 +532,41 @@ class MeshNotificationManagerImpl(
                 .setAutoCancel(true)
                 .build()
 
-        notificationManager.notify(SUMMARY_ID, summaryNotification)
+        notificationManager.notify(TAG_MESSAGE_SUMMARY, SUMMARY_ID, summaryNotification)
     }
 
     override fun showAlertNotification(contactKey: String, name: String, alert: String) {
         val notification = createAlertNotification(contactKey, name, alert)
         // Use a consistent, unique ID for each alert source.
-        notificationManager.notify(name.hashCode(), notification)
+        notificationManager.notify(TAG_ALERT, name.hashCode(), notification)
     }
 
     override fun showNewNodeSeenNotification(node: Node) {
         val notification = createNewNodeSeenNotification(node.user.short_name, node.user.long_name, node.num)
-        notificationManager.notify(node.num, notification)
+        notificationManager.notify(TAG_NEW_NODE, node.num, notification)
     }
 
     override fun showOrUpdateLowBatteryNotification(node: Node, isRemote: Boolean) {
         val notification = createLowBatteryNotification(node, isRemote)
-        notificationManager.notify(node.num, notification)
+        notificationManager.notify(TAG_LOW_BATTERY, node.num, notification)
     }
 
     override fun showClientNotification(clientNotification: ClientNotification) {
         val notification =
             createClientNotification(getString(Res.string.client_notification), clientNotification.message)
-        notificationManager.notify(clientNotification.toString().hashCode(), notification)
+        notificationManager.notify(TAG_CLIENT, clientNotification.toString().hashCode(), notification)
     }
 
     override fun cancelMessageNotification(contactKey: String) {
-        notificationManager.cancel(contactKey.hashCode())
+        notificationManager.cancel(TAG_MESSAGE, contactKey.hashCode())
         // Rebuild (or clear) the group summary so it doesn't keep showing the dismissed conversation in Android Auto.
         showGroupSummary()
     }
 
-    override fun cancelLowBatteryNotification(node: Node) = notificationManager.cancel(node.num)
+    override fun cancelLowBatteryNotification(node: Node) = notificationManager.cancel(TAG_LOW_BATTERY, node.num)
 
     override fun clearClientNotification(notification: ClientNotification) =
-        notificationManager.cancel(notification.toString().hashCode())
+        notificationManager.cancel(TAG_CLIENT, notification.toString().hashCode())
 
     // endregion
 
@@ -585,29 +618,49 @@ class MeshNotificationManagerImpl(
             Person.Builder()
                 .setName(meName)
                 .setKey(ourNode?.user?.id ?: NodeAddress.ID_LOCAL)
-                .apply { ourNode?.let { setIcon(createPersonIcon(meName, it.colors.second, it.colors.first)) } }
+                .apply {
+                    ourNode?.let { setIcon(cachedPersonIcon(it.user.id, meName, it.colors.second, it.colors.first)) }
+                }
                 .build()
 
         val style =
             NotificationCompat.MessagingStyle(me)
                 .setGroupConversation(channelName != null)
                 .setConversationTitle(channelName)
 
-        history.forEach { msg ->
+        // Already-read messages are added as *historic* context rather than as new content: MessagingStyle keeps them
+        // available to accessibility services and Android Auto/Wear for conversation context without re-presenting them
+        // as freshly-arrived messages. Unread messages (and reactions, which are themselves new events) are the actual
+        // alerting content. When every message in the window is read (e.g. a reaction arrived on a read message) the
+        // most recent one is kept as a normal message so the notification still has alerting content to show.
+        val anyUnread = history.any { !it.read }
+        val lastIndex = history.lastIndex
+        history.forEachIndexed { index, msg ->
             // Use the node attached to the message directly to ensure correct identification
             val person =
                 Person.Builder()
                     .setName(msg.node.user.long_name)
                     .setKey(msg.node.user.id)
-                    .setIcon(createPersonIcon(msg.node.user.short_name, msg.node.colors.second, msg.node.colors.first))
+                    .setIcon(
+                        cachedPersonIcon(
+                            msg.node.user.id,
+                            msg.node.user.short_name,
+                            msg.node.colors.second,
+                            msg.node.colors.first,
+                        ),
+                    )
                     .build()
 
             val text =
                 msg.originalMessage?.let { original ->
                     "↩️ \"${original.node.user.short_name}: ${original.text.take(SNIPPET_LENGTH)}...\": ${msg.text}"
                 } ?: msg.text
 
-            style.addMessage(text, msg.receivedTime, person)
+            if (msg.read && (anyUnread || index != lastIndex)) {
+                style.addHistoricMessage(NotificationCompat.MessagingStyle.Message(text, msg.receivedTime, person))
+            } else {
+                style.addMessage(text, msg.receivedTime, person)
+            }
 
             // Add reactions as separate "messages" in history if they exist
             msg.emojis.forEach { reaction ->
@@ -617,7 +670,8 @@ class MeshNotificationManagerImpl(
                         .setName(reaction.user.long_name)
                         .setKey(reaction.user.id)
                         .setIcon(
-                            createPersonIcon(
+                            cachedPersonIcon(
+                                reaction.user.id,
                                 reaction.user.short_name,
                                 reactorNode.colors.second,
                                 reactorNode.colors.first,
@@ -635,6 +689,9 @@ class MeshNotificationManagerImpl(
 
         builder
             .setCategory(Notification.CATEGORY_MESSAGE)
+            // Link to the conversation shortcut so this is treated as a Conversation notification (Android 11+).
+            .setShortcutId(contactKey)
+            .setLocusId(LocusIdCompat(contactKey))
             .setAutoCancel(true)
             .setStyle(style)
             .setGroup(GROUP_KEY_MESSAGES)
@@ -873,33 +930,6 @@ class MeshNotificationManagerImpl(
             .setContentIntent(contentIntent ?: openAppIntent)
     }
 
-    private fun createPersonIcon(name: String, backgroundColor: Int, foregroundColor: Int): IconCompat {
-        val bitmap = createBitmap(PERSON_ICON_SIZE, PERSON_ICON_SIZE)
-        val canvas = Canvas(bitmap)
-        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
-
-        // Draw background circle
-        paint.color = backgroundColor
-        canvas.drawCircle(PERSON_ICON_SIZE / 2f, PERSON_ICON_SIZE / 2f, PERSON_ICON_SIZE / 2f, paint)
-
-        // Draw initials
-        paint.color = foregroundColor
-        paint.textSize = PERSON_ICON_SIZE * PERSON_ICON_TEXT_SIZE_RATIO
-        paint.textAlign = Paint.Align.CENTER
-        val initial =
-            if (name.isNotEmpty()) {
-                val codePoint = name.codePointAt(0)
-                String(Character.toChars(codePoint)).uppercase()
-            } else {
-                "?"
-            }
-        val xPos = canvas.width / 2f
-        val yPos = (canvas.height / 2f - (paint.descent() + paint.ascent()) / 2f)
-        canvas.drawText(initial, xPos, yPos, paint)
-
-        return IconCompat.createWithBitmap(bitmap)
-    }
-
     // endregion
 
     // region Extension Functions (Localized)