refactor(map): architecture, expression DSL, and filter UX

- Decompose composables: MapControlsOverlay, NodeMarkerLayers, etc.
- Modern Kotlin idioms: when expressions, takeIf, zipWithNext
- MapLibre expression DSL: coalesce(), step(), switch/condition
- Replace compass with DisappearingCompassButton (material3)
- Replace last-heard Slider with SingleChoiceSegmentedButtonRow
- Add active filter count badge on filter button
- Add node search/filter by name in filter dropdown
- 109 tests total across JVM + Android host

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jamesarich

core/resources/src/commonMain/composeResources/values/strings.xml

@@ -832,6 +832,7 @@
     <string name="show_waypoints">Show Waypoints</string>
     <string name="show_precision_circle">Show Precision Circles</string>
     <string name="show_weather_radar">Weather Radar</string>
+    <string name="search_nodes_hint">Search nodes…</string>
     <string name="owm_api_key_hint">OpenWeatherMap API Key (global)</string>
     <string name="owm_info_title">Global Weather Radar</string>
     <string name="owm_info_message">Without an API key, weather radar shows US-only NOAA NEXRAD data.\n\nFor global coverage, enter a free OpenWeatherMap API key. Sign up at openweathermap.org/api — the free tier includes 1,000 tile requests per day.</string>

feature/map/build.gradle.kts

@@ -31,7 +31,7 @@ kotlin {
         commonMain.dependencies {
             implementation(libs.jetbrains.navigation3.ui)
             implementation(libs.kotlinx.collections.immutable)
-            api(libs.maplibre.compose)
+            implementation(libs.maplibre.compose)
             implementation(libs.maplibre.compose.material3)
             implementation(projects.core.data)
             implementation(projects.core.database)

feature/map/src/commonMain/kotlin/org/meshtastic/feature/map/BaseMapViewModel.kt

@@ -17,7 +17,6 @@
 package org.meshtastic.feature.map
 
 import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -30,7 +29,6 @@ import org.meshtastic.core.common.util.nowSeconds
 import org.meshtastic.core.model.DataPacket
 import org.meshtastic.core.model.Node
 import org.meshtastic.core.model.RadioController
-import org.meshtastic.core.model.TracerouteOverlay
 import org.meshtastic.core.repository.MapPrefs
 import org.meshtastic.core.repository.NodeRepository
 import org.meshtastic.core.repository.PacketRepository
@@ -42,7 +40,6 @@ import org.meshtastic.core.resources.one_hour
 import org.meshtastic.core.resources.two_days
 import org.meshtastic.core.ui.viewmodel.safeLaunch
 import org.meshtastic.core.ui.viewmodel.stateInWhileSubscribed
-import org.meshtastic.proto.Position
 import org.meshtastic.proto.Waypoint
 import org.meshtastic.core.common.util.ioDispatcher as defaultIoDispatcher
 
@@ -99,38 +96,22 @@ open class BaseMapViewModel(
     private val showOnlyFavorites = MutableStateFlow(mapPrefs.showOnlyFavorites.value)
     val showOnlyFavoritesOnMap: StateFlow<Boolean> = showOnlyFavorites.asStateFlow()
 
-    fun toggleOnlyFavorites() {
-        val newValue = !showOnlyFavorites.value
-        showOnlyFavorites.value = newValue
-        mapPrefs.setShowOnlyFavorites(newValue)
-    }
+    fun toggleOnlyFavorites() = togglePref(showOnlyFavorites, mapPrefs::setShowOnlyFavorites)
 
     private val showWaypoints = MutableStateFlow(mapPrefs.showWaypointsOnMap.value)
     val showWaypointsOnMap: StateFlow<Boolean> = showWaypoints.asStateFlow()
 
-    fun toggleShowWaypointsOnMap() {
-        val newValue = !showWaypoints.value
-        showWaypoints.value = newValue
-        mapPrefs.setShowWaypointsOnMap(newValue)
-    }
+    fun toggleShowWaypointsOnMap() = togglePref(showWaypoints, mapPrefs::setShowWaypointsOnMap)
 
     private val showPrecisionCircle = MutableStateFlow(mapPrefs.showPrecisionCircleOnMap.value)
     val showPrecisionCircleOnMap: StateFlow<Boolean> = showPrecisionCircle.asStateFlow()
 
-    fun toggleShowPrecisionCircleOnMap() {
-        val newValue = !showPrecisionCircle.value
-        showPrecisionCircle.value = newValue
-        mapPrefs.setShowPrecisionCircleOnMap(newValue)
-    }
+    fun toggleShowPrecisionCircleOnMap() = togglePref(showPrecisionCircle, mapPrefs::setShowPrecisionCircleOnMap)
 
     private val showWeatherRadar = MutableStateFlow(mapPrefs.showWeatherRadarOnMap.value)
     val showWeatherRadarOnMap: StateFlow<Boolean> = showWeatherRadar.asStateFlow()
 
-    fun toggleShowWeatherRadarOnMap() {
-        val newValue = !showWeatherRadar.value
-        showWeatherRadar.value = newValue
-        mapPrefs.setShowWeatherRadarOnMap(newValue)
-    }
+    fun toggleShowWeatherRadarOnMap() = togglePref(showWeatherRadar, mapPrefs::setShowWeatherRadarOnMap)
 
     private val owmApiKeyBuffer = MutableStateFlow(mapPrefs.openWeatherMapApiKey.value)
     val owmApiKey: StateFlow<String> = owmApiKeyBuffer.asStateFlow()
@@ -160,6 +141,13 @@ open class BaseMapViewModel(
 
     fun getNodeOrFallback(nodeNum: Int): Node = nodeRepository.nodeDBbyNum.value[nodeNum] ?: Node(num = nodeNum)
 
+    /** Toggle a boolean pref flow and persist the new value. */
+    private inline fun togglePref(flow: MutableStateFlow<Boolean>, crossinline persist: (Boolean) -> Unit) {
+        val toggled = !flow.value
+        flow.value = toggled
+        persist(toggled)
+    }
+
     fun deleteWaypoint(id: Int) =
         safeLaunch(context = ioDispatcher, tag = "deleteWaypoint") { packetRepository.deleteWaypoint(id) }
 
@@ -176,6 +164,12 @@ open class BaseMapViewModel(
         safeLaunch(context = ioDispatcher, tag = "sendDataPacket") { radioController.sendMessage(p) }
     }
 
+    private val nodeSearchQuery = MutableStateFlow("")
+
+    fun setNodeSearchQuery(query: String) {
+        nodeSearchQuery.value = query
+    }
+
     fun generatePacketId(): Int = radioController.getPacketId()
 
     data class MapFilterState(
@@ -186,7 +180,21 @@ open class BaseMapViewModel(
         val owmApiKey: String,
         val lastHeardFilter: LastHeardFilter,
         val lastHeardTrackFilter: LastHeardFilter,
-    )
+        val nodeSearchQuery: String = "",
+    ) {
+        /** Number of active non-default filters, shown as a badge on the filter button. */
+        val activeFilterCount: Int
+            get() =
+                listOf(
+                    onlyFavorites,
+                    !showWaypoints,
+                    !showPrecisionCircle,
+                    showWeatherRadar,
+                    lastHeardFilter != LastHeardFilter.Any,
+                    nodeSearchQuery.isNotBlank(),
+                )
+                    .count { it }
+    }
 
     val mapFilterStateFlow: StateFlow<MapFilterState> =
         combine(
@@ -209,8 +217,9 @@ open class BaseMapViewModel(
             },
             showWeatherRadarOnMap,
             owmApiKey,
-        ) { state, weatherRadar, apiKey ->
-            state.copy(showWeatherRadar = weatherRadar, owmApiKey = apiKey)
+            nodeSearchQuery,
+        ) { state, weatherRadar, apiKey, searchQuery ->
+            state.copy(showWeatherRadar = weatherRadar, owmApiKey = apiKey, nodeSearchQuery = searchQuery)
         }
             .stateInWhileSubscribed(
                 initialValue =
@@ -225,89 +234,27 @@ open class BaseMapViewModel(
                 ),
             )
 
-    /** Nodes with position, filtered by favorites and last-heard preferences. */
+    /** Nodes with position, filtered by favorites, last-heard, and search query. */
     val filteredNodes: StateFlow<List<Node>> =
         combine(nodesWithPosition, mapFilterStateFlow) { nodes, filter ->
             val myNum = myNodeNum
-            nodes
-                .filter { node -> !filter.onlyFavorites || node.isFavorite || node.num == myNum }
-                .filter { node ->
+            val query = filter.nodeSearchQuery.trim().lowercase()
+            nodes.filter { node ->
+                val isMyNode = node.num == myNum
+                val matchesFavorite = !filter.onlyFavorites || node.isFavorite || isMyNode
+                val matchesLastHeard =
                     filter.lastHeardFilter.seconds == 0L ||
                         (nowSeconds - node.lastHeard) <= filter.lastHeardFilter.seconds ||
-                        node.num == myNum
-                }
-        }
-            .stateInWhileSubscribed(initialValue = emptyList())
-}
-
-/**
- * Result of resolving a [TracerouteOverlay]'s node nums into displayable [Node] instances.
- *
- * @property overlayNodeNums All unique node nums referenced by the traceroute.
- * @property nodesForMarkers Nodes to render as map markers (with snapshot positions when available).
- * @property nodeLookup Node-num-keyed map for polyline coordinate resolution.
- */
-internal data class TracerouteNodeSelection(
-    val overlayNodeNums: Set<Int>,
-    val nodesForMarkers: List<Node>,
-    val nodeLookup: Map<Int, Node>,
-)
-
-/** Convenience extension that delegates to [tracerouteNodeSelection] using the VM's [getNodeOrFallback]. */
-internal fun BaseMapViewModel.tracerouteNodeSelection(
-    tracerouteOverlay: TracerouteOverlay?,
-    tracerouteNodePositions: Map<Int, Position>,
-    nodes: List<Node>,
-): TracerouteNodeSelection = tracerouteNodeSelection(
-    tracerouteOverlay = tracerouteOverlay,
-    tracerouteNodePositions = tracerouteNodePositions,
-    nodes = nodes,
-    getNodeOrFallback = ::getNodeOrFallback,
-)
-
-/**
- * Resolves traceroute overlay node nums into displayable [Node] instances. Snapshot positions (recorded at traceroute
- * time) take priority over live positions from the node database.
- *
- * @param getNodeOrFallback Provides a [Node] for a given num, falling back to a stub if not in the DB.
- */
-internal fun tracerouteNodeSelection(
-    tracerouteOverlay: TracerouteOverlay?,
-    tracerouteNodePositions: Map<Int, Position>,
-    nodes: List<Node>,
-    getNodeOrFallback: (Int) -> Node,
-): TracerouteNodeSelection {
-    val overlayNodeNums = tracerouteOverlay?.relatedNodeNums ?: emptySet()
-    val tracerouteSnapshotNodes =
-        if (tracerouteOverlay == null || tracerouteNodePositions.isEmpty()) {
-            emptyList()
-        } else {
-            tracerouteNodePositions.map { (nodeNum, position) -> getNodeOrFallback(nodeNum).copy(position = position) }
-        }
-
-    val nodesForMarkers =
-        if (tracerouteOverlay != null) {
-            if (tracerouteSnapshotNodes.isNotEmpty()) {
-                tracerouteSnapshotNodes.filter { overlayNodeNums.contains(it.num) }
-            } else {
-                nodes.filter { overlayNodeNums.contains(it.num) }
+                        isMyNode
+                val matchesSearch =
+                    query.isEmpty() ||
+                        node.user.short_name.lowercase().contains(query) ||
+                        node.user.long_name.lowercase().contains(query) ||
+                        isMyNode
+                matchesFavorite && matchesLastHeard && matchesSearch
             }
-        } else {
-            nodes
         }
-
-    val nodesForLookup =
-        if (tracerouteSnapshotNodes.isNotEmpty()) {
-            tracerouteSnapshotNodes
-        } else {
-            nodes.filter { it.validPosition != null }
-        }
-
-    return TracerouteNodeSelection(
-        overlayNodeNums = overlayNodeNums,
-        nodesForMarkers = nodesForMarkers,
-        nodeLookup = nodesForLookup.associateBy { it.num },
-    )
+            .stateInWhileSubscribed(initialValue = emptyList())
 }
 
 @Suppress("MagicNumber")

feature/map/src/commonMain/kotlin/org/meshtastic/feature/map/MapScreen.kt

@@ -41,6 +41,7 @@ import org.maplibre.compose.location.LocationTrackingEffect
 import org.maplibre.compose.location.rememberNullLocationProvider
 import org.maplibre.compose.location.rememberUserLocationState
 import org.maplibre.compose.map.GestureOptions
+import org.maplibre.compose.material3.DisappearingCompassButton
 import org.maplibre.compose.material3.DisappearingScaleBar
 import org.maplibre.compose.material3.ExpandingAttributionButton
 import org.maplibre.compose.style.rememberStyleState
@@ -116,24 +117,22 @@ fun MapScreen(
         }
     }
 
-    // Location tracking state: 3-mode cycling (Off → Track → TrackBearing → Off)
-    var isLocationTrackingEnabled by remember { mutableStateOf(false) }
-    var bearingUpdate by remember { mutableStateOf(BearingUpdate.TRACK_LOCATION) }
+    // Location tracking state: 3-mode cycling (Off → TrackBearing → TrackNorth → Off)
+    var locationTrackingMode by remember { mutableStateOf(LocationTrackingMode.OFF) }
     val locationProvider = rememberLocationProviderOrNull()
     val locationState = rememberUserLocationState(locationProvider ?: rememberNullLocationProvider())
     val locationAvailable = locationProvider != null
 
+    val isLocationTrackingEnabled = locationTrackingMode != LocationTrackingMode.OFF
+    val bearingUpdate = locationTrackingMode.bearingUpdate
+
     // Derive gesture options from location tracking state
     val gestureOptions =
-        remember(isLocationTrackingEnabled, bearingUpdate) {
-            if (isLocationTrackingEnabled) {
-                when (bearingUpdate) {
-                    BearingUpdate.IGNORE -> GestureOptions.PositionLocked
-                    BearingUpdate.ALWAYS_NORTH -> GestureOptions.ZoomOnly
-                    BearingUpdate.TRACK_LOCATION -> GestureOptions.ZoomOnly
-                }
-            } else {
-                GestureOptions.Standard
+        remember(locationTrackingMode) {
+            when (locationTrackingMode) {
+                LocationTrackingMode.OFF -> GestureOptions.Standard
+                LocationTrackingMode.TRACK_BEARING -> GestureOptions.ZoomOnly
+                LocationTrackingMode.TRACK_NORTH -> GestureOptions.ZoomOnly
             }
         }
 
@@ -198,26 +197,23 @@ fun MapScreen(
                 LocationTrackingEffect(
                     locationState = locationState,
                     enabled = isLocationTrackingEnabled,
-                    trackBearing = bearingUpdate == BearingUpdate.TRACK_LOCATION,
+                    trackBearing = locationTrackingMode == LocationTrackingMode.TRACK_BEARING,
                 ) {
                     cameraState.updateFromLocation(updateBearing = bearingUpdate)
                 }
 
                 // Cancel tracking when user manually pans the map
                 LaunchedEffect(cameraState.moveReason) {
                     if (cameraState.moveReason == CameraMoveReason.GESTURE && isLocationTrackingEnabled) {
-                        isLocationTrackingEnabled = false
-                        bearingUpdate = BearingUpdate.IGNORE
+                        locationTrackingMode = LocationTrackingMode.OFF
                     }
                 }
             }
 
             MapControlsOverlay(
                 onToggleFilterMenu = { filterMenuExpanded = !filterMenuExpanded },
                 modifier = Modifier.align(Alignment.TopEnd).padding(paddingValues),
-                bearing = cameraState.position.bearing.toFloat(),
-                onCompassClick = { scope.launch { cameraState.animateTo(cameraState.position.copy(bearing = 0.0)) } },
-                followPhoneBearing = isLocationTrackingEnabled && bearingUpdate == BearingUpdate.TRACK_LOCATION,
+                activeFilterCount = filterState.activeFilterCount,
                 filterDropdownContent = {
                     MapFilterDropdown(
                         expanded = filterMenuExpanded,
@@ -229,6 +225,7 @@ fun MapScreen(
                         onToggleWeatherRadar = viewModel::toggleShowWeatherRadarOnMap,
                         onSetOwmApiKey = viewModel::setOwmApiKey,
                         onSetLastHeardFilter = viewModel::setLastHeardFilter,
+                        onSetNodeSearchQuery = viewModel::setNodeSearchQuery,
                     )
                 },
                 mapTypeContent = {
@@ -244,28 +241,14 @@ fun MapScreen(
                     )
                 },
                 isLocationTrackingEnabled = isLocationTrackingEnabled,
-                isTrackingBearing = bearingUpdate == BearingUpdate.TRACK_LOCATION,
-                onToggleLocationTracking = {
-                    if (!isLocationTrackingEnabled) {
-                        // Off → Track with bearing
-                        bearingUpdate = BearingUpdate.TRACK_LOCATION
-                        isLocationTrackingEnabled = true
-                    } else {
-                        when (bearingUpdate) {
-                            BearingUpdate.TRACK_LOCATION -> {
-                                // TrackBearing → TrackNorth
-                                bearingUpdate = BearingUpdate.ALWAYS_NORTH
-                            }
-                            BearingUpdate.ALWAYS_NORTH -> {
-                                // TrackNorth → Off
-                                isLocationTrackingEnabled = false
-                            }
-                            BearingUpdate.IGNORE -> {
-                                isLocationTrackingEnabled = false
-                            }
-                        }
-                    }
-                },
+                isTrackingBearing = locationTrackingMode == LocationTrackingMode.TRACK_BEARING,
+                onToggleLocationTracking = { locationTrackingMode = locationTrackingMode.next() },
+            )
+
+            // Compass — auto-hides when north-up, resets bearing/tilt on tap
+            DisappearingCompassButton(
+                cameraState = cameraState,
+                modifier = Modifier.align(Alignment.TopStart).padding(paddingValues).padding(MAP_OVERLAY_PADDING),
             )
 
             // Zoom controls
@@ -341,3 +324,17 @@ fun MapScreen(
         )
     }
 }
+
+/** Location tracking state machine: Off → TrackBearing → TrackNorth → Off. */
+private enum class LocationTrackingMode(val bearingUpdate: BearingUpdate) {
+    OFF(BearingUpdate.IGNORE),
+    TRACK_BEARING(BearingUpdate.TRACK_LOCATION),
+    TRACK_NORTH(BearingUpdate.ALWAYS_NORTH),
+    ;
+
+    fun next(): LocationTrackingMode = when (this) {
+        OFF -> TRACK_BEARING
+        TRACK_BEARING -> TRACK_NORTH
+        TRACK_NORTH -> OFF
+    }
+}