Support TAK v2 + legacy v1 conversion

Author: thebentern

core/model/src/commonMain/kotlin/org/meshtastic/core/model/Capabilities.kt

@@ -58,6 +58,14 @@ data class Capabilities(val firmwareVersion: String?, internal val forceEnableAl
     /** Support for TAK (ATAK) module configuration. Supported since firmware v2.7.19. */
     val supportsTakConfig = atLeast(V2_7_19)
 
+    /**
+     * Support for the v2 TAK port (ATAK_PLUGIN_V2 = 78) with TAKPacketV2 + zstd dictionary compression.
+     * Supported since firmware v2.8.0. Firmware v2.7.x and earlier only support the legacy
+     * ATAK_PLUGIN port (72) with the original TAKPacket schema (PLI + GeoChat only, no compression),
+     * so the bridge falls back to that path for older nodes.
+     */
+    val supportsTakV2 = atLeast(V2_8_0)
+
     /** Support for location sharing on secondary channels. Supported since firmware v2.6.10. */
     val supportsSecondaryChannelLocation = atLeast(V2_6_10)
 
@@ -72,6 +80,7 @@ data class Capabilities(val firmwareVersion: String?, internal val forceEnableAl
         private val V2_7_17 = DeviceVersion("2.7.17")
         private val V2_7_18 = DeviceVersion("2.7.18")
         private val V2_7_19 = DeviceVersion("2.7.19")
+        private val V2_8_0 = DeviceVersion("2.8.0")
         private val V3_0_0 = DeviceVersion("3.0.0")
         private val UNRELEASED = DeviceVersion("9.9.9")
     }

core/takserver/src/commonMain/kotlin/org/meshtastic/core/takserver/TAKMeshIntegration.kt

@@ -27,12 +27,14 @@ import kotlinx.coroutines.flow.map
 
 import kotlinx.coroutines.launch
 import okio.ByteString.Companion.toByteString
+import org.meshtastic.core.model.Capabilities
 import org.meshtastic.core.model.DataPacket
 import org.meshtastic.core.repository.CommandSender
 import org.meshtastic.core.repository.MeshConfigHandler
+import org.meshtastic.core.repository.NodeRepository
 
 import org.meshtastic.core.repository.ServiceRepository
-import org.meshtastic.core.takserver.TAKPacketV2Conversion.toCoTMessage
+import org.meshtastic.core.takserver.TAKPacketConversion.toTAKPacket
 import org.meshtastic.core.takserver.TAKPacketV2Conversion.toTAKPacketV2
 import org.meshtastic.proto.MemberRole
 import org.meshtastic.proto.MeshPacket
@@ -46,15 +48,31 @@ import kotlin.time.Duration.Companion.minutes
 /**
  * Bidirectional bridge between the local TAK server and the Meshtastic mesh network.
  *
- * V2 protocol only: All traffic uses port 78 (ATAK_PLUGIN_V2).
- * Legacy V1 port 72 is still received for backward compatibility but will be removed.
+ * Outbound traffic (TAK client -> mesh) is version-gated on the connected radio's
+ * firmware version, exposed via [Capabilities.supportsTakV2]:
+ *
+ *  - Firmware **>= 2.8.0**: TAKPacketV2 on port 78 (ATAK_PLUGIN_V2) with zstd
+ *    dictionary compression via TAKPacket-SDK. Supports all CoT payload types
+ *    (PLI, GeoChat, DrawnShape, Marker, Route, Aircraft, Casevac, Emergency, Task)
+ *    with compact typed encodings that fit under the 237B LoRa MTU.
+ *
+ *  - Firmware **<= 2.7.x**: Legacy [TAKPacket] on port 72 (ATAK_PLUGIN) with bare
+ *    protobuf encoding. Supports only PLI and GeoChat — shapes, markers, routes,
+ *    and other typed CoT events are dropped (with a warning) because the legacy
+ *    schema cannot represent them.
+ *
+ * Inbound traffic (mesh -> TAK client) is always dual-path tolerant — both port 72
+ * and port 78 are dispatched regardless of the local radio's firmware version, so
+ * a v2-capable node can still relay legacy v1 packets received from older nodes
+ * in mixed-firmware mesh deployments.
  */
 class TAKMeshIntegration(
     private val takServerManager: TAKServerManager,
     private val commandSender: CommandSender,
 
     private val serviceRepository: ServiceRepository,
     private val meshConfigHandler: MeshConfigHandler,
+    private val nodeRepository: NodeRepository,
 ) {
     @Volatile private var isRunning = false
     private val jobs = mutableListOf<Job>()
@@ -113,7 +131,9 @@ class TAKMeshIntegration(
         )
 
         jobs.addAll(newJobs)
-        Logger.i { "TAK Mesh Integration started (v2 protocol)" }
+        val fw = nodeRepository.myNodeInfo.value?.firmwareVersion
+        val proto = if (Capabilities(fw).supportsTakV2) "v2 (port 78, zstd)" else "v1 (port 72, legacy)"
+        Logger.i { "TAK Mesh Integration started — firmware=$fw, outbound=$proto" }
     }
 
     fun stop() {
@@ -128,7 +148,34 @@ class TAKMeshIntegration(
 
     // ── Send: TAK client → mesh ─────────────────────────────────────────────
 
+    /**
+     * Determine the outbound TAK protocol version based on the connected radio's
+     * firmware version. Evaluated per-send (not cached) so the bridge picks up
+     * firmware upgrades during a session without restart. If the firmware
+     * version is unavailable (radio not yet handshook), default to V2 — the
+     * v2 firmware was released widely enough that defaulting to legacy would
+     * be a regression for the common case.
+     */
+    private fun useTakV2(): Boolean {
+        val fw = nodeRepository.myNodeInfo.value?.firmwareVersion ?: return true
+        return Capabilities(fw).supportsTakV2
+    }
+
     private suspend fun sendCoTToMesh(cotMessage: CoTMessage) {
+        if (useTakV2()) {
+            sendCoTToMeshV2(cotMessage)
+        } else {
+            sendCoTToMeshV1(cotMessage)
+        }
+    }
+
+    /**
+     * v2 send path (firmware >= 2.8.0): SDK parser + zstd dictionary compression,
+     * full typed payload support (DrawnShape, Marker, Route, Aircraft, Casevac,
+     * Emergency, Task, plus PLI / GeoChat). Wire format: `[flags byte][zstd-compressed
+     * TAKPacketV2 protobuf]` on port 78 (ATAK_PLUGIN_V2).
+     */
+    private suspend fun sendCoTToMeshV2(cotMessage: CoTMessage) {
         // Prefer the sourceEventXml for shape/marker/route types — the SDK's
         // CotXmlParser extracts compact typed payloads (DrawnShape, Marker,
         // Route, etc.) that compress far better than raw_detail encoding.
@@ -142,8 +189,6 @@ class TAKMeshIntegration(
         // Strip non-essential elements before compression to save wire bytes
         val xml = stripNonEssentialElements(freshXml)
 
-        // Logger.d { "RAW CoT OUT (mesh, ${cotMessage.type}): $rawXml" }
-
         // Route through the SDK parser/compressor which handles all typed
         // payloads (DrawnShape, Marker, Route, Aircraft, etc.) with compact
         // proto fields instead of raw_detail XML. Falls back to the app's
@@ -199,6 +244,44 @@ class TAKMeshIntegration(
         }
     }
 
+    /**
+     * Legacy v1 send path (firmware <= 2.7.x): bare protobuf-encoded [TAKPacket]
+     * on port 72 (ATAK_PLUGIN), no zstd compression. Only PLI and GeoChat
+     * payloads are supported by the v1 schema — shapes, markers, routes,
+     * casevac, emergency, and task CoT events are dropped with a warning.
+     */
+    private suspend fun sendCoTToMeshV1(cotMessage: CoTMessage) {
+        val takPacket = cotMessage.toTAKPacket() ?: run {
+            Logger.w {
+                "Dropping CoT for legacy v1 radio: type=${cotMessage.type} not representable " +
+                    "in v1 TAKPacket schema (only PLI and GeoChat are supported). " +
+                    "Upgrade radio firmware to >= 2.8.0 for full payload support."
+            }
+            return
+        }
+
+        val wirePayload = TAKPacket.ADAPTER.encode(takPacket)
+        if (wirePayload.size > MAX_TAK_WIRE_PAYLOAD_BYTES) {
+            Logger.w {
+                "Dropping oversized v1 TAK packet: type=${cotMessage.type} " +
+                    "size=${wirePayload.size}B max=$MAX_TAK_WIRE_PAYLOAD_BYTES"
+            }
+            return
+        }
+
+        try {
+            val dataPacket = DataPacket(
+                to = DataPacket.ID_BROADCAST,
+                bytes = wirePayload.toByteString(),
+                dataType = PortNum.ATAK_PLUGIN.value,
+            )
+            commandSender.sendData(dataPacket)
+            Logger.d { "Sent V1 to mesh: ${cotMessage.type} (${wirePayload.size} bytes)" }
+        } catch (e: Throwable) {
+            Logger.e(e) { "Failed to send v1 TAKPacket to mesh (${cotMessage.type}, ${wirePayload.size} bytes): ${e.message}" }
+        }
+    }
+
     /**
      * Wrap a [org.meshtastic.proto.TAKPacketV2] into the uncompressed v2 wire format:
      * `[0xFF flag byte][raw protobuf]`. Used as a fallback when the zstd native lib

core/takserver/src/commonMain/kotlin/org/meshtastic/core/takserver/TAKPacketConversion.kt

@@ -0,0 +1,186 @@
+/*
+ * 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/>.
+ */
+@file:Suppress("CyclomaticComplexMethod", "ReturnCount")
+
+package org.meshtastic.core.takserver
+
+import co.touchlab.kermit.Logger
+import org.meshtastic.proto.Contact
+import org.meshtastic.proto.GeoChat
+import org.meshtastic.proto.Group
+import org.meshtastic.proto.MemberRole
+import org.meshtastic.proto.PLI
+import org.meshtastic.proto.Status
+import org.meshtastic.proto.TAKPacket
+import org.meshtastic.proto.Team
+import kotlin.random.Random
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.minutes
+
+/**
+ * Legacy v1 CoT <-> TAKPacket conversion for firmware <= 2.7.x.
+ *
+ * Wire format: bare protobuf-encoded [TAKPacket] on `ATAK_PLUGIN` port 72,
+ * no zstd compression (the proto has an `is_compressed` flag but the firmware
+ * doesn't act on it). Supports only PLI and GeoChat payloads — shape, marker,
+ * route, casevac, emergency, and task CoT events return null and are dropped.
+ *
+ * For the SDK-backed path that handles all payload types with zstd dictionary
+ * compression on `ATAK_PLUGIN_V2` port 78, see [TAKPacketV2Conversion].
+ *
+ * [TAKMeshIntegration] picks between the two paths based on
+ * `Capabilities.supportsTakV2` (firmware >= 2.8.0).
+ */
+object TAKPacketConversion {
+
+    fun CoTMessage.toTAKPacket(): TAKPacket? {
+        val group =
+            this.group?.let {
+                Group(
+                    role = MemberRole.fromValue(TakConversionHelpers.getMemberRoleValue(it.role))
+                        ?: MemberRole.Unspecifed,
+                    team = Team.fromValue(TakConversionHelpers.getTeamValue(it.name)) ?: Team.Unspecifed_Color,
+                )
+            }
+
+        val status = this.status?.let { Status(battery = it.battery.coerceAtLeast(0)) }
+
+        if (type.startsWith("a-f-G") || type.startsWith("a-f-g")) {
+            return createPliPacket(group, status)
+        }
+
+        if (type == "b-t-f") {
+            return createChatPacket(group, status)
+        }
+
+        Logger.w { "Cannot convert CoT to TAKPacket for type $type" }
+        return null
+    }
+
+    private fun CoTMessage.createPliPacket(group: Group?, status: Status?): TAKPacket {
+        val contact = this.contact?.let { Contact(callsign = it.callsign, device_callsign = this.uid) }
+        val pli =
+            PLI(
+                latitude_i = (latitude * TAK_COORDINATE_SCALE).toInt(),
+                longitude_i = (longitude * TAK_COORDINATE_SCALE).toInt(),
+                altitude = if (hae >= TAK_UNKNOWN_POINT_VALUE || hae.isNaN()) 0 else hae.toInt(),
+                speed = track?.speed?.coerceAtLeast(0.0)?.toInt() ?: 0,
+                course = track?.course?.coerceAtLeast(0.0)?.toInt() ?: 0,
+            )
+
+        return TAKPacket(is_compressed = false, contact = contact, group = group, status = status, pli = pli)
+    }
+
+    private fun CoTMessage.createChatPacket(group: Group?, status: Status?): TAKPacket? {
+        val localChat = this.chat ?: return null
+        val chatMsg = localChat.message
+        var toUid: String? = null
+        var toCallsign: String? = null
+
+        val actualDeviceUid = this.uid.geoChatSenderUid()
+        val messageId =
+            if (this.uid.startsWith("GeoChat.")) {
+                this.uid.geoChatMessageId()
+            } else {
+                Random.nextInt().toString(TAK_HEX_RADIX)
+            }
+
+        val contact =
+            this.contact?.let {
+                val smuggledCallsign =
+                    if (actualDeviceUid.isNotEmpty()) {
+                        "$actualDeviceUid|$messageId"
+                    } else {
+                        it.endpoint ?: ""
+                    }
+                Contact(callsign = it.callsign, device_callsign = smuggledCallsign)
+            }
+
+        if (localChat.chatroom.startsWith(this.uid) || this.uid.startsWith("GeoChat")) {
+            val parts = this.uid.split(".")
+            if (parts.size >= TAK_DIRECT_MESSAGE_PARTS_MIN && parts[0] == "GeoChat") {
+                toUid = localChat.chatroom
+            }
+        } else if (localChat.chatroom != "All Chat Rooms") {
+            toCallsign = localChat.chatroom
+        }
+
+        val chat =
+            GeoChat(
+                message = chatMsg,
+                to = toUid ?: if (toCallsign == null) "All Chat Rooms" else null,
+                to_callsign = toCallsign,
+            )
+
+        return TAKPacket(is_compressed = false, contact = contact, group = group, status = status, chat = chat)
+    }
+
+    fun TAKPacket.toCoTMessage(): CoTMessage? {
+        val rawDeviceCallsign = contact?.device_callsign ?: "UNKNOWN"
+        val senderCallsign = contact?.callsign ?: "UNKNOWN"
+        val timeNow = Clock.System.now()
+        val staleTime = timeNow + DEFAULT_TAK_STALE_MINUTES.minutes
+
+        val (senderUid, messageId) = TakConversionHelpers.parseDeviceCallsign(rawDeviceCallsign)
+
+        val localPli = pli
+        if (localPli != null) {
+            return CoTMessage.pli(
+                uid = senderUid,
+                callsign = senderCallsign,
+                latitude = localPli.latitude_i.toDouble() / TAK_COORDINATE_SCALE,
+                longitude = localPli.longitude_i.toDouble() / TAK_COORDINATE_SCALE,
+                altitude = localPli.altitude.toDouble(),
+                speed = localPli.speed.toDouble(),
+                course = localPli.course.toDouble(),
+                team = TakConversionHelpers.teamToColorName(group?.team),
+                role = TakConversionHelpers.roleToName(group?.role),
+                battery = status?.battery ?: DEFAULT_TAK_BATTERY,
+                staleMinutes = DEFAULT_TAK_STALE_MINUTES,
+            )
+        }
+
+        val localChat = chat
+        if (localChat != null) {
+            val chatroom =
+                if (localChat.to != null || localChat.to_callsign != null) {
+                    localChat.to_callsign ?: localChat.to ?: "Direct Message"
+                } else {
+                    "All Chat Rooms"
+                }
+
+            val msgId = messageId ?: Random.nextInt().toString(TAK_HEX_RADIX)
+
+            return CoTMessage(
+                uid = "GeoChat.$senderUid.$chatroom.$msgId",
+                type = "b-t-f",
+                how = "h-g-i-g-o",
+                time = timeNow,
+                start = timeNow,
+                stale = staleTime,
+                latitude = 0.0,
+                longitude = 0.0,
+                contact = CoTContact(callsign = senderCallsign, endpoint = DEFAULT_TAK_ENDPOINT),
+                group = CoTGroup(name = TakConversionHelpers.teamToColorName(group?.team), role = TakConversionHelpers.roleToName(group?.role)),
+                status = CoTStatus(battery = status?.battery ?: DEFAULT_TAK_BATTERY),
+                chat = CoTChat(chatroom = chatroom, senderCallsign = senderCallsign, message = localChat.message),
+            )
+        }
+
+        return null
+    }
+}