fix(discovery): fix scan engine bugs and nav crash

- Add use_preset=true and use setLocalConfig to shift presets.
- Fix ConcurrentModificationExceptions in persistCurrentDwellResults by locking.
- Only collect packets while dwelling, preventing misattributions during shift.
- Increase reconnect timeout to 60s for slow radios.
- Fetch neighbor names from NodeDB for better neighbor matching.
- Add DiscoveryRoute to MeshtasticNavSavedStateConfig to fix serialization crash.

Author: jamesarich

core/navigation/src/commonMain/kotlin/org/meshtastic/core/navigation/NavigationConfig.kt

@@ -40,6 +40,7 @@ val MeshtasticNavSavedStateConfig = SavedStateConfiguration {
             subclassesOfSealed<SettingsRoute>()
             subclassesOfSealed<FirmwareRoute>()
             subclassesOfSealed<WifiProvisionRoute>()
+            subclassesOfSealed<DiscoveryRoute>()
         }
     }
 }

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoveryScanEngine.kt

@@ -201,7 +201,7 @@ class DiscoveryScanEngine(
     // region DiscoveryPacketCollector
 
     override suspend fun onPacketReceived(meshPacket: MeshPacket, dataPacket: DataPacket) {
-        if (!isActive) return
+        if (_scanState.value !is DiscoveryScanState.Dwell) return
         val fromNum = meshPacket.from.toLong()
         val portNum = meshPacket.decoded?.portnum ?: return
 
@@ -222,12 +222,14 @@ class DiscoveryScanEngine(
                 }
             }
 
-            // Try to fill in names from the live NodeDB
-            if (node.shortName == null || node.longName == null) {
-                val dbNode = nodeRepository.nodeDBbyNum.value[fromNum.toInt()]
-                if (dbNode != null) {
-                    node.shortName = dbNode.user.short_name.ifBlank { null }
-                    node.longName = dbNode.user.long_name.ifBlank { null }
+            // Ensure all nodes in the collection have names if available in the NodeDB
+            collectedNodes.values.forEach { n ->
+                if (n.shortName == null || n.longName == null) {
+                    val dbNode = nodeRepository.nodeDBbyNum.value[n.nodeNum.toInt()]
+                    if (dbNode != null) {
+                        n.shortName = dbNode.user.short_name.ifBlank { null }
+                        n.longName = dbNode.user.long_name.ifBlank { null }
+                    }
                 }
             }
         }
@@ -243,8 +245,10 @@ class DiscoveryScanEngine(
             if (!isActive) return
 
             currentPresetName = preset.name
-            mutex.withLock { collectedNodes.clear() }
-            deviceMetricsLog.clear()
+            mutex.withLock {
+                collectedNodes.clear()
+                deviceMetricsLog.clear()
+            }
             totalDwellSeconds = dwellDurationSeconds
 
             // Shift to the new preset
@@ -263,7 +267,14 @@ class DiscoveryScanEngine(
             }
 
             // Dwell
-            runDwell(preset.name, dwellDurationSeconds)
+            val dwellCompleted = runDwell(preset.name, dwellDurationSeconds)
+            if (!dwellCompleted) {
+                cancelScanInternal()
+                restoreHomePreset()
+                finalizeSession("paused")
+                _scanState.value = DiscoveryScanState.Idle
+                return
+            }
             if (!isActive) return
 
             // Persist this preset's results
@@ -279,11 +290,13 @@ class DiscoveryScanEngine(
     }
 
     private suspend fun shiftPreset(preset: ChannelOption) {
-        val myNodeNum = nodeRepository.myNodeInfo.value?.myNodeNum ?: return
-        val loraConfig = Config.LoRaConfig(modem_preset = preset.modemPreset)
+        val loraConfig = Config.LoRaConfig(use_preset = true, modem_preset = preset.modemPreset)
         val config = Config(lora = loraConfig)
-        radioController.setConfig(myNodeNum, config, radioController.getPacketId())
-        Logger.i { "DiscoveryScanEngine: shifted to ${preset.name}" }
+        radioController.setLocalConfig(config)
+        Logger.i { "DiscoveryScanEngine: shifted to ${preset.name} (use_preset=true)" }
+        // The firmware often restarts the radio or reboots after a LoRa config change.
+        // Wait a short moment to ensure we don't consider it 'connected' right before it drops.
+        delay(3000)
     }
 
     private suspend fun waitForConnection(): Boolean {
@@ -294,9 +307,17 @@ class DiscoveryScanEngine(
         return result != null
     }
 
-    private suspend fun runDwell(presetName: String, durationSeconds: Long) {
+    private suspend fun runDwell(presetName: String, durationSeconds: Long): Boolean {
         var remaining = durationSeconds
         while (remaining > 0 && isActive) {
+            val isConnected = serviceRepository.connectionState.value is ConnectionState.Connected
+            if (!isConnected) {
+                _scanState.value = DiscoveryScanState.Reconnecting(presetName)
+                val reconnected = waitForConnection()
+                if (!reconnected) return false
+                continue
+            }
+
             _scanState.value =
                 DiscoveryScanState.Dwell(
                     presetName = presetName,
@@ -306,6 +327,7 @@ class DiscoveryScanEngine(
             delay(TICK_INTERVAL_MS)
             remaining--
         }
+        return true
     }
 
     // endregion
@@ -384,55 +406,57 @@ class DiscoveryScanEngine(
 
     private suspend fun persistCurrentDwellResults() {
         if (sessionId == 0L) return
-        if (collectedNodes.isEmpty()) {
-            // Persist a zero-result entry so the preset appears in reports
-            val emptyResult =
+        mutex.withLock {
+            if (collectedNodes.isEmpty()) {
+                // Persist a zero-result entry so the preset appears in reports
+                val emptyResult =
+                    DiscoveryPresetResultEntity(
+                        sessionId = sessionId,
+                        presetName = currentPresetName,
+                        dwellDurationSeconds = totalDwellSeconds,
+                    )
+                discoveryDao.insertPresetResult(emptyResult)
+                return
+            }
+
+            val (avgChannelUtil, avgAirUtil) = computeAverageMetrics()
+            val directCount = collectedNodes.values.count { it.neighborType == "direct" }
+            val meshCount = collectedNodes.values.count { it.neighborType == "mesh" }
+
+            val presetResult =
                 DiscoveryPresetResultEntity(
                     sessionId = sessionId,
                     presetName = currentPresetName,
                     dwellDurationSeconds = totalDwellSeconds,
+                    uniqueNodes = collectedNodes.size,
+                    directNeighborCount = directCount,
+                    meshNeighborCount = meshCount,
+                    messageCount = collectedNodes.values.sumOf { it.messageCount },
+                    sensorPacketCount = collectedNodes.values.sumOf { it.sensorPacketCount },
+                    avgChannelUtilization = avgChannelUtil,
+                    avgAirtimeRate = avgAirUtil,
                 )
-            discoveryDao.insertPresetResult(emptyResult)
-            return
+            val presetResultId = discoveryDao.insertPresetResult(presetResult)
+
+            val nodeEntities =
+                collectedNodes.values.map { data ->
+                    DiscoveredNodeEntity(
+                        presetResultId = presetResultId,
+                        nodeNum = data.nodeNum,
+                        shortName = data.shortName,
+                        longName = data.longName,
+                        neighborType = data.neighborType,
+                        latitude = data.latitude,
+                        longitude = data.longitude,
+                        hopCount = data.hopCount,
+                        snr = data.snr,
+                        rssi = data.rssi,
+                        messageCount = data.messageCount,
+                        sensorPacketCount = data.sensorPacketCount,
+                    )
+                }
+            discoveryDao.insertDiscoveredNodes(nodeEntities)
         }
-
-        val (avgChannelUtil, avgAirUtil) = computeAverageMetrics()
-        val directCount = collectedNodes.values.count { it.neighborType == "direct" }
-        val meshCount = collectedNodes.values.count { it.neighborType == "mesh" }
-
-        val presetResult =
-            DiscoveryPresetResultEntity(
-                sessionId = sessionId,
-                presetName = currentPresetName,
-                dwellDurationSeconds = totalDwellSeconds,
-                uniqueNodes = collectedNodes.size,
-                directNeighborCount = directCount,
-                meshNeighborCount = meshCount,
-                messageCount = collectedNodes.values.sumOf { it.messageCount },
-                sensorPacketCount = collectedNodes.values.sumOf { it.sensorPacketCount },
-                avgChannelUtilization = avgChannelUtil,
-                avgAirtimeRate = avgAirUtil,
-            )
-        val presetResultId = discoveryDao.insertPresetResult(presetResult)
-
-        val nodeEntities =
-            collectedNodes.values.map { data ->
-                DiscoveredNodeEntity(
-                    presetResultId = presetResultId,
-                    nodeNum = data.nodeNum,
-                    shortName = data.shortName,
-                    longName = data.longName,
-                    neighborType = data.neighborType,
-                    latitude = data.latitude,
-                    longitude = data.longitude,
-                    hopCount = data.hopCount,
-                    snr = data.snr,
-                    rssi = data.rssi,
-                    messageCount = data.messageCount,
-                    sensorPacketCount = data.sensorPacketCount,
-                )
-            }
-        discoveryDao.insertDiscoveredNodes(nodeEntities)
     }
 
     /**
@@ -502,7 +526,7 @@ class DiscoveryScanEngine(
     // endregion
 
     companion object {
-        private const val RECONNECT_TIMEOUT_MS = 30_000L
+        private const val RECONNECT_TIMEOUT_MS = 60_000L
         private const val TICK_INTERVAL_MS = 1_000L
         private const val POSITION_DIVISOR = 1e7
         private const val MIN_DEVICE_METRICS_PACKETS = 2