Merge remote-tracking branch 'upstream/main' into chore/convert-main-tree-buildable

Author: bruschill

Localizable.xcstrings

@@ -579,6 +579,9 @@
         }
       }
     },
+    "%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."
+    },
     "%@" : {
       "localizations" : {
         "da" : {

Meshtastic/API/MeshtasticAPI.swift

@@ -50,14 +50,14 @@ private struct DeviceHardware: Codable {
 }
 
 /// Firmware Release Lists
-private struct FirmwareReleases: Codable {
+struct FirmwareReleases: Codable {
 	let releases: Releases
 	let pullRequests: [FirmwareRelease]
 }
-private struct Releases: Codable {
+struct Releases: Codable {
 	let stable, alpha: [FirmwareRelease]
 }
-private struct FirmwareRelease: Codable {
+struct FirmwareRelease: Codable {
 	let id, title: String
 	let pageURL: String
 	let zipURL: String
@@ -71,6 +71,59 @@ private struct FirmwareRelease: Codable {
 	}
 }
 
+private struct GitHubFirmwareRelease: Decodable {
+	let tagName: String
+	let name: String?
+	let htmlURL: String
+	let zipballURL: String
+	let body: String?
+	let prerelease: Bool
+	let draft: Bool
+
+	enum CodingKeys: String, CodingKey {
+		case tagName = "tag_name"
+		case name
+		case htmlURL = "html_url"
+		case zipballURL = "zipball_url"
+		case body
+		case prerelease
+		case draft
+	}
+}
+
+enum FirmwareReleaseCatalog {
+	static func decode(_ data: Data) throws -> FirmwareReleases {
+		let decoder = JSONDecoder()
+		if let meshtasticReleases = try? decoder.decode(FirmwareReleases.self, from: data) {
+			return meshtasticReleases
+		}
+
+		let githubReleases = try decoder.decode([GitHubFirmwareRelease].self, from: data)
+		let publishedReleases = githubReleases.filter { !$0.draft }
+		let stable = publishedReleases
+			.filter { !$0.prerelease }
+			.map { FirmwareRelease(gitHubRelease: $0) }
+		let alpha = publishedReleases
+			.filter(\.prerelease)
+			.map { FirmwareRelease(gitHubRelease: $0) }
+
+		return FirmwareReleases(
+			releases: Releases(stable: stable, alpha: alpha),
+			pullRequests: []
+		)
+	}
+}
+
+private extension FirmwareRelease {
+	init(gitHubRelease: GitHubFirmwareRelease) {
+		id = gitHubRelease.tagName
+		title = gitHubRelease.name ?? gitHubRelease.tagName
+		pageURL = gitHubRelease.htmlURL
+		zipURL = gitHubRelease.zipballURL
+		releaseNotes = gitHubRelease.body
+	}
+}
+
 extension MeshtasticAPI {
 	enum MeshtasticAPIError: Error, LocalizedError {
 		case timedOut(TimeInterval)
@@ -116,6 +169,7 @@ class MeshtasticAPI: ObservableObject, @unchecked Sendable {
 	static let deviceURLEndpoint = URL(string: "https://api.meshtastic.org/resource/deviceHardware")!
 	static let imageURLPrefix = URL(string: "https://flasher.meshtastic.org/img/devices/")!
 	static let firmwareURLEndpoint = URL(string: "https://api.meshtastic.org/github/firmware/list")!
+	static let firmwareGitHubURLEndpoint = URL(string: "https://api.github.com/repos/meshtastic/firmware/releases?per_page=100")!
 	static let eventFirmwareURLEndpoint = URL(string: "https://api.meshtastic.org/resource/eventFirmware")!
 
 	// MARK: - Private properties
@@ -154,10 +208,19 @@ class MeshtasticAPI: ObservableObject, @unchecked Sendable {
 		await MainActor.run {
 			self.isLoadingFirmwareList = true
 		}
-		
-		let apiData = try await Self.firmwareURLEndpoint.data(timeout: 5.0)
-		
-		let decodedFirmware = try decoder.decode(FirmwareReleases.self, from: apiData)
+		defer {
+			Task { @MainActor in self.isLoadingFirmwareList = false }
+		}
+
+		let decodedFirmware: FirmwareReleases
+		do {
+			let apiData = try await Self.firmwareURLEndpoint.data(timeout: 5.0)
+			decodedFirmware = try FirmwareReleaseCatalog.decode(apiData)
+		} catch {
+			Logger.services.warning("Firmware API request failed; falling back to GitHub releases: \(error.localizedDescription, privacy: .public)")
+			let githubData = try await Self.firmwareGitHubURLEndpoint.data(timeout: 5.0)
+			decodedFirmware = try FirmwareReleaseCatalog.decode(githubData)
+		}
 		let stableVersions = Set(decodedFirmware.releases.stable.map { $0.id })
 		let alphaVersions = Set(decodedFirmware.releases.alpha.map { $0.id })
 
@@ -196,10 +259,6 @@ class MeshtasticAPI: ObservableObject, @unchecked Sendable {
 
 		// Save the last update date for the firmware
 		UserDefaults.lastFirmwareAPIUpdate = Date()
-		
-		await MainActor.run {
-			self.isLoadingFirmwareList = false
-		}
 	}
 
 	func refreshDevicesAPIData() async throws {

Meshtastic/Accessory/Accessory Manager/AccessoryManager+ToRadio.swift

@@ -379,8 +379,9 @@ extension AccessoryManager {
 						try context.save()
 						Logger.data.info("💾 Saved a new sent message from \(self.activeDeviceNum?.toHex() ?? "0", privacy: .public) to \(toUserNum.toHex(), privacy: .public)")
 						// Donate outgoing message to SiriKit for CarPlay
+						// (CarPlay is iPhone-only, so skip on Mac Catalyst).
 						if !isEmoji {
-							#if os(iOS)
+							#if os(iOS) && !targetEnvironment(macCatalyst)
 							CarPlayIntentDonation.donateOutgoingMessage(content: message, toUserNum: toUserNum, channel: channel)
 							#endif
 						}

Meshtastic/Helpers/LocalNotificationManager.swift

@@ -67,6 +67,10 @@ class LocalNotificationManager {
 			if notification.messageId != nil {
 				content.categoryIdentifier = "messageNotificationCategory"
 				content.userInfo["messageId"] = notification.messageId
+				// `messageId` identifies this notification for cancellation (keyed on the packet's
+				// own id). Tapback/reply actions must instead target the message being replied to,
+				// which differs for reactions — carry it separately, defaulting to `messageId`.
+				content.userInfo["replyMessageId"] = notification.replyMessageId ?? notification.messageId
 			}
 			if notification.channel != nil {
 				content.userInfo["channel"] = notification.channel
@@ -146,6 +150,10 @@ struct Notification {
 	var target: String?
 	var path: String?
 	var messageId: Int64?
+	/// Target message id for tapback/reply actions. For a reaction notification this is the
+	/// original (reacted-to) message rather than the reaction packet in `messageId`. `nil` means
+	/// "same as `messageId`" (regular messages).
+	var replyMessageId: Int64?
 	var channel: Int32?
 	var userNum: Int64?
 	var critical: Bool = false

Meshtastic/Helpers/MeshPackets.swift

@@ -1143,6 +1143,62 @@ 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`.
+	///
+	/// `replyMessageId` is the message that tapback/reply notification actions should target. It
+	/// defaults to `message.messageId`, but for a reaction notification the caller passes the
+	/// original (reacted-to) message id so actions act on that message rather than the reaction
+	/// packet (which `messageId` — used for notification cancellation — must keep referencing).
+	private func makeMessageNotification(
+		message: MessageEntity,
+		content: String,
+		path: String,
+		userNum: Int64?,
+		critical: Bool,
+		replyMessageId: Int64? = nil
+	) -> 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,
+			replyMessageId: replyMessageId ?? message.messageId,
+			channel: message.channel,
+			userNum: userNum,
+			critical: critical
+		)
+		#if os(iOS) && !targetEnvironment(macCatalyst)
+		notification.senderIntent = CarPlayIntentDonation.incomingMessageIntent(from: message)
+		#endif
+		return notification
+	}
+
 	func textMessageAppPacket(
 		packet: MeshPacket,
 		wantRangeTestPackets: Bool,
@@ -1347,7 +1403,8 @@ actor MeshPackets {
 					// Send notifications if the message saved properly to core data
 					if messageSaved {
 						// Donate to SiriKit so the message appears in CarPlay Messages
-						#if os(iOS)
+						// (CarPlay is iPhone-only, so skip on Mac Catalyst).
+						#if os(iOS) && !targetEnvironment(macCatalyst)
 						CarPlayIntentDonation.donateReceivedMessage(newMessage)
 						#endif
 
@@ -1362,33 +1419,42 @@ 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,
+										replyMessageId: newMessage.replyID
+									)
+								}
+								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 {
@@ -1406,25 +1472,34 @@ 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
+										&& !(newMessage.fromUser?.mute ?? false)
+										&& 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,
+												replyMessageId: newMessage.replyID
+											)
+										}
 									}
 									let notification = channelNotification
 									Task {@MainActor in

Meshtastic/MeshtasticAppDelegate.swift

@@ -124,7 +124,7 @@ class MeshtasticAppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificat
 			}
 		case "messageNotification.thumbsUpAction":
 			if let channel = userInfo["channel"] as? Int32,
-			   let replyID = userInfo["messageId"] as? Int64 {
+			   let replyID = userInfo["replyMessageId"] as? Int64 ?? userInfo["messageId"] as? Int64 {
 				Task {
 					do {
 						try await AccessoryManager.shared.sendMessage(
@@ -142,7 +142,7 @@ class MeshtasticAppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificat
 			}
 		case "messageNotification.thumbsDownAction":
 			if let channel = userInfo["channel"] as? Int32,
-			   let replyID = userInfo["messageId"] as? Int64 {
+			   let replyID = userInfo["replyMessageId"] as? Int64 ?? userInfo["messageId"] as? Int64 {
 				Task {
 					do {
 						try await AccessoryManager.shared.sendMessage(
@@ -161,7 +161,7 @@ class MeshtasticAppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificat
 		case "messageNotification.replyInputAction":
 			if let userInput = (response as? UNTextInputNotificationResponse)?.userText,
 			   let channel = userInfo["channel"] as? Int32,
-			   let replyID = userInfo["messageId"] as? Int64 {
+			   let replyID = userInfo["replyMessageId"] as? Int64 ?? userInfo["messageId"] as? Int64 {
 				Task {
 					do {
 						try await AccessoryManager.shared.sendMessage(

Meshtastic/Model/Firmware/FirmwareUpdateNotifier.swift

@@ -24,6 +24,8 @@ struct FirmwareUpdateNotificationSource {
 }
 
 struct FirmwareUpdateNotice: Equatable {
+	static let symbolName = "arrow.triangle.2.circlepath"
+
 	let notificationKey: String
 	let deviceName: String
 	let currentVersion: String