feat(notifications): surface tapback/reaction notifications (#2039)

Receiving a tapback/reaction previously produced no local notification:
both notification branches in textMessageAppPacket gated on
isEmoji == false, so a reaction was stored but only visible with the
conversation already open.

Now, when a reaction arrives and the sender/channel isn't muted, look up
the reacted-to message locally by messageId == replyID and schedule an
iMessage-style notification (e.g. `Alice reacted 👍 to "See you soon"`).
If the original message isn't known locally (a "phantom" tapback whose
replyID matches nothing), the reaction is still stored but no
notification is shown — mirroring Android's rememberReaction guard.

- Add MeshPackets.reactionNotificationBody(replyID:emoji:senderName:context:)
  (static + context-injected so it's unit-testable) which returns nil for
  phantom tapbacks and formats the localized body otherwise.
- Add makeMessageNotification(...) factory to collapse the DM/channel by
  regular/reaction Notification construction into one path.
- Add the reaction body format key to Localizable.xcstrings.

Out of scope (unchanged): unread-count/badge behavior. The isEmoji == false
filters in the *EntityExtension unread counts stay, so a reaction notifies
without bumping the conversation's unread badge (matching iMessage/Google
Messages).

Adds ReactionNotificationTests (7 tests) covering the phantom-tapback guard
(unknown/zero/negative replyID), the formatted body, emoji fallbacks, and
the nil-original-payload-still-notifies edge.

Author: bruschill

Localizable.xcstrings

@@ -1,6 +1,9 @@
 {
   "sourceLanguage" : "en",
   "strings" : {
+    "%1$@ reacted %2$@ to \"%3$@\"" : {
+      "comment" : "Tapback/reaction notification body. %1$@ is the sender name, %2$@ is the reaction emoji, %3$@ is the original message text that was reacted to."
+    },
     "%@ entered %@" : {
       "comment" : "Geofence notification body. First %@ is the node name, second %@ is the waypoint name."
     },

Meshtastic.xcodeproj/project.pbxproj

@@ -333,6 +333,7 @@
 		DD00003C000SNAP00000001 /* SnapshotTesting in Frameworks */ = {isa = PBXBuildFile; productRef = DD00003B000SNAP00000000 /* SnapshotTesting */; };
 		DD0000CHSETST0000000001 /* ChannelSetSaveTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DD0000CHSETST0000000000 /* ChannelSetSaveTests.swift */; };
 		DD0000MQTTFWDFLTTST00001 /* MqttForwardFilterTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DD0000MQTTFWDFLTTST00000 /* MqttForwardFilterTests.swift */; };
+		DD0000REACTNOTIFTST00001 /* ReactionNotificationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DD0000REACTNOTIFTST00000 /* ReactionNotificationTests.swift */; };
 		DD0000DEVLNKTST000000001 /* DeviceLinkTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DD0000DEVLNKTST000000000 /* DeviceLinkTests.swift */; };
 		DD1827FB0000000000000002 /* RegionCodesFirmwareLocaleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DD1827FA0000000000000002 /* RegionCodesFirmwareLocaleTests.swift */; };
 		DD007BAE2AA4E91200F5FA12 /* MyInfoEntityExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = DD007BAD2AA4E91200F5FA12 /* MyInfoEntityExtension.swift */; };
@@ -946,6 +947,7 @@
 		DD00003ASUPPORTLVL0000000 /* SupportLevel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SupportLevel.swift; sourceTree = "<group>"; };
 		DD0000CHSETST0000000000 /* ChannelSetSaveTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChannelSetSaveTests.swift; sourceTree = "<group>"; };
 		DD0000MQTTFWDFLTTST00000 /* MqttForwardFilterTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MqttForwardFilterTests.swift; sourceTree = "<group>"; };
+		DD0000REACTNOTIFTST00000 /* ReactionNotificationTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ReactionNotificationTests.swift; sourceTree = "<group>"; };
 		DD0000DEVLNKTST000000000 /* DeviceLinkTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DeviceLinkTests.swift; sourceTree = "<group>"; };
 		DD1827FA0000000000000002 /* RegionCodesFirmwareLocaleTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RegionCodesFirmwareLocaleTests.swift; sourceTree = "<group>"; };
 		DD007BAD2AA4E91200F5FA12 /* MyInfoEntityExtension.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MyInfoEntityExtension.swift; sourceTree = "<group>"; };
@@ -1696,6 +1698,7 @@
 				BEEF00102F00000100000003 /* MeshtasticChannelURLTests.swift */,
 				DD0000CHSETST0000000000 /* ChannelSetSaveTests.swift */,
 				DD0000MQTTFWDFLTTST00000 /* MqttForwardFilterTests.swift */,
+				DD0000REACTNOTIFTST00000 /* ReactionNotificationTests.swift */,
 				DD1827FA0000000000000002 /* RegionCodesFirmwareLocaleTests.swift */,
 				DD000031STATMSGDISP00000 /* StatusMessageDisplayTests.swift */,
 			);
@@ -2780,6 +2783,7 @@
 				DD0000DEVLNKTST000000001 /* DeviceLinkTests.swift in Sources */,
 				DD0000CHSETST0000000001 /* ChannelSetSaveTests.swift in Sources */,
 				DD0000MQTTFWDFLTTST00001 /* MqttForwardFilterTests.swift in Sources */,
+				DD0000REACTNOTIFTST00001 /* ReactionNotificationTests.swift in Sources */,
 				DD1827FB0000000000000002 /* RegionCodesFirmwareLocaleTests.swift in Sources */,
 				DD000031STATMSGDISP00001 /* StatusMessageDisplayTests.swift in Sources */,
 				AA009MCT0000002000000001 /* MarkdownConverterTests.swift in Sources */,

Meshtastic/Helpers/MeshPackets.swift

@@ -1121,6 +1121,55 @@ actor MeshPackets {
 		}
 	}
 
+	/// Builds the notification body for a received tapback/reaction, or returns `nil` when the
+	/// reacted-to message isn't known locally (a "phantom" tapback). The reaction is still stored
+	/// as it is today — we just don't surface a notification for something there's nothing to show
+	/// for, matching Android's guard (`MeshDataHandlerImpl.rememberReaction`).
+	///
+	/// Made `static` and context-injected (rather than reading `self.modelContext`) so the
+	/// phantom-tapback guard and body formatting can be exercised directly in unit tests.
+	static func reactionNotificationBody(replyID: Int64, emoji: String?, senderName: String, context: ModelContext) -> String? {
+		guard replyID > 0 else { return nil }
+		let descriptor = FetchDescriptor<MessageEntity>(predicate: #Predicate { $0.messageId == replyID })
+		guard let original = try? context.fetch(descriptor).first else { return nil }
+		let originalText = original.messagePayload ?? ""
+		let reactionEmoji = (emoji?.isEmpty == false) ? emoji! : "❤️"
+		// Mirrors how iMessage phrases a tapback notification ("Name liked …").
+		return String.localizedStringWithFormat(
+			"%1$@ reacted %2$@ to \"%3$@\"".localized,
+			senderName, reactionEmoji, originalText
+		)
+	}
+
+	/// Builds a message/reaction local notification from a (context-bound) `MessageEntity`,
+	/// synchronously, so callers can hand the resulting value to a deferred `@MainActor` Task
+	/// without capturing the entity itself. Collapses the DM/channel × regular/reaction variants
+	/// that differ only in `content`, deep-link `path`, and `userNum`.
+	private func makeMessageNotification(
+		message: MessageEntity,
+		content: String,
+		path: String,
+		userNum: Int64?,
+		critical: Bool
+	) -> Notification {
+		var notification = Notification(
+			id: ("notification.id.\(message.messageId)"),
+			title: "\(message.fromUser?.longName ?? "Unknown".localized)",
+			subtitle: "AKA \(message.fromUser?.shortName ?? "?")",
+			content: content,
+			target: "messages",
+			path: path,
+			messageId: message.messageId,
+			channel: message.channel,
+			userNum: userNum,
+			critical: critical
+		)
+		#if os(iOS)
+		notification.senderIntent = CarPlayIntentDonation.incomingMessageIntent(from: message)
+		#endif
+		return notification
+	}
+
 	func textMessageAppPacket(
 		packet: MeshPacket,
 		wantRangeTestPackets: Bool,
@@ -1340,33 +1389,41 @@ actor MeshPackets {
 									appState?.unreadDirectMessages = unreadCount
 								}
 							}
-							if !(newMessage.fromUser?.mute ?? false) && newMessage.isEmoji == false {
+							if !(newMessage.fromUser?.mute ?? false) {
 								// Build the notification from the model objects now, while this context is valid,
 								// and capture only the resulting value — a deferred Task must not hold `newMessage`
 								// (a context-bound model), since a device switch can reset this context first
 								// ("destroyed by ModelContext.reset").
 								let senderName = newMessage.fromUser?.longName ?? "Unknown".localized
-								var dmNotification = Notification(
-									id: ("notification.id.\(newMessage.messageId)"),
-									title: "\(senderName)",
-									subtitle: "AKA \(newMessage.fromUser?.shortName ?? "?")",
-									content: messageText!,
-									target: "messages",
-									path: "meshtastic:///messages?userNum=\(newMessage.fromUser?.num ?? 0)&messageId=\(newMessage.isEmoji ? newMessage.replyID : newMessage.messageId)",
-									messageId: newMessage.messageId,
-									channel: newMessage.channel,
-									userNum: Int64(packet.from),
-									critical: critical
-								)
-								#if os(iOS)
-								dmNotification.senderIntent = CarPlayIntentDonation.incomingMessageIntent(from: newMessage)
-								#endif
-								let notification = dmNotification
-								Task {@MainActor in
-									let manager = LocalNotificationManager()
-									manager.notifications = [notification]
-									manager.schedule()
-									Logger.services.debug("iOS Notification Scheduled for text message from \(senderName, privacy: .public)")
+								let dmUserNum = Int64(packet.from)
+								var dmNotification: Notification?
+								if newMessage.isEmoji == false {
+									dmNotification = makeMessageNotification(
+										message: newMessage,
+										content: messageText!,
+										path: "meshtastic:///messages?userNum=\(newMessage.fromUser?.num ?? 0)&messageId=\(newMessage.messageId)",
+										userNum: dmUserNum,
+										critical: critical
+									)
+								} else if let reactionBody = MeshPackets.reactionNotificationBody(replyID: newMessage.replyID, emoji: messageText, senderName: senderName, context: modelContext) {
+									// Tapback/reaction: only notify when the reacted-to message is known locally.
+									// A "phantom" tapback (replyID with no matching local message) is stored but not
+									// surfaced — reactionNotificationBody returns nil in that case.
+									dmNotification = makeMessageNotification(
+										message: newMessage,
+										content: reactionBody,
+										path: "meshtastic:///messages?userNum=\(newMessage.fromUser?.num ?? 0)&messageId=\(newMessage.replyID)",
+										userNum: dmUserNum,
+										critical: critical
+									)
+								}
+								if let notification = dmNotification {
+									Task {@MainActor in
+										let manager = LocalNotificationManager()
+										manager.notifications = [notification]
+										manager.schedule()
+										Logger.services.debug("iOS Notification Scheduled for direct message from \(senderName, privacy: .public)")
+									}
 								}
 							}
 						} else if newMessage.fromUser != nil && newMessage.toUser == nil {
@@ -1384,25 +1441,31 @@ actor MeshPackets {
 									// to ~1/sec — the badge tolerates brief lag and resyncs on app-active and on read.
 									let recountUnread = shouldRecomputeChannelUnread()
 									let connectedNodeNum = connectedNode
-									let shouldNotify = UserDefaults.channelMessageNotifications && newMessage.isEmoji == false && myInfo.channels.contains(where: { $0.index == newMessage.channel && !$0.mute })
+									let channelNotificationsEnabled = UserDefaults.channelMessageNotifications && myInfo.channels.contains(where: { $0.index == newMessage.channel && !$0.mute })
+									let senderName = newMessage.fromUser?.longName ?? "Unknown".localized
+									let channelUserNum = Int64(newMessage.fromUser?.userId ?? "0")
 									var channelNotification: Notification?
-									if shouldNotify {
-										var chNotification = Notification(
-											id: ("notification.id.\(newMessage.messageId)"),
-											title: "\(newMessage.fromUser?.longName ?? "Unknown".localized)",
-											subtitle: "AKA \(newMessage.fromUser?.shortName ?? "?")",
-											content: messageText!,
-											target: "messages",
-											path: "meshtastic:///messages?channelId=\(newMessage.channel)&messageId=\(newMessage.isEmoji ? newMessage.replyID : newMessage.messageId)",
-											messageId: newMessage.messageId,
-											channel: newMessage.channel,
-											userNum: Int64(newMessage.fromUser?.userId ?? "0"),
-											critical: critical
-										)
-										#if os(iOS)
-										chNotification.senderIntent = CarPlayIntentDonation.incomingMessageIntent(from: newMessage)
-										#endif
-										channelNotification = chNotification
+									if channelNotificationsEnabled {
+										if newMessage.isEmoji == false {
+											channelNotification = makeMessageNotification(
+												message: newMessage,
+												content: messageText!,
+												path: "meshtastic:///messages?channelId=\(newMessage.channel)&messageId=\(newMessage.messageId)",
+												userNum: channelUserNum,
+												critical: critical
+											)
+										} else if let reactionBody = MeshPackets.reactionNotificationBody(replyID: newMessage.replyID, emoji: messageText, senderName: senderName, context: modelContext) {
+											// Tapback/reaction: only notify when the reacted-to message is known
+											// locally. A "phantom" tapback is stored but not surfaced — the helper
+											// returns nil in that case, per Android's guard.
+											channelNotification = makeMessageNotification(
+												message: newMessage,
+												content: reactionBody,
+												path: "meshtastic:///messages?channelId=\(newMessage.channel)&messageId=\(newMessage.replyID)",
+												userNum: channelUserNum,
+												critical: critical
+											)
+										}
 									}
 									let notification = channelNotification
 									Task {@MainActor in

MeshtasticTests/ReactionNotificationTests.swift

@@ -0,0 +1,90 @@
+//
+//  ReactionNotificationTests.swift
+//  MeshtasticTests
+//
+//  Coverage for issue #2039: receiving a tapback/reaction should surface a local
+//  notification (it previously produced none), *except* for a "phantom" tapback whose
+//  replyID doesn't match a locally-known message — that is stored but must not notify,
+//  matching Android's guard (MeshDataHandlerImpl.rememberReaction).
+//
+//  These exercise `MeshPackets.reactionNotificationBody(replyID:emoji:senderName:context:)`
+//  directly against an in-memory SwiftData context, so both the phantom guard and the
+//  iMessage-style body formatting are locked in without spinning up the whole packet path.
+//
+
+import Testing
+import Foundation
+import SwiftData
+@testable import Meshtastic
+
+@Suite("Reaction notifications (#2039)")
+@MainActor
+struct ReactionNotificationTests {
+
+	private var context: ModelContext { TestContainerProvider.shared.mainContext }
+
+	/// Insert an original (reacted-to) message with a unique id and the given payload.
+	@discardableResult
+	private func insertOriginal(id: Int64, payload: String?) -> MessageEntity {
+		let msg = MessageEntity()
+		context.insert(msg)
+		msg.messageId = id
+		msg.messagePayload = payload
+		msg.isEmoji = false
+		try? context.save()
+		return msg
+	}
+
+	private func body(replyID: Int64, emoji: String?, sender: String = "Bob") -> String? {
+		MeshPackets.reactionNotificationBody(
+			replyID: replyID,
+			emoji: emoji,
+			senderName: sender,
+			context: context
+		)
+	}
+
+	// MARK: - Phantom-tapback guard (the core of the fix)
+
+	@Test func phantomTapback_unknownReplyID_returnsNil() {
+		// No message with id 990001 exists in the store.
+		#expect(body(replyID: 990_001, emoji: "👍") == nil)
+	}
+
+	@Test func replyIDZero_returnsNil() {
+		// replyID == 0 means "not a reply/reaction to anything" — never notify.
+		#expect(body(replyID: 0, emoji: "👍") == nil)
+	}
+
+	@Test func negativeReplyID_returnsNil() {
+		#expect(body(replyID: -5, emoji: "👍") == nil)
+	}
+
+	// MARK: - Found original -> formatted iMessage-style body
+
+	@Test func knownReplyID_formatsBody() {
+		insertOriginal(id: 990_010, payload: "See you soon")
+		let result = body(replyID: 990_010, emoji: "👍", sender: "Alice")
+		#expect(result == "Alice reacted 👍 to \"See you soon\"")
+	}
+
+	@Test func knownReplyID_emptyEmoji_fallsBackToHeart() {
+		insertOriginal(id: 990_020, payload: "Hello there")
+		let result = body(replyID: 990_020, emoji: "")
+		#expect(result == "Bob reacted ❤️ to \"Hello there\"")
+	}
+
+	@Test func knownReplyID_nilEmoji_fallsBackToHeart() {
+		insertOriginal(id: 990_030, payload: "Hello there")
+		let result = body(replyID: 990_030, emoji: nil)
+		#expect(result == "Bob reacted ❤️ to \"Hello there\"")
+	}
+
+	@Test func knownReplyID_nilOriginalPayload_stillNotifies() {
+		// The original message exists (so it's NOT a phantom tapback) but has no text.
+		// We still surface a notification; the quoted text is simply empty.
+		insertOriginal(id: 990_040, payload: nil)
+		let result = body(replyID: 990_040, emoji: "🎉", sender: "Carol")
+		#expect(result == "Carol reacted 🎉 to \"\"")
+	}
+}