refactor: maps (#2097)

Signed-off-by: James Rich <2199651+jamesarich@users.noreply.github.com>

app/src/fdroid/java/com/geeksville/mesh/ui/map/MapView.kt

@@ -0,0 +1,791 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.map
+
+import android.Manifest // Added for Accompanist
+import android.content.Context
+import androidx.appcompat.content.res.AppCompatResources
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Lens
+import androidx.compose.material.icons.filled.LocationDisabled
+import androidx.compose.material.icons.filled.PinDrop
+import androidx.compose.material.icons.filled.Star
+import androidx.compose.material.icons.outlined.Layers
+import androidx.compose.material.icons.outlined.MyLocation
+import androidx.compose.material.icons.outlined.Tune
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableDoubleStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.geeksville.mesh.DataPacket
+import com.geeksville.mesh.MeshProtos.Waypoint
+import com.geeksville.mesh.R
+import com.geeksville.mesh.android.BuildUtils.debug
+import com.geeksville.mesh.android.gpsDisabled
+import com.geeksville.mesh.android.hasGps
+import com.geeksville.mesh.copy
+import com.geeksville.mesh.database.entity.Packet
+import com.geeksville.mesh.model.Node
+import com.geeksville.mesh.model.UIViewModel
+import com.geeksville.mesh.model.map.CustomTileSource
+import com.geeksville.mesh.model.map.MarkerWithLabel
+import com.geeksville.mesh.model.map.clustering.RadiusMarkerClusterer
+import com.geeksville.mesh.ui.map.components.CacheLayout
+import com.geeksville.mesh.ui.map.components.DownloadButton
+import com.geeksville.mesh.ui.map.components.EditWaypointDialog
+import com.geeksville.mesh.ui.map.components.MapButton
+import com.geeksville.mesh.util.SqlTileWriterExt
+import com.geeksville.mesh.util.addCopyright
+import com.geeksville.mesh.util.addScaleBarOverlay
+import com.geeksville.mesh.util.createLatLongGrid
+import com.geeksville.mesh.util.formatAgo
+import com.geeksville.mesh.util.zoomIn
+import com.geeksville.mesh.waypoint
+import com.google.accompanist.permissions.ExperimentalPermissionsApi // Added for Accompanist
+import com.google.accompanist.permissions.rememberMultiplePermissionsState // Added for Accompanist
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.osmdroid.bonuspack.utils.BonusPackHelper.getBitmapFromVectorDrawable
+import org.osmdroid.config.Configuration
+import org.osmdroid.events.MapEventsReceiver
+import org.osmdroid.events.MapListener
+import org.osmdroid.events.ScrollEvent
+import org.osmdroid.events.ZoomEvent
+import org.osmdroid.tileprovider.cachemanager.CacheManager
+import org.osmdroid.tileprovider.modules.SqliteArchiveTileWriter
+import org.osmdroid.tileprovider.tilesource.ITileSource
+import org.osmdroid.tileprovider.tilesource.OnlineTileSourceBase
+import org.osmdroid.tileprovider.tilesource.TileSourcePolicyException
+import org.osmdroid.util.BoundingBox
+import org.osmdroid.util.GeoPoint
+import org.osmdroid.views.MapView
+import org.osmdroid.views.overlay.MapEventsOverlay
+import org.osmdroid.views.overlay.Marker
+import org.osmdroid.views.overlay.Polygon
+import org.osmdroid.views.overlay.infowindow.InfoWindow
+import org.osmdroid.views.overlay.mylocation.MyLocationNewOverlay
+import java.io.File
+import java.text.DateFormat
+
+@Composable
+private fun MapView.UpdateMarkers(
+    nodeMarkers: List<MarkerWithLabel>,
+    waypointMarkers: List<MarkerWithLabel>,
+    nodeClusterer: RadiusMarkerClusterer,
+) {
+    debug("Showing on map: ${nodeMarkers.size} nodes ${waypointMarkers.size} waypoints")
+    overlays.removeAll { it is MarkerWithLabel }
+    // overlays.addAll(nodeMarkers + waypointMarkers)
+    overlays.addAll(waypointMarkers)
+    nodeClusterer.items.clear()
+    nodeClusterer.items.addAll(nodeMarkers)
+    nodeClusterer.invalidate()
+}
+
+//    private fun addWeatherLayer() {
+//        if (map.tileProvider.tileSource.name()
+//                .equals(CustomTileSource.getTileSource("ESRI World TOPO").name())
+//        ) {
+//            val layer = TilesOverlay(
+//                MapTileProviderBasic(
+//                    activity,
+//                    CustomTileSource.OPENWEATHER_RADAR
+//                ), context
+//            )
+//            layer.loadingBackgroundColor = Color.TRANSPARENT
+//            layer.loadingLineColor = Color.TRANSPARENT
+//            map.overlayManager.add(layer)
+//        }
+//    }
+
+private fun cacheManagerCallback(onTaskComplete: () -> Unit, onTaskFailed: (Int) -> Unit) =
+    object : CacheManager.CacheManagerCallback {
+        override fun onTaskComplete() {
+            onTaskComplete()
+        }
+
+        override fun onTaskFailed(errors: Int) {
+            onTaskFailed(errors)
+        }
+
+        override fun updateProgress(progress: Int, currentZoomLevel: Int, zoomMin: Int, zoomMax: Int) {
+            // NOOP since we are using the build in UI
+        }
+
+        override fun downloadStarted() {
+            // NOOP since we are using the build in UI
+        }
+
+        override fun setPossibleTilesInArea(total: Int) {
+            // NOOP since we are using the build in UI
+        }
+    }
+
+private fun Context.purgeTileSource(onResult: (String) -> Unit) {
+    val cache = SqlTileWriterExt()
+    val builder = MaterialAlertDialogBuilder(this)
+    builder.setTitle(R.string.map_tile_source)
+    val sources = cache.sources
+    val sourceList = mutableListOf<String>()
+    for (i in sources.indices) {
+        sourceList.add(sources[i].source as String)
+    }
+    val selected: BooleanArray? = null
+    val selectedList = mutableListOf<Int>()
+    builder.setMultiChoiceItems(sourceList.toTypedArray(), selected) { _, i, b ->
+        if (b) {
+            selectedList.add(i)
+        } else {
+            selectedList.remove(i)
+        }
+    }
+    builder.setPositiveButton(R.string.clear) { _, _ ->
+        for (x in selectedList) {
+            val item = sources[x]
+            val b = cache.purgeCache(item.source)
+            onResult(
+                if (b) {
+                    getString(R.string.map_purge_success, item.source)
+                } else {
+                    getString(R.string.map_purge_fail)
+                },
+            )
+        }
+    }
+    builder.setNegativeButton(R.string.cancel) { dialog, _ -> dialog.cancel() }
+    builder.show()
+}
+
+/**
+ * Main composable for displaying the map view, including nodes, waypoints, and user location. It handles user
+ * interactions for map manipulation, filtering, and offline caching.
+ *
+ * @param model The [UIViewModel] providing data and state for the map.
+ * @param navigateToNodeDetails Callback to navigate to the details screen of a selected node.
+ */
+@OptIn(ExperimentalPermissionsApi::class) // Added for Accompanist
+@Suppress("CyclomaticComplexMethod", "LongMethod")
+@Composable
+fun MapView(
+    uiViewModel: UIViewModel = viewModel(),
+    mapViewModel: MapViewModel = viewModel(),
+    navigateToNodeDetails: (Int) -> Unit,
+) {
+    var mapFilterExpanded by remember { mutableStateOf(false) }
+
+    val mapFilterState by mapViewModel.mapFilterStateFlow.collectAsStateWithLifecycle()
+    val isConnected by uiViewModel.isConnectedStateFlow.collectAsStateWithLifecycle()
+
+    var cacheEstimate by remember { mutableStateOf("") }
+
+    var zoomLevelMin by remember { mutableDoubleStateOf(0.0) }
+    var zoomLevelMax by remember { mutableDoubleStateOf(0.0) }
+
+    var downloadRegionBoundingBox: BoundingBox? by remember { mutableStateOf(null) }
+    var myLocationOverlay: MyLocationNewOverlay? by remember { mutableStateOf(null) }
+
+    var showDownloadButton: Boolean by remember { mutableStateOf(false) }
+    var showEditWaypointDialog by remember { mutableStateOf<Waypoint?>(null) }
+    var showCurrentCacheInfo by remember { mutableStateOf(false) }
+
+    val context = LocalContext.current
+    val density = LocalDensity.current
+
+    val haptic = LocalHapticFeedback.current
+    fun performHapticFeedback() = haptic.performHapticFeedback(HapticFeedbackType.LongPress)
+
+    val hasGps = remember { context.hasGps() }
+
+    // Accompanist permissions state for location
+    val locationPermissionsState =
+        rememberMultiplePermissionsState(permissions = listOf(Manifest.permission.ACCESS_FINE_LOCATION))
+    var triggerLocationToggleAfterPermission by remember { mutableStateOf(false) }
+
+    fun loadOnlineTileSourceBase(): ITileSource {
+        val id = mapViewModel.mapStyleId
+        debug("mapStyleId from prefs: $id")
+        return CustomTileSource.getTileSource(id).also {
+            zoomLevelMax = it.maximumZoomLevel.toDouble()
+            showDownloadButton = if (it is OnlineTileSourceBase) it.tileSourcePolicy.acceptsBulkDownload() else false
+        }
+    }
+
+    val initialCameraView = remember {
+        val nodes = mapViewModel.nodes.value
+        val nodesWithPosition = nodes.filter { it.validPosition != null }
+        val geoPoints = nodesWithPosition.map { GeoPoint(it.latitude, it.longitude) }
+        BoundingBox.fromGeoPoints(geoPoints)
+    }
+    val map = rememberMapViewWithLifecycle(initialCameraView, loadOnlineTileSourceBase())
+
+    val nodeClusterer = remember { RadiusMarkerClusterer(context) }
+
+    fun MapView.toggleMyLocation() {
+        if (context.gpsDisabled()) {
+            debug("Telling user we need location turned on for MyLocationNewOverlay")
+            uiViewModel.showSnackBar(R.string.location_disabled)
+            return
+        }
+        debug("user clicked MyLocationNewOverlay ${myLocationOverlay == null}")
+        if (myLocationOverlay == null) {
+            myLocationOverlay =
+                MyLocationNewOverlay(this).apply {
+                    enableMyLocation()
+                    enableFollowLocation()
+                    getBitmapFromVectorDrawable(context, R.drawable.ic_map_location_dot_24)?.let {
+                        setPersonIcon(it)
+                        setPersonAnchor(0.5f, 0.5f)
+                    }
+                    getBitmapFromVectorDrawable(context, R.drawable.ic_map_navigation_24)?.let {
+                        setDirectionIcon(it)
+                        setDirectionAnchor(0.5f, 0.5f)
+                    }
+                }
+            overlays.add(myLocationOverlay)
+        } else {
+            myLocationOverlay?.apply {
+                disableMyLocation()
+                disableFollowLocation()
+            }
+            overlays.remove(myLocationOverlay)
+            myLocationOverlay = null
+        }
+    }
+
+    // Effect to toggle MyLocation after permission is granted
+    LaunchedEffect(locationPermissionsState.allPermissionsGranted) {
+        if (locationPermissionsState.allPermissionsGranted && triggerLocationToggleAfterPermission) {
+            map.toggleMyLocation()
+            triggerLocationToggleAfterPermission = false
+        }
+    }
+
+    val nodes by mapViewModel.nodes.collectAsStateWithLifecycle()
+    val waypoints by mapViewModel.waypoints.collectAsStateWithLifecycle(emptyMap())
+
+    val markerIcon = remember { AppCompatResources.getDrawable(context, R.drawable.ic_baseline_location_on_24) }
+
+    fun MapView.onNodesChanged(nodes: Collection<Node>): List<MarkerWithLabel> {
+        val nodesWithPosition = nodes.filter { it.validPosition != null }
+        val ourNode = uiViewModel.ourNodeInfo.value
+        val displayUnits = uiViewModel.config.display.units
+        val mapFilterStateValue = mapViewModel.mapFilterStateFlow.value // Access mapFilterState directly
+        return nodesWithPosition.mapNotNull { node ->
+            if (mapFilterStateValue.onlyFavorites && !node.isFavorite && !node.equals(ourNode)) {
+                return@mapNotNull null
+            }
+
+            val (p, u) = node.position to node.user
+            val nodePosition = GeoPoint(node.latitude, node.longitude)
+            MarkerWithLabel(mapView = this, label = "${u.shortName} ${formatAgo(p.time)}").apply {
+                id = u.id
+                title = u.longName
+                snippet =
+                    context.getString(
+                        R.string.map_node_popup_details,
+                        node.gpsString(),
+                        formatAgo(node.lastHeard),
+                        formatAgo(p.time),
+                        if (node.batteryStr != "") node.batteryStr else "?",
+                    )
+                ourNode?.distanceStr(node, displayUnits)?.let { dist ->
+                    subDescription = context.getString(R.string.map_subDescription, ourNode.bearing(node), dist)
+                }
+                setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_BOTTOM)
+                position = nodePosition
+                icon = markerIcon
+                setNodeColors(node.colors)
+                if (!mapFilterStateValue.showPrecisionCircle) {
+                    setPrecisionBits(0)
+                } else {
+                    setPrecisionBits(p.precisionBits)
+                }
+                setOnLongClickListener {
+                    navigateToNodeDetails(node.num)
+                    true
+                }
+            }
+        }
+    }
+
+    fun showDeleteMarkerDialog(waypoint: Waypoint) {
+        val builder = MaterialAlertDialogBuilder(context)
+        builder.setTitle(R.string.waypoint_delete)
+        builder.setNeutralButton(R.string.cancel) { _, _ -> debug("User canceled marker delete dialog") }
+        builder.setNegativeButton(R.string.delete_for_me) { _, _ ->
+            debug("User deleted waypoint ${waypoint.id} for me")
+            uiViewModel.deleteWaypoint(waypoint.id)
+        }
+        if (waypoint.lockedTo in setOf(0, uiViewModel.myNodeNum ?: 0) && isConnected) {
+            builder.setPositiveButton(R.string.delete_for_everyone) { _, _ ->
+                debug("User deleted waypoint ${waypoint.id} for everyone")
+                uiViewModel.sendWaypoint(waypoint.copy { expire = 1 })
+                uiViewModel.deleteWaypoint(waypoint.id)
+            }
+        }
+        val dialog = builder.show()
+        for (
+        button in
+        setOf(
+            androidx.appcompat.app.AlertDialog.BUTTON_NEUTRAL,
+            androidx.appcompat.app.AlertDialog.BUTTON_NEGATIVE,
+            androidx.appcompat.app.AlertDialog.BUTTON_POSITIVE,
+        )
+        ) {
+            with(dialog.getButton(button)) {
+                textSize = 12F
+                isAllCaps = false
+            }
+        }
+    }
+
+    fun showMarkerLongPressDialog(id: Int) {
+        performHapticFeedback()
+        debug("marker long pressed id=$id")
+        val waypoint = waypoints[id]?.data?.waypoint ?: return
+        // edit only when unlocked or lockedTo myNodeNum
+        if (waypoint.lockedTo in setOf(0, uiViewModel.myNodeNum ?: 0) && isConnected) {
+            showEditWaypointDialog = waypoint
+        } else {
+            showDeleteMarkerDialog(waypoint)
+        }
+    }
+
+    fun getUsername(id: String?) = if (id == DataPacket.ID_LOCAL) {
+        context.getString(R.string.you)
+    } else {
+        uiViewModel.getUser(id).longName
+    }
+
+    @Composable
+    @Suppress("MagicNumber")
+    fun MapView.onWaypointChanged(waypoints: Collection<Packet>): List<MarkerWithLabel> {
+        val dateFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT)
+        return waypoints.mapNotNull { waypoint ->
+            val pt = waypoint.data.waypoint ?: return@mapNotNull null
+            if (!mapFilterState.showWaypoints) return@mapNotNull null // Use collected mapFilterState
+            val lock = if (pt.lockedTo != 0) "\uD83D\uDD12" else ""
+            val time = dateFormat.format(waypoint.received_time)
+            val label = pt.name + " " + formatAgo((waypoint.received_time / 1000).toInt())
+            val emoji = String(Character.toChars(if (pt.icon == 0) 128205 else pt.icon))
+            val timeLeft = pt.expire * 1000L - System.currentTimeMillis()
+            val expireTimeStr =
+                when {
+                    pt.expire == 0 || pt.expire == Int.MAX_VALUE -> "Never"
+                    timeLeft <= 0 -> "Expired"
+                    timeLeft < 60_000 -> "${timeLeft / 1000} seconds"
+                    timeLeft < 3_600_000 -> "${timeLeft / 60_000} minute${if (timeLeft / 60_000 != 1L) "s" else ""}"
+                    timeLeft < 86_400_000 -> {
+                        val hours = (timeLeft / 3_600_000).toInt()
+                        val minutes = ((timeLeft % 3_600_000) / 60_000).toInt()
+                        if (minutes >= 30) {
+                            "${hours + 1} hour${if (hours + 1 != 1) "s" else ""}"
+                        } else if (minutes > 0) {
+                            "$hours hour${if (hours != 1) "s" else ""}, $minutes minute${if (minutes != 1) "s" else ""}"
+                        } else {
+                            "$hours hour${if (hours != 1) "s" else ""}"
+                        }
+                    }
+
+                    else -> "${timeLeft / 86_400_000} day${if (timeLeft / 86_400_000 != 1L) "s" else ""}"
+                }
+            MarkerWithLabel(this, label, emoji).apply {
+                id = "${pt.id}"
+                title = "${pt.name} (${getUsername(waypoint.data.from)}$lock)"
+                snippet = "[$time] ${pt.description}  " + stringResource(R.string.expires) + ": $expireTimeStr"
+                position = GeoPoint(pt.latitudeI * 1e-7, pt.longitudeI * 1e-7)
+                setVisible(false) // This seems to be always false, was this intended?
+                setOnLongClickListener {
+                    showMarkerLongPressDialog(pt.id)
+                    true
+                }
+            }
+        }
+    }
+
+    LaunchedEffect(showCurrentCacheInfo) {
+        if (!showCurrentCacheInfo) return@LaunchedEffect
+        uiViewModel.showSnackBar(R.string.calculating)
+        val cacheManager = CacheManager(map)
+        val cacheCapacity = cacheManager.cacheCapacity()
+        val currentCacheUsage = cacheManager.currentCacheUsage()
+
+        val mapCacheInfoText =
+            context.getString(
+                R.string.map_cache_info,
+                cacheCapacity / (1024.0 * 1024.0),
+                currentCacheUsage / (1024.0 * 1024.0),
+            )
+
+        MaterialAlertDialogBuilder(context)
+            .setTitle(R.string.map_cache_manager)
+            .setMessage(mapCacheInfoText)
+            .setPositiveButton(R.string.close) { dialog, _ ->
+                showCurrentCacheInfo = false
+                dialog.dismiss()
+            }
+            .show()
+    }
+
+    val mapEventsReceiver =
+        object : MapEventsReceiver {
+            override fun singleTapConfirmedHelper(p: GeoPoint): Boolean {
+                InfoWindow.closeAllInfoWindowsOn(map)
+                return true
+            }
+
+            override fun longPressHelper(p: GeoPoint): Boolean {
+                performHapticFeedback()
+                val enabled = isConnected && downloadRegionBoundingBox == null
+
+                if (enabled) {
+                    showEditWaypointDialog = waypoint {
+                        latitudeI = (p.latitude * 1e7).toInt()
+                        longitudeI = (p.longitude * 1e7).toInt()
+                    }
+                }
+                return true
+            }
+        }
+
+    fun MapView.drawOverlays() {
+        if (overlays.none { it is MapEventsOverlay }) {
+            overlays.add(0, MapEventsOverlay(mapEventsReceiver))
+        }
+        if (myLocationOverlay != null && overlays.none { it is MyLocationNewOverlay }) {
+            overlays.add(myLocationOverlay)
+        }
+        if (overlays.none { it is RadiusMarkerClusterer }) {
+            overlays.add(nodeClusterer)
+        }
+
+        addCopyright()
+        addScaleBarOverlay(density)
+        createLatLongGrid(false)
+
+        invalidate()
+    }
+
+    with(map) { UpdateMarkers(onNodesChanged(nodes), onWaypointChanged(waypoints.values), nodeClusterer) }
+
+    fun MapView.generateBoxOverlay() {
+        overlays.removeAll { it is Polygon }
+        val zoomFactor = 1.3
+        zoomLevelMin = minOf(zoomLevelDouble, zoomLevelMax)
+        downloadRegionBoundingBox = boundingBox.zoomIn(zoomFactor)
+        val polygon =
+            Polygon().apply {
+                points = Polygon.pointsAsRect(downloadRegionBoundingBox).map { GeoPoint(it.latitude, it.longitude) }
+            }
+        overlays.add(polygon)
+        invalidate()
+        val tileCount: Int =
+            CacheManager(this)
+                .possibleTilesInArea(downloadRegionBoundingBox, zoomLevelMin.toInt(), zoomLevelMax.toInt())
+        cacheEstimate = context.getString(R.string.map_cache_tiles, tileCount)
+    }
+
+    val boxOverlayListener =
+        object : MapListener {
+            override fun onScroll(event: ScrollEvent): Boolean {
+                if (downloadRegionBoundingBox != null) {
+                    event.source.generateBoxOverlay()
+                }
+                return true
+            }
+
+            override fun onZoom(event: ZoomEvent): Boolean = false
+        }
+
+    fun startDownload() {
+        val boundingBox = downloadRegionBoundingBox ?: return
+        try {
+            val outputName = buildString {
+                append(Configuration.getInstance().osmdroidBasePath.absolutePath)
+                append(File.separator)
+                append("mainFile.sqlite")
+            }
+            val writer = SqliteArchiveTileWriter(outputName)
+            val cacheManager = CacheManager(map, writer)
+            cacheManager.downloadAreaAsync(
+                context,
+                boundingBox,
+                zoomLevelMin.toInt(),
+                zoomLevelMax.toInt(),
+                cacheManagerCallback(
+                    onTaskComplete = {
+                        uiViewModel.showSnackBar(R.string.map_download_complete)
+                        writer.onDetach()
+                    },
+                    onTaskFailed = { errors ->
+                        uiViewModel.showSnackBar(context.getString(R.string.map_download_errors, errors))
+                        writer.onDetach()
+                    },
+                ),
+            )
+        } catch (ex: TileSourcePolicyException) {
+            debug("Tile source does not allow archiving: ${ex.message}")
+        } catch (ex: Exception) {
+            debug("Tile source exception: ${ex.message}")
+        }
+    }
+
+    fun showMapStyleDialog() {
+        val builder = MaterialAlertDialogBuilder(context)
+        val mapStyles: Array<CharSequence> = CustomTileSource.mTileSources.values.toTypedArray()
+
+        val mapStyleInt = mapViewModel.mapStyleId
+        builder.setSingleChoiceItems(mapStyles, mapStyleInt) { dialog, which ->
+            debug("Set mapStyleId pref to $which")
+            mapViewModel.mapStyleId = which
+            dialog.dismiss()
+            map.setTileSource(loadOnlineTileSourceBase())
+        }
+        val dialog = builder.create()
+        dialog.show()
+    }
+
+    fun Context.showCacheManagerDialog() {
+        MaterialAlertDialogBuilder(this)
+            .setTitle(R.string.map_offline_manager)
+            .setItems(
+                arrayOf<CharSequence>(
+                    getString(R.string.map_cache_size),
+                    getString(R.string.map_download_region),
+                    getString(R.string.map_clear_tiles),
+                    getString(R.string.cancel),
+                ),
+            ) { dialog, which ->
+                when (which) {
+                    0 -> showCurrentCacheInfo = true
+                    1 -> {
+                        map.generateBoxOverlay()
+                        dialog.dismiss()
+                    }
+
+                    2 -> purgeTileSource { uiViewModel.showSnackBar(it) }
+                    else -> dialog.dismiss()
+                }
+            }
+            .show()
+    }
+
+    Scaffold(
+        floatingActionButton = {
+            DownloadButton(showDownloadButton && downloadRegionBoundingBox == null) { context.showCacheManagerDialog() }
+        },
+    ) { innerPadding ->
+        Box(modifier = Modifier.fillMaxSize().padding(innerPadding)) {
+            AndroidView(
+                factory = {
+                    map.apply {
+                        setDestroyMode(false)
+                        addMapListener(boxOverlayListener)
+                    }
+                },
+                modifier = Modifier.fillMaxSize(),
+                update = { mapView -> mapView.drawOverlays() }, // Renamed map to mapView to avoid conflict
+            )
+            if (downloadRegionBoundingBox != null) {
+                CacheLayout(
+                    cacheEstimate = cacheEstimate,
+                    onExecuteJob = { startDownload() },
+                    onCancelDownload = {
+                        downloadRegionBoundingBox = null
+                        map.overlays.removeAll { it is Polygon }
+                        map.invalidate()
+                    },
+                    modifier = Modifier.align(Alignment.BottomCenter),
+                )
+            } else {
+                Column(
+                    modifier = Modifier.padding(top = 16.dp, end = 16.dp).align(Alignment.TopEnd),
+                    verticalArrangement = Arrangement.spacedBy(8.dp),
+                ) {
+                    MapButton(
+                        onClick = ::showMapStyleDialog,
+                        icon = Icons.Outlined.Layers,
+                        contentDescription = R.string.map_style_selection,
+                    )
+                    Box(modifier = Modifier) {
+                        MapButton(
+                            onClick = { mapFilterExpanded = true },
+                            icon = Icons.Outlined.Tune,
+                            contentDescription = R.string.map_filter,
+                        )
+                        DropdownMenu(
+                            expanded = mapFilterExpanded,
+                            onDismissRequest = { mapFilterExpanded = false },
+                            modifier = Modifier.background(MaterialTheme.colorScheme.surface),
+                        ) {
+                            DropdownMenuItem(
+                                text = {
+                                    Row(
+                                        modifier = Modifier.fillMaxWidth(),
+                                        verticalAlignment = Alignment.CenterVertically,
+                                    ) {
+                                        Icon(
+                                            imageVector = Icons.Default.Star,
+                                            contentDescription = null,
+                                            modifier = Modifier.padding(end = 8.dp),
+                                            tint = MaterialTheme.colorScheme.onSurface,
+                                        )
+                                        Text(
+                                            text = stringResource(R.string.only_favorites),
+                                            modifier = Modifier.weight(1f),
+                                        )
+                                        Checkbox(
+                                            checked = mapFilterState.onlyFavorites,
+                                            onCheckedChange = { mapViewModel.toggleOnlyFavorites() },
+                                            modifier = Modifier.padding(start = 8.dp),
+                                        )
+                                    }
+                                },
+                                onClick = { mapViewModel.toggleOnlyFavorites() },
+                            )
+                            DropdownMenuItem(
+                                text = {
+                                    Row(
+                                        modifier = Modifier.fillMaxWidth(),
+                                        verticalAlignment = Alignment.CenterVertically,
+                                    ) {
+                                        Icon(
+                                            imageVector = Icons.Default.PinDrop,
+                                            contentDescription = null,
+                                            modifier = Modifier.padding(end = 8.dp),
+                                            tint = MaterialTheme.colorScheme.onSurface,
+                                        )
+                                        Text(
+                                            text = stringResource(R.string.show_waypoints),
+                                            modifier = Modifier.weight(1f),
+                                        )
+                                        Checkbox(
+                                            checked = mapFilterState.showWaypoints,
+                                            onCheckedChange = { mapViewModel.toggleShowWaypointsOnMap() },
+                                            modifier = Modifier.padding(start = 8.dp),
+                                        )
+                                    }
+                                },
+                                onClick = { mapViewModel.toggleShowWaypointsOnMap() },
+                            )
+                            DropdownMenuItem(
+                                text = {
+                                    Row(
+                                        modifier = Modifier.fillMaxWidth(),
+                                        verticalAlignment = Alignment.CenterVertically,
+                                    ) {
+                                        Icon(
+                                            imageVector = Icons.Default.Lens,
+                                            contentDescription = null,
+                                            modifier = Modifier.padding(end = 8.dp),
+                                            tint = MaterialTheme.colorScheme.onSurface,
+                                        )
+                                        Text(
+                                            text = stringResource(R.string.show_precision_circle),
+                                            modifier = Modifier.weight(1f),
+                                        )
+                                        Checkbox(
+                                            checked = mapFilterState.showPrecisionCircle,
+                                            onCheckedChange = { mapViewModel.toggleShowPrecisionCircleOnMap() },
+                                            modifier = Modifier.padding(start = 8.dp),
+                                        )
+                                    }
+                                },
+                                onClick = { mapViewModel.toggleShowPrecisionCircleOnMap() },
+                            )
+                        }
+                    }
+                    if (hasGps) {
+                        MapButton(
+                            icon =
+                            if (myLocationOverlay == null) {
+                                Icons.Outlined.MyLocation
+                            } else {
+                                Icons.Default.LocationDisabled
+                            },
+                            contentDescription = stringResource(R.string.toggle_my_position),
+                        ) {
+                            if (locationPermissionsState.allPermissionsGranted) {
+                                map.toggleMyLocation()
+                            } else {
+                                triggerLocationToggleAfterPermission = true
+                                locationPermissionsState.launchMultiplePermissionRequest()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (showEditWaypointDialog != null) {
+        EditWaypointDialog(
+            waypoint = showEditWaypointDialog ?: return, // Safe call
+            onSendClicked = { waypoint ->
+                debug("User clicked send waypoint ${waypoint.id}")
+                showEditWaypointDialog = null
+                uiViewModel.sendWaypoint(
+                    waypoint.copy {
+                        if (id == 0) id = uiViewModel.generatePacketId() ?: return@EditWaypointDialog
+                        if (name == "") name = "Dropped Pin"
+                        if (expire == 0) expire = Int.MAX_VALUE
+                        lockedTo = if (waypoint.lockedTo != 0) uiViewModel.myNodeNum ?: 0 else 0
+                        if (waypoint.icon == 0) icon = 128205
+                    },
+                )
+            },
+            onDeleteClicked = { waypoint ->
+                debug("User clicked delete waypoint ${waypoint.id}")
+                showEditWaypointDialog = null
+                showDeleteMarkerDialog(waypoint)
+            },
+            onDismissRequest = {
+                debug("User clicked cancel marker edit dialog")
+                showEditWaypointDialog = null
+            },
+        )
+    }
+}

app/src/fdroid/java/com/geeksville/mesh/ui/map/MapViewModel.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.map
+
+import android.content.SharedPreferences
+import androidx.core.content.edit
+import com.geeksville.mesh.database.NodeRepository
+import com.geeksville.mesh.database.PacketRepository
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+
+@HiltViewModel
+class MapViewModel
+@Inject
+constructor(
+    preferences: SharedPreferences,
+    packetRepository: PacketRepository,
+    nodeRepository: NodeRepository,
+) : BaseMapViewModel(preferences, nodeRepository, packetRepository) {
+
+    var mapStyleId: Int
+        get() = preferences.getInt(MAP_STYLE_ID, 0)
+        set(value) = preferences.edit { putInt(MAP_STYLE_ID, value) }
+}

app/src/fdroid/java/com/geeksville/mesh/ui/map/MapViewWithLifecycle.kt

@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.map
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.PowerManager
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableDoubleStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.Saver
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import com.geeksville.mesh.BuildConfig
+import com.geeksville.mesh.android.BuildUtils.errormsg
+import com.geeksville.mesh.util.requiredZoomLevel
+import org.osmdroid.config.Configuration
+import org.osmdroid.tileprovider.tilesource.ITileSource
+import org.osmdroid.tileprovider.tilesource.TileSourceFactory
+import org.osmdroid.util.BoundingBox
+import org.osmdroid.util.GeoPoint
+import org.osmdroid.views.CustomZoomButtonsController
+import org.osmdroid.views.MapView
+
+@SuppressLint("WakelockTimeout")
+private fun PowerManager.WakeLock.safeAcquire() {
+    if (!isHeld) {
+        try {
+            acquire()
+        } catch (e: SecurityException) {
+            errormsg("WakeLock permission exception: ${e.message}")
+        } catch (e: IllegalStateException) {
+            errormsg("WakeLock acquire() exception: ${e.message}")
+        }
+    }
+}
+
+private fun PowerManager.WakeLock.safeRelease() {
+    if (isHeld) {
+        try {
+            release()
+        } catch (e: IllegalStateException) {
+            errormsg("WakeLock release() exception: ${e.message}")
+        }
+    }
+}
+
+private const val MIN_ZOOM_LEVEL = 1.5
+private const val MAX_ZOOM_LEVEL = 20.0
+private const val DEFAULT_ZOOM_LEVEL = 15.0
+
+@Suppress("MagicNumber")
+@Composable
+internal fun rememberMapViewWithLifecycle(
+    box: BoundingBox,
+    tileSource: ITileSource = TileSourceFactory.DEFAULT_TILE_SOURCE,
+): MapView {
+    val zoom =
+        if (box.requiredZoomLevel().isFinite()) {
+            (box.requiredZoomLevel() - 0.5).coerceAtLeast(MIN_ZOOM_LEVEL)
+        } else {
+            DEFAULT_ZOOM_LEVEL
+        }
+    val center = GeoPoint(box.centerLatitude, box.centerLongitude)
+    return rememberMapViewWithLifecycle(zoom, center, tileSource)
+}
+
+@Suppress("LongMethod")
+@Composable
+internal fun rememberMapViewWithLifecycle(
+    zoomLevel: Double = MIN_ZOOM_LEVEL,
+    mapCenter: GeoPoint = GeoPoint(0.0, 0.0),
+    tileSource: ITileSource = TileSourceFactory.DEFAULT_TILE_SOURCE,
+): MapView {
+    var savedZoom by rememberSaveable { mutableDoubleStateOf(zoomLevel) }
+    var savedCenter by
+        rememberSaveable(
+            stateSaver =
+            Saver(
+                save = { mapOf("latitude" to it.latitude, "longitude" to it.longitude) },
+                restore = { GeoPoint(it["latitude"] ?: 0.0, it["longitude"] ?: .0) },
+            ),
+        ) {
+            mutableStateOf(mapCenter)
+        }
+
+    val context = LocalContext.current
+    val mapView = remember {
+        MapView(context).apply {
+            clipToOutline = true
+
+            // Required to get online tiles
+            Configuration.getInstance().userAgentValue = BuildConfig.APPLICATION_ID
+            setTileSource(tileSource)
+            isVerticalMapRepetitionEnabled = false // disables map repetition
+            setMultiTouchControls(true)
+            val bounds = overlayManager.tilesOverlay.bounds // bounds scrollable map
+            setScrollableAreaLimitLatitude(bounds.actualNorth, bounds.actualSouth, 0)
+            // scales the map tiles to the display density of the screen
+            isTilesScaledToDpi = true
+            // sets the minimum zoom level (the furthest out you can zoom)
+            minZoomLevel = MIN_ZOOM_LEVEL
+            maxZoomLevel = MAX_ZOOM_LEVEL
+            // Disables default +/- button for zooming
+            zoomController.setVisibility(CustomZoomButtonsController.Visibility.SHOW_AND_FADEOUT)
+
+            controller.setZoom(savedZoom)
+            controller.setCenter(savedCenter)
+        }
+    }
+    val lifecycle = LocalLifecycleOwner.current.lifecycle
+    DisposableEffect(lifecycle) {
+        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+
+        @Suppress("DEPRECATION")
+        val wakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, "Meshtastic:MapViewLock")
+
+        wakeLock.safeAcquire()
+
+        val observer = LifecycleEventObserver { _, event ->
+            when (event) {
+                Lifecycle.Event.ON_PAUSE -> {
+                    wakeLock.safeRelease()
+                    mapView.onPause()
+                }
+
+                Lifecycle.Event.ON_RESUME -> {
+                    wakeLock.safeAcquire()
+                    mapView.onResume()
+                }
+
+                Lifecycle.Event.ON_STOP -> {
+                    savedCenter = mapView.projection.currentCenter
+                    savedZoom = mapView.zoomLevelDouble
+                }
+
+                else -> {}
+            }
+        }
+
+        lifecycle.addObserver(observer)
+
+        onDispose {
+            lifecycle.removeObserver(observer)
+            wakeLock.safeRelease()
+        }
+    }
+    return mapView
+}

app/src/fdroid/java/com/geeksville/mesh/ui/map/components/CacheLayout.kt

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.map.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.wrapContentHeight
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.geeksville.mesh.R
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+internal fun CacheLayout(
+    cacheEstimate: String,
+    onExecuteJob: () -> Unit,
+    onCancelDownload: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier =
+        modifier
+            .fillMaxWidth()
+            .wrapContentHeight()
+            .background(color = MaterialTheme.colorScheme.background)
+            .padding(8.dp),
+    ) {
+        Text(
+            text = stringResource(id = R.string.map_select_download_region),
+            modifier = Modifier.fillMaxWidth(),
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.headlineSmall,
+        )
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        Text(
+            text = stringResource(R.string.map_tile_download_estimate) + " " + cacheEstimate,
+            modifier = Modifier.fillMaxWidth(),
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.bodyLarge,
+        )
+
+        FlowRow(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp),
+            horizontalArrangement = Arrangement.spacedBy(space = 8.dp),
+        ) {
+            Button(onClick = onCancelDownload, modifier = Modifier.weight(1f)) {
+                Text(text = stringResource(id = R.string.cancel), color = MaterialTheme.colorScheme.onPrimary)
+            }
+            Button(onClick = onExecuteJob, modifier = Modifier.weight(1f)) {
+                Text(
+                    text = stringResource(id = R.string.map_start_download),
+                    color = MaterialTheme.colorScheme.onPrimary,
+                )
+            }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun CacheLayoutPreview() {
+    CacheLayout(cacheEstimate = "100 tiles", onExecuteJob = {}, onCancelDownload = {})
+}

app/src/fdroid/java/com/geeksville/mesh/ui/map/components/DownloadButton.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.map.components
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Download
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.res.stringResource
+import com.geeksville.mesh.R
+
+@Composable
+internal fun DownloadButton(enabled: Boolean, onClick: () -> Unit) {
+    AnimatedVisibility(
+        visible = enabled,
+        enter =
+        slideInHorizontally(
+            initialOffsetX = { it },
+            animationSpec = tween(durationMillis = 600, easing = FastOutSlowInEasing),
+        ),
+        exit =
+        slideOutHorizontally(
+            targetOffsetX = { it },
+            animationSpec = tween(durationMillis = 600, easing = FastOutSlowInEasing),
+        ),
+    ) {
+        FloatingActionButton(onClick = onClick, contentColor = MaterialTheme.colorScheme.primary) {
+            Icon(
+                imageVector = Icons.Default.Download,
+                contentDescription = stringResource(R.string.map_download_region),
+                modifier = Modifier.scale(1.25f),
+            )
+        }
+    }
+}
+
+// @Preview(showBackground = true)
+// @Composable
+// private fun DownloadButtonPreview() {
+//    DownloadButton(true, onClick = {})
+// }

app/src/fdroid/java/com/geeksville/mesh/ui/map/components/EditWaypointDialog.kt

@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.map.components
+
+import android.app.DatePickerDialog
+import android.widget.DatePicker
+import android.widget.TimePicker
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.wrapContentWidth
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material.icons.filled.Lock
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.geeksville.mesh.MeshProtos.Waypoint
+import com.geeksville.mesh.R
+import com.geeksville.mesh.copy
+import com.geeksville.mesh.ui.common.components.EditTextPreference
+import com.geeksville.mesh.ui.common.components.EmojiPickerDialog
+import com.geeksville.mesh.ui.common.theme.AppTheme
+import com.geeksville.mesh.waypoint
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Locale
+
+@Suppress("LongMethod")
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+internal fun EditWaypointDialog(
+    waypoint: Waypoint,
+    onSendClicked: (Waypoint) -> Unit,
+    onDeleteClicked: (Waypoint) -> Unit,
+    onDismissRequest: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var waypointInput by remember { mutableStateOf(waypoint) }
+    val title = if (waypoint.id == 0) R.string.waypoint_new else R.string.waypoint_edit
+
+    @Suppress("MagicNumber")
+    val emoji = if (waypointInput.icon == 0) 128205 else waypointInput.icon
+    var showEmojiPickerView by remember { mutableStateOf(false) }
+
+    // Get current context for dialogs
+    val context = LocalContext.current
+    val calendar = Calendar.getInstance()
+    val currentTime = System.currentTimeMillis()
+    calendar.timeInMillis = currentTime
+    @Suppress("MagicNumber")
+    calendar.add(Calendar.HOUR_OF_DAY, 8)
+
+    // Current time for initializing pickers
+    val year = calendar.get(Calendar.YEAR)
+    val month = calendar.get(Calendar.MONTH)
+    val day = calendar.get(Calendar.DAY_OF_MONTH)
+    val hour = calendar.get(Calendar.HOUR_OF_DAY)
+    val minute = calendar.get(Calendar.MINUTE)
+
+    // Determine locale-specific date format
+    val locale = Locale.getDefault()
+    val dateFormat =
+        if (locale.country == "US") {
+            SimpleDateFormat("MM/dd/yyyy", locale)
+        } else {
+            SimpleDateFormat("dd/MM/yyyy", locale)
+        }
+    // Check if 24-hour format is preferred
+    val is24Hour = android.text.format.DateFormat.is24HourFormat(context)
+    val timeFormat =
+        if (is24Hour) {
+            SimpleDateFormat("HH:mm", locale)
+        } else {
+            SimpleDateFormat("hh:mm a", locale)
+        }
+
+    // State to hold selected date and time
+    var selectedDate by remember { mutableStateOf(dateFormat.format(calendar.time)) }
+    var selectedTime by remember { mutableStateOf(timeFormat.format(calendar.time)) }
+    var epochTime by remember { mutableStateOf<Long?>(null) }
+
+    if (!showEmojiPickerView) {
+        AlertDialog(
+            onDismissRequest = onDismissRequest,
+            shape = RoundedCornerShape(16.dp),
+            text = {
+                Column(modifier = modifier.fillMaxWidth()) {
+                    Text(
+                        text = stringResource(title),
+                        style =
+                        MaterialTheme.typography.titleLarge.copy(
+                            fontWeight = FontWeight.Bold,
+                            textAlign = TextAlign.Center,
+                        ),
+                        modifier = Modifier.fillMaxWidth().padding(bottom = 16.dp),
+                    )
+                    EditTextPreference(
+                        title = stringResource(R.string.name),
+                        value = waypointInput.name,
+                        maxSize = 29,
+                        enabled = true,
+                        isError = false,
+                        keyboardOptions =
+                        KeyboardOptions.Default.copy(keyboardType = KeyboardType.Text, imeAction = ImeAction.Done),
+                        keyboardActions = KeyboardActions(onDone = {}),
+                        onValueChanged = { waypointInput = waypointInput.copy { name = it } },
+                        trailingIcon = {
+                            IconButton(onClick = { showEmojiPickerView = true }) {
+                                Text(
+                                    text = String(Character.toChars(emoji)),
+                                    modifier =
+                                    Modifier.background(MaterialTheme.colorScheme.background, CircleShape)
+                                        .padding(4.dp),
+                                    fontSize = 24.sp,
+                                    color = Color.Unspecified.copy(alpha = 1f),
+                                )
+                            }
+                        },
+                    )
+                    EditTextPreference(
+                        title = stringResource(R.string.description),
+                        value = waypointInput.description,
+                        maxSize = 99,
+                        enabled = true,
+                        isError = false,
+                        keyboardOptions =
+                        KeyboardOptions.Default.copy(keyboardType = KeyboardType.Text, imeAction = ImeAction.Done),
+                        keyboardActions = KeyboardActions(onDone = {}),
+                        onValueChanged = { waypointInput = waypointInput.copy { description = it } },
+                    )
+                    Row(
+                        modifier = Modifier.fillMaxWidth().size(48.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        Image(imageVector = Icons.Default.Lock, contentDescription = stringResource(R.string.locked))
+                        Text(stringResource(R.string.locked))
+                        Switch(
+                            modifier = Modifier.fillMaxWidth().wrapContentWidth(Alignment.End),
+                            checked = waypointInput.lockedTo != 0,
+                            onCheckedChange = { waypointInput = waypointInput.copy { lockedTo = if (it) 1 else 0 } },
+                        )
+                    }
+                    val datePickerDialog =
+                        DatePickerDialog(
+                            context,
+                            { _: DatePicker, selectedYear: Int, selectedMonth: Int, selectedDay: Int ->
+                                selectedDate = "$selectedDay/${selectedMonth + 1}/$selectedYear"
+                                calendar.set(selectedYear, selectedMonth, selectedDay)
+                                epochTime = calendar.timeInMillis
+                                if (epochTime != null) {
+                                    selectedDate = dateFormat.format(calendar.time)
+                                }
+                            },
+                            year,
+                            month,
+                            day,
+                        )
+
+                    val timePickerDialog =
+                        android.app.TimePickerDialog(
+                            context,
+                            { _: TimePicker, selectedHour: Int, selectedMinute: Int ->
+                                selectedTime =
+                                    String.format(Locale.getDefault(), "%02d:%02d", selectedHour, selectedMinute)
+                                calendar.set(Calendar.HOUR_OF_DAY, selectedHour)
+                                calendar.set(Calendar.MINUTE, selectedMinute)
+                                epochTime = calendar.timeInMillis
+                                selectedTime = timeFormat.format(calendar.time)
+                                @Suppress("MagicNumber")
+                                waypointInput = waypointInput.copy { expire = (epochTime!! / 1000).toInt() }
+                            },
+                            hour,
+                            minute,
+                            is24Hour,
+                        )
+
+                    Row(
+                        modifier = Modifier.fillMaxWidth().size(48.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        Image(
+                            imageVector = Icons.Default.CalendarMonth,
+                            contentDescription = stringResource(R.string.expires),
+                        )
+                        Text(stringResource(R.string.expires))
+                        Switch(
+                            modifier = Modifier.fillMaxWidth().wrapContentWidth(Alignment.End),
+                            checked = waypointInput.expire != Int.MAX_VALUE && waypointInput.expire != 0,
+                            onCheckedChange = { isChecked ->
+                                waypointInput =
+                                    waypointInput.copy {
+                                        expire =
+                                            if (isChecked) {
+                                                @Suppress("MagicNumber")
+                                                calendar.timeInMillis / 1000
+                                            } else {
+                                                Int.MAX_VALUE
+                                            }
+                                                .toInt()
+                                    }
+                                if (isChecked) {
+                                    selectedDate = dateFormat.format(calendar.time)
+                                    selectedTime = timeFormat.format(calendar.time)
+                                } else {
+                                    selectedDate = ""
+                                    selectedTime = ""
+                                }
+                            },
+                        )
+                    }
+
+                    if (waypointInput.expire != Int.MAX_VALUE && waypointInput.expire != 0) {
+                        Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterHorizontally),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                                Button(onClick = { datePickerDialog.show() }) { Text(stringResource(R.string.date)) }
+                                Text(
+                                    modifier = Modifier.padding(top = 4.dp),
+                                    text = "$selectedDate",
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    textAlign = TextAlign.Center,
+                                )
+                            }
+                            Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                                Button(onClick = { timePickerDialog.show() }) { Text(stringResource(R.string.time)) }
+                                Text(
+                                    modifier = Modifier.padding(top = 4.dp),
+                                    text = "$selectedTime",
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    textAlign = TextAlign.Center,
+                                )
+                            }
+                        }
+                    }
+                }
+            },
+            confirmButton = {
+                FlowRow(
+                    modifier = modifier.padding(start = 20.dp, end = 20.dp, bottom = 16.dp),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    verticalArrangement = Arrangement.Center,
+                ) {
+                    TextButton(modifier = modifier.weight(1f), onClick = onDismissRequest) {
+                        Text(stringResource(R.string.cancel))
+                    }
+                    if (waypoint.id != 0) {
+                        Button(
+                            modifier = modifier.weight(1f),
+                            onClick = { onDeleteClicked(waypointInput) },
+                            enabled = waypointInput.name.isNotEmpty(),
+                        ) {
+                            Text(stringResource(R.string.delete))
+                        }
+                    }
+                    Button(modifier = modifier.weight(1f), onClick = { onSendClicked(waypointInput) }, enabled = true) {
+                        Text(stringResource(R.string.send))
+                    }
+                }
+            },
+        )
+    } else {
+        EmojiPickerDialog(onDismiss = { showEmojiPickerView = false }) {
+            showEmojiPickerView = false
+            waypointInput = waypointInput.copy { icon = it.codePointAt(0) }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+@Suppress("MagicNumber")
+private fun EditWaypointFormPreview() {
+    AppTheme {
+        EditWaypointDialog(
+            waypoint =
+            waypoint {
+                id = 123
+                name = "Test 123"
+                description = "This is only a test"
+                icon = 128169
+                expire = (System.currentTimeMillis() / 1000 + 8 * 3600).toInt()
+            },
+            onSendClicked = {},
+            onDeleteClicked = {},
+            onDismissRequest = {},
+        )
+    }
+}

app/src/fdroid/java/com/geeksville/mesh/ui/map/components/MapButton.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.map.components
+
+import androidx.annotation.StringRes
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Layers
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.PreviewLightDark
+import androidx.compose.ui.unit.dp
+import com.geeksville.mesh.R
+import com.geeksville.mesh.ui.common.theme.AppTheme
+
+@Composable
+fun MapButton(
+    icon: ImageVector,
+    @StringRes contentDescription: Int,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit = {},
+) {
+    MapButton(
+        icon = icon,
+        contentDescription = stringResource(contentDescription),
+        modifier = modifier,
+        onClick = onClick,
+    )
+}
+
+@Composable
+fun MapButton(icon: ImageVector, contentDescription: String?, modifier: Modifier = Modifier, onClick: () -> Unit = {}) {
+    FloatingActionButton(onClick = onClick, modifier = modifier) {
+        Icon(imageVector = icon, contentDescription = contentDescription, modifier = Modifier.size(24.dp))
+    }
+}
+
+@PreviewLightDark
+@Composable
+private fun MapButtonPreview() {
+    AppTheme { MapButton(icon = Icons.Outlined.Layers, contentDescription = R.string.map_style_selection) }
+}

app/src/fdroid/java/com/geeksville/mesh/ui/node/NodeMap.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2025 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/>.
+ */
+
+package com.geeksville.mesh.ui.node
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.geeksville.mesh.model.MetricsViewModel
+import com.geeksville.mesh.model.UIViewModel
+import com.geeksville.mesh.ui.map.rememberMapViewWithLifecycle
+import com.geeksville.mesh.util.addCopyright
+import com.geeksville.mesh.util.addPolyline
+import com.geeksville.mesh.util.addPositionMarkers
+import com.geeksville.mesh.util.addScaleBarOverlay
+import org.osmdroid.util.BoundingBox
+import org.osmdroid.util.GeoPoint
+
+private const val DEG_D = 1e-7
+
+@Composable
+fun NodeMapScreen(
+    @Suppress("UNUSED_PARAMETER") uiViewModel: UIViewModel = hiltViewModel(),
+    viewModel: MetricsViewModel = hiltViewModel(),
+) {
+    val density = LocalDensity.current
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    val geoPoints = state.positionLogs.map { GeoPoint(it.latitudeI * DEG_D, it.longitudeI * DEG_D) }
+    val cameraView = remember { BoundingBox.fromGeoPoints(geoPoints) }
+    val mapView = rememberMapViewWithLifecycle(cameraView, viewModel.tileSource)
+
+    AndroidView(
+        modifier = Modifier.fillMaxSize(),
+        factory = { mapView },
+        update = { map ->
+            map.overlays.clear()
+            map.addCopyright()
+            map.addScaleBarOverlay(density)
+
+            map.addPolyline(density, geoPoints) {}
+            map.addPositionMarkers(state.positionLogs) {}
+        },
+    )
+}