feat: Migrate project to Kotlin Multiplatform (KMP) architecture (#4738)

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

app/src/google/AndroidManifest.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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/>.
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application>
+        <meta-data
+            android:name="com.google.android.geo.API_KEY"
+            android:value="${MAPS_API_KEY}" />
+    </application>
+
+</manifest>

app/src/google/kotlin/org/meshtastic/app/intro/AnalyticsIntro.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.intro
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.analytics_notice
+import org.meshtastic.core.resources.analytics_platforms
+import org.meshtastic.core.resources.datadog_link
+import org.meshtastic.core.resources.firebase_link
+import org.meshtastic.core.resources.for_more_information_see_our_privacy_policy
+import org.meshtastic.core.resources.privacy_url
+import org.meshtastic.core.ui.component.AutoLinkText
+
+@Composable
+fun AnalyticsIntro(modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier.fillMaxWidth().padding(top = 24.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        Text(
+            modifier = Modifier.fillMaxWidth(),
+            textAlign = TextAlign.Center,
+            text = stringResource(Res.string.analytics_notice),
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+        Text(
+            modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
+            textAlign = TextAlign.Center,
+            text = stringResource(Res.string.analytics_platforms),
+            style = MaterialTheme.typography.labelMedium,
+            color = MaterialTheme.colorScheme.onSurface,
+        )
+        AutoLinkText(
+            text = stringResource(Res.string.firebase_link),
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.fillMaxWidth(),
+            textAlign = TextAlign.Center,
+        )
+        AutoLinkText(
+            text = stringResource(Res.string.datadog_link),
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.fillMaxWidth(),
+            textAlign = TextAlign.Center,
+        )
+
+        Text(
+            modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
+            textAlign = TextAlign.Center,
+            text = stringResource(Res.string.for_more_information_see_our_privacy_policy),
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+        AutoLinkText(
+            text = stringResource(Res.string.privacy_url),
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.fillMaxWidth(),
+            textAlign = TextAlign.Center,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun AnalyticsIntroPreview() {
+    AnalyticsIntro()
+}

app/src/google/kotlin/org/meshtastic/app/map/GetMapViewProvider.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map
+
+import org.meshtastic.core.ui.util.MapViewProvider
+
+fun getMapViewProvider(): MapViewProvider = GoogleMapViewProvider()

app/src/google/kotlin/org/meshtastic/app/map/GoogleMapViewProvider.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import org.meshtastic.core.ui.util.MapViewProvider
+
+class GoogleMapViewProvider : MapViewProvider {
+    @Composable
+    override fun MapView(
+        modifier: Modifier,
+        viewModel: Any,
+        navigateToNodeDetails: (Int) -> Unit,
+        focusedNodeNum: Int?,
+        nodeTracks: List<Any>?,
+        tracerouteOverlay: Any?,
+        tracerouteNodePositions: Map<Int, Any>,
+        onTracerouteMappableCountChanged: (Int, Int) -> Unit,
+    ) {
+        val mapViewModel: MapViewModel = hiltViewModel()
+        org.meshtastic.app.map.MapView(
+            modifier = modifier,
+            mapViewModel = mapViewModel,
+            navigateToNodeDetails = navigateToNodeDetails,
+            focusedNodeNum = focusedNodeNum,
+            nodeTracks = nodeTracks as? List<org.meshtastic.proto.Position>,
+            tracerouteOverlay = tracerouteOverlay as? org.meshtastic.feature.map.model.TracerouteOverlay,
+            tracerouteNodePositions = tracerouteNodePositions as? Map<Int, org.meshtastic.proto.Position> ?: emptyMap(),
+            onTracerouteMappableCountChanged = onTracerouteMappableCountChanged,
+        )
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/LocationHandler.kt

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map
+
+import android.Manifest
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.pm.PackageManager
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.IntentSenderRequest
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.ContextCompat
+import co.touchlab.kermit.Logger
+import com.google.android.gms.common.api.ResolvableApiException
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.LocationSettingsRequest
+import com.google.android.gms.location.Priority
+
+private const val INTERVAL_MILLIS = 10000L
+
+@Suppress("LongMethod")
+@Composable
+fun LocationPermissionsHandler(onPermissionResult: (Boolean) -> Unit) {
+    val context = LocalContext.current
+    var localHasPermission by remember {
+        mutableStateOf(
+            ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) ==
+                PackageManager.PERMISSION_GRANTED,
+        )
+    }
+
+    val requestLocationPermissionLauncher =
+        rememberLauncherForActivityResult(contract = ActivityResultContracts.RequestPermission()) { isGranted ->
+            localHasPermission = isGranted
+            // Defer to the LaunchedEffect(localHasPermission) to check settings before confirming via
+            // onPermissionResult
+            // if permission is granted. If not granted, immediately report false.
+            if (!isGranted) {
+                onPermissionResult(false)
+            }
+        }
+
+    val locationSettingsLauncher =
+        rememberLauncherForActivityResult(contract = ActivityResultContracts.StartIntentSenderForResult()) { result ->
+            if (result.resultCode == Activity.RESULT_OK) {
+                Logger.d { "Location settings changed by user." }
+                // User has enabled location services or improved accuracy.
+                onPermissionResult(true) // Settings are now adequate, and permission was already granted.
+            } else {
+                Logger.d { "Location settings change cancelled by user." }
+                // User chose not to change settings. The permission itself is still granted,
+                // but the experience might be degraded. For the purpose of enabling map features,
+                // we consider this as success if the core permission is there.
+                // If stricter handling is needed (e.g., block feature if settings not optimal),
+                // this logic might change.
+                onPermissionResult(localHasPermission)
+            }
+        }
+
+    LaunchedEffect(Unit) {
+        // Initial permission check
+        when (ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION)) {
+            PackageManager.PERMISSION_GRANTED -> {
+                if (!localHasPermission) {
+                    localHasPermission = true
+                }
+                // If permission is already granted, proceed to check location settings.
+                // The LaunchedEffect(localHasPermission) will handle this.
+                // No need to call onPermissionResult(true) here yet, let settings check complete.
+            }
+
+            else -> {
+                // Request permission if not granted. The launcher's callback will update localHasPermission.
+                requestLocationPermissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION)
+            }
+        }
+    }
+
+    LaunchedEffect(localHasPermission) {
+        // Handles logic after permission status is known/updated
+        if (localHasPermission) {
+            // Permission is granted, now check location settings
+            val locationRequest = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, INTERVAL_MILLIS).build()
+
+            val builder = LocationSettingsRequest.Builder().addLocationRequest(locationRequest)
+
+            val client = LocationServices.getSettingsClient(context)
+            val task = client.checkLocationSettings(builder.build())
+
+            task.addOnSuccessListener {
+                Logger.d { "Location settings are satisfied." }
+                onPermissionResult(true) // Permission granted and settings are good
+            }
+
+            task.addOnFailureListener { exception ->
+                if (exception is ResolvableApiException) {
+                    try {
+                        val intentSenderRequest = IntentSenderRequest.Builder(exception.resolution).build()
+                        locationSettingsLauncher.launch(intentSenderRequest)
+                        // Result of this launch will be handled by locationSettingsLauncher's callback
+                    } catch (sendEx: ActivityNotFoundException) {
+                        Logger.d { "Error launching location settings resolution ${sendEx.message}." }
+                        onPermissionResult(true) // Permission is granted, but settings dialog failed. Proceed.
+                    }
+                } else {
+                    Logger.d { "Location settings are not satisfiable.${exception.message}" }
+                    onPermissionResult(true) // Permission is granted, but settings not ideal. Proceed.
+                }
+            }
+        } else {
+            // If permission is not granted, report false.
+            // This case is primarily handled by the requestLocationPermissionLauncher's callback
+            // if the initial state was denied, or if user denies it.
+            onPermissionResult(false)
+        }
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/MBTilesProvider.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map
+
+import android.database.sqlite.SQLiteDatabase
+import com.google.android.gms.maps.model.Tile
+import com.google.android.gms.maps.model.TileProvider
+import java.io.File
+
+class MBTilesProvider(private val file: File) :
+    TileProvider,
+    AutoCloseable {
+    private var database: SQLiteDatabase? = null
+
+    init {
+        openDatabase()
+    }
+
+    private fun openDatabase() {
+        if (database == null && file.exists()) {
+            database = SQLiteDatabase.openDatabase(file.absolutePath, null, SQLiteDatabase.OPEN_READONLY)
+        }
+    }
+
+    override fun getTile(x: Int, y: Int, zoom: Int): Tile? {
+        val db = database ?: return null
+
+        var tile: Tile? = null
+        // Convert Google Maps y coordinate to standard TMS y coordinate
+        val tmsY = (1 shl zoom) - 1 - y
+
+        val cursor =
+            db.rawQuery(
+                "SELECT tile_data FROM tiles WHERE zoom_level = ? AND tile_column = ? AND tile_row = ?",
+                arrayOf(zoom.toString(), x.toString(), tmsY.toString()),
+            )
+
+        if (cursor.moveToFirst()) {
+            val tileData = cursor.getBlob(0)
+            tile = Tile(256, 256, tileData)
+        }
+        cursor.close()
+
+        return tile ?: TileProvider.NO_TILE
+    }
+
+    override fun close() {
+        database?.close()
+        database = null
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/MapView.kt

@@ -0,0 +1,901 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.app.map
+
+import android.Manifest
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.net.Uri
+import android.view.WindowManager
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material.icons.rounded.TripOrigin
+import androidx.compose.material3.Card
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+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.unit.dp
+import androidx.core.graphics.createBitmap
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import co.touchlab.kermit.Logger
+import com.google.accompanist.permissions.ExperimentalPermissionsApi
+import com.google.accompanist.permissions.rememberMultiplePermissionsState
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.Priority
+import com.google.android.gms.maps.CameraUpdateFactory
+import com.google.android.gms.maps.model.BitmapDescriptor
+import com.google.android.gms.maps.model.BitmapDescriptorFactory
+import com.google.android.gms.maps.model.CameraPosition
+import com.google.android.gms.maps.model.JointType
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.LatLngBounds
+import com.google.maps.android.SphericalUtil
+import com.google.maps.android.compose.ComposeMapColorScheme
+import com.google.maps.android.compose.GoogleMap
+import com.google.maps.android.compose.MapEffect
+import com.google.maps.android.compose.MapProperties
+import com.google.maps.android.compose.MapType
+import com.google.maps.android.compose.MapUiSettings
+import com.google.maps.android.compose.MapsComposeExperimentalApi
+import com.google.maps.android.compose.MarkerComposable
+import com.google.maps.android.compose.MarkerInfoWindowComposable
+import com.google.maps.android.compose.Polyline
+import com.google.maps.android.compose.TileOverlay
+import com.google.maps.android.compose.rememberUpdatedMarkerState
+import com.google.maps.android.compose.widgets.ScaleBar
+import com.google.maps.android.data.geojson.GeoJsonLayer
+import com.google.maps.android.data.kml.KmlLayer
+import kotlinx.coroutines.launch
+import org.jetbrains.compose.resources.stringResource
+import org.json.JSONObject
+import org.meshtastic.app.map.component.ClusterItemsListDialog
+import org.meshtastic.app.map.component.CustomMapLayersSheet
+import org.meshtastic.app.map.component.CustomTileProviderManagerSheet
+import org.meshtastic.app.map.component.EditWaypointDialog
+import org.meshtastic.app.map.component.MapControlsOverlay
+import org.meshtastic.app.map.component.NodeClusterMarkers
+import org.meshtastic.app.map.component.WaypointMarkers
+import org.meshtastic.app.map.model.NodeClusterItem
+import org.meshtastic.core.common.util.nowMillis
+import org.meshtastic.core.common.util.nowSeconds
+import org.meshtastic.core.model.Node
+import org.meshtastic.core.model.util.metersIn
+import org.meshtastic.core.model.util.mpsToKmph
+import org.meshtastic.core.model.util.mpsToMph
+import org.meshtastic.core.model.util.toString
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.alt
+import org.meshtastic.core.resources.heading
+import org.meshtastic.core.resources.latitude
+import org.meshtastic.core.resources.longitude
+import org.meshtastic.core.resources.position
+import org.meshtastic.core.resources.sats
+import org.meshtastic.core.resources.speed
+import org.meshtastic.core.resources.timestamp
+import org.meshtastic.core.resources.track_point
+import org.meshtastic.core.ui.component.NodeChip
+import org.meshtastic.core.ui.theme.TracerouteColors
+import org.meshtastic.core.ui.util.formatAgo
+import org.meshtastic.core.ui.util.formatPositionTime
+import org.meshtastic.feature.map.LastHeardFilter
+import org.meshtastic.feature.map.model.TracerouteOverlay
+import org.meshtastic.feature.map.tracerouteNodeSelection
+import org.meshtastic.proto.Config.DisplayConfig.DisplayUnits
+import org.meshtastic.proto.Position
+import org.meshtastic.proto.Waypoint
+import kotlin.math.abs
+import kotlin.math.max
+
+private const val MIN_TRACK_POINT_DISTANCE_METERS = 20f
+private const val DEG_D = 1e-7
+private const val HEADING_DEG = 1e-5
+private const val TRACEROUTE_OFFSET_METERS = 100.0
+private const val TRACEROUTE_BOUNDS_PADDING_PX = 120
+
+@Suppress("CyclomaticComplexMethod", "LongMethod")
+@OptIn(
+    MapsComposeExperimentalApi::class,
+    ExperimentalMaterial3Api::class,
+    ExperimentalMaterial3ExpressiveApi::class,
+    ExperimentalPermissionsApi::class,
+)
+@Composable
+fun MapView(
+    modifier: Modifier = Modifier,
+    mapViewModel: MapViewModel = hiltViewModel(),
+    navigateToNodeDetails: (Int) -> Unit,
+    focusedNodeNum: Int? = null,
+    nodeTracks: List<Position>? = null,
+    tracerouteOverlay: TracerouteOverlay? = null,
+    tracerouteNodePositions: Map<Int, Position> = emptyMap(),
+    onTracerouteMappableCountChanged: (shown: Int, total: Int) -> Unit = { _, _ -> },
+) {
+    val context = LocalContext.current
+    val coroutineScope = rememberCoroutineScope()
+    val mapLayers by mapViewModel.mapLayers.collectAsStateWithLifecycle()
+    val displayUnits by mapViewModel.displayUnits.collectAsStateWithLifecycle()
+
+    // Location permissions state
+    val locationPermissionsState =
+        rememberMultiplePermissionsState(permissions = listOf(Manifest.permission.ACCESS_FINE_LOCATION))
+    var triggerLocationToggleAfterPermission by remember { mutableStateOf(false) }
+
+    // Location tracking state
+    var isLocationTrackingEnabled by remember { mutableStateOf(false) }
+    var followPhoneBearing by remember { mutableStateOf(false) }
+
+    // Effect to toggle location tracking after permission is granted
+    LaunchedEffect(locationPermissionsState.allPermissionsGranted) {
+        if (locationPermissionsState.allPermissionsGranted && triggerLocationToggleAfterPermission) {
+            isLocationTrackingEnabled = true
+            triggerLocationToggleAfterPermission = false
+        }
+    }
+
+    val filePickerLauncher =
+        rememberLauncherForActivityResult(contract = ActivityResultContracts.StartActivityForResult()) { result ->
+            if (result.resultCode == android.app.Activity.RESULT_OK) {
+                result.data?.data?.let { uri ->
+                    val fileName = uri.getFileName(context)
+                    mapViewModel.addMapLayer(uri, fileName)
+                }
+            }
+        }
+
+    var mapFilterMenuExpanded by remember { mutableStateOf(false) }
+    val mapFilterState by mapViewModel.mapFilterStateFlow.collectAsStateWithLifecycle()
+    val ourNodeInfo by mapViewModel.ourNodeInfo.collectAsStateWithLifecycle()
+    var editingWaypoint by remember { mutableStateOf<Waypoint?>(null) }
+
+    val selectedGoogleMapType by mapViewModel.selectedGoogleMapType.collectAsStateWithLifecycle()
+    val currentCustomTileProviderUrl by mapViewModel.selectedCustomTileProviderUrl.collectAsStateWithLifecycle()
+
+    var mapTypeMenuExpanded by remember { mutableStateOf(false) }
+    var showCustomTileManagerSheet by remember { mutableStateOf(false) }
+
+    val cameraPositionState = mapViewModel.cameraPositionState
+
+    // Save camera position when it stops moving
+    LaunchedEffect(cameraPositionState.isMoving) {
+        if (!cameraPositionState.isMoving) {
+            mapViewModel.saveCameraPosition(cameraPositionState.position)
+        }
+    }
+
+    // Location tracking functionality
+    val fusedLocationClient = remember { LocationServices.getFusedLocationProviderClient(context) }
+    val locationCallback = remember {
+        object : LocationCallback() {
+            override fun onLocationResult(locationResult: LocationResult) {
+                if (isLocationTrackingEnabled) {
+                    locationResult.lastLocation?.let { location ->
+                        val latLng = LatLng(location.latitude, location.longitude)
+                        val cameraUpdate =
+                            if (followPhoneBearing) {
+                                val bearing =
+                                    if (location.hasBearing()) {
+                                        location.bearing
+                                    } else {
+                                        cameraPositionState.position.bearing
+                                    }
+                                CameraUpdateFactory.newCameraPosition(
+                                    CameraPosition.Builder()
+                                        .target(latLng)
+                                        .zoom(cameraPositionState.position.zoom)
+                                        .bearing(bearing)
+                                        .build(),
+                                )
+                            } else {
+                                CameraUpdateFactory.newLatLngZoom(latLng, cameraPositionState.position.zoom)
+                            }
+                        coroutineScope.launch {
+                            try {
+                                cameraPositionState.animate(cameraUpdate)
+                            } catch (e: IllegalStateException) {
+                                Logger.d { "Error animating camera to location: ${e.message}" }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Start/stop location tracking based on state
+    LaunchedEffect(isLocationTrackingEnabled, locationPermissionsState.allPermissionsGranted) {
+        if (isLocationTrackingEnabled && locationPermissionsState.allPermissionsGranted) {
+            val locationRequest =
+                LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 5000L)
+                    .setMinUpdateIntervalMillis(2000L)
+                    .build()
+
+            try {
+                @Suppress("MissingPermission")
+                fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, null)
+                Logger.d { "Started location tracking" }
+            } catch (e: SecurityException) {
+                Logger.d { "Location permission not available: ${e.message}" }
+                isLocationTrackingEnabled = false
+            }
+        } else {
+            fusedLocationClient.removeLocationUpdates(locationCallback)
+            Logger.d { "Stopped location tracking" }
+        }
+    }
+
+    DisposableEffect(Unit) { onDispose { fusedLocationClient.removeLocationUpdates(locationCallback) } }
+
+    val allNodes by mapViewModel.nodesWithPosition.collectAsStateWithLifecycle(listOf())
+    val waypoints by mapViewModel.waypoints.collectAsStateWithLifecycle(emptyMap())
+    val displayableWaypoints = waypoints.values.mapNotNull { it.waypoint }
+    val selectedWaypointId by mapViewModel.selectedWaypointId.collectAsStateWithLifecycle()
+
+    val tracerouteSelection =
+        remember(tracerouteOverlay, tracerouteNodePositions, allNodes) {
+            mapViewModel.tracerouteNodeSelection(
+                tracerouteOverlay = tracerouteOverlay,
+                tracerouteNodePositions = tracerouteNodePositions,
+                nodes = allNodes,
+            )
+        }
+
+    val filteredNodes =
+        allNodes
+            .filter { node -> !mapFilterState.onlyFavorites || node.isFavorite || node.num == ourNodeInfo?.num }
+            .filter { node ->
+                mapFilterState.lastHeardFilter.seconds == 0L ||
+                    (nowSeconds - node.lastHeard) <= mapFilterState.lastHeardFilter.seconds ||
+                    node.num == ourNodeInfo?.num
+            }
+
+    val displayNodes =
+        if (tracerouteOverlay != null) {
+            tracerouteSelection.nodesForMarkers
+        } else {
+            filteredNodes
+        }
+    LaunchedEffect(tracerouteOverlay, displayNodes) {
+        if (tracerouteOverlay != null) {
+            onTracerouteMappableCountChanged(displayNodes.size, tracerouteOverlay.relatedNodeNums.size)
+        }
+    }
+
+    val myNodeNum = mapViewModel.myNodeNum
+    val nodeClusterItems =
+        displayNodes.map { node ->
+            val latLng = LatLng((node.position.latitude_i ?: 0) * DEG_D, (node.position.longitude_i ?: 0) * DEG_D)
+            NodeClusterItem(
+                node = node,
+                nodePosition = latLng,
+                nodeTitle = "${node.user.short_name} ${formatAgo(node.position.time)}",
+                nodeSnippet = "${node.user.long_name}",
+                myNodeNum = myNodeNum,
+            )
+        }
+    val isConnected by mapViewModel.isConnected.collectAsStateWithLifecycle()
+    val theme by mapViewModel.theme.collectAsStateWithLifecycle()
+    val dark =
+        when (theme) {
+            AppCompatDelegate.MODE_NIGHT_YES -> true
+            AppCompatDelegate.MODE_NIGHT_NO -> false
+            AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM -> isSystemInDarkTheme()
+            else -> isSystemInDarkTheme()
+        }
+    val mapColorScheme =
+        when (dark) {
+            true -> ComposeMapColorScheme.DARK
+            else -> ComposeMapColorScheme.LIGHT
+        }
+    val tracerouteForwardPoints =
+        remember(tracerouteOverlay, displayNodes) {
+            val nodeLookup = displayNodes.associateBy { it.num }
+            tracerouteOverlay?.forwardRoute?.mapNotNull { nodeLookup[it]?.toLatLng() } ?: emptyList()
+        }
+    val tracerouteReturnPoints =
+        remember(tracerouteOverlay, displayNodes) {
+            val nodeLookup = displayNodes.associateBy { it.num }
+            tracerouteOverlay?.returnRoute?.mapNotNull { nodeLookup[it]?.toLatLng() } ?: emptyList()
+        }
+    val tracerouteHeadingReferencePoints =
+        remember(tracerouteForwardPoints, tracerouteReturnPoints) {
+            when {
+                tracerouteForwardPoints.size >= 2 -> tracerouteForwardPoints
+                tracerouteReturnPoints.size >= 2 -> tracerouteReturnPoints
+                else -> emptyList()
+            }
+        }
+    val tracerouteForwardOffsetPoints =
+        remember(tracerouteForwardPoints, tracerouteHeadingReferencePoints) {
+            offsetPolyline(
+                points = tracerouteForwardPoints,
+                offsetMeters = TRACEROUTE_OFFSET_METERS,
+                headingReferencePoints = tracerouteHeadingReferencePoints,
+                sideMultiplier = 1.0,
+            )
+        }
+    val tracerouteReturnOffsetPoints =
+        remember(tracerouteReturnPoints, tracerouteHeadingReferencePoints) {
+            offsetPolyline(
+                points = tracerouteReturnPoints,
+                offsetMeters = TRACEROUTE_OFFSET_METERS,
+                headingReferencePoints = tracerouteHeadingReferencePoints,
+                sideMultiplier = -1.0,
+            )
+        }
+    var hasCenteredTraceroute by remember(tracerouteOverlay) { mutableStateOf(false) }
+
+    var showLayersBottomSheet by remember { mutableStateOf(false) }
+
+    val onAddLayerClicked = {
+        val intent =
+            Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+                addCategory(Intent.CATEGORY_OPENABLE)
+                type = "*/*"
+                val mimeTypes =
+                    arrayOf(
+                        "application/vnd.google-earth.kml+xml",
+                        "application/vnd.google-earth.kmz",
+                        "application/vnd.geo+json",
+                        "application/geo+json",
+                        "application/json",
+                    )
+                putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes)
+            }
+        filePickerLauncher.launch(intent)
+    }
+    val onRemoveLayer = { layerId: String -> mapViewModel.removeMapLayer(layerId) }
+    val onToggleVisibility = { layerId: String -> mapViewModel.toggleLayerVisibility(layerId) }
+
+    val effectiveGoogleMapType =
+        if (currentCustomTileProviderUrl != null) {
+            MapType.NONE
+        } else {
+            selectedGoogleMapType
+        }
+
+    var showClusterItemsDialog by remember { mutableStateOf<List<NodeClusterItem>?>(null) }
+
+    LaunchedEffect(isLocationTrackingEnabled) {
+        val activity = context as? Activity ?: return@LaunchedEffect
+        val window = activity.window
+
+        if (isLocationTrackingEnabled) {
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        } else {
+            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        }
+    }
+    LaunchedEffect(tracerouteOverlay, tracerouteForwardPoints, tracerouteReturnPoints) {
+        if (tracerouteOverlay == null || hasCenteredTraceroute) return@LaunchedEffect
+        val allPoints = (tracerouteForwardPoints + tracerouteReturnPoints).distinct()
+        if (allPoints.isNotEmpty()) {
+            val cameraUpdate =
+                if (allPoints.size == 1) {
+                    CameraUpdateFactory.newLatLngZoom(allPoints.first(), max(cameraPositionState.position.zoom, 12f))
+                } else {
+                    val bounds = LatLngBounds.builder()
+                    allPoints.forEach { bounds.include(it) }
+                    CameraUpdateFactory.newLatLngBounds(bounds.build(), TRACEROUTE_BOUNDS_PADDING_PX)
+                }
+            try {
+                cameraPositionState.animate(cameraUpdate)
+                hasCenteredTraceroute = true
+            } catch (e: IllegalStateException) {
+                Logger.d { "Error centering traceroute overlay: ${e.message}" }
+            }
+        }
+    }
+
+    Box(modifier = modifier) {
+        GoogleMap(
+            mapColorScheme = mapColorScheme,
+            modifier = Modifier.fillMaxSize(),
+            cameraPositionState = cameraPositionState,
+            uiSettings =
+            MapUiSettings(
+                zoomControlsEnabled = true,
+                mapToolbarEnabled = true,
+                compassEnabled = false,
+                myLocationButtonEnabled = false,
+                rotationGesturesEnabled = true,
+                scrollGesturesEnabled = true,
+                tiltGesturesEnabled = true,
+                zoomGesturesEnabled = true,
+            ),
+            properties =
+            MapProperties(
+                mapType = effectiveGoogleMapType,
+                isMyLocationEnabled = isLocationTrackingEnabled && locationPermissionsState.allPermissionsGranted,
+            ),
+            onMapLongClick = { latLng ->
+                if (isConnected) {
+                    val newWaypoint =
+                        Waypoint(
+                            latitude_i = (latLng.latitude / DEG_D).toInt(),
+                            longitude_i = (latLng.longitude / DEG_D).toInt(),
+                        )
+                    editingWaypoint = newWaypoint
+                }
+            },
+        ) {
+            key(currentCustomTileProviderUrl) {
+                currentCustomTileProviderUrl?.let { url ->
+                    val config =
+                        mapViewModel.customTileProviderConfigs.collectAsStateWithLifecycle().value.find {
+                            it.urlTemplate == url || it.localUri == url
+                        }
+                    mapViewModel.getTileProvider(config)?.let { tileProvider ->
+                        TileOverlay(tileProvider = tileProvider, fadeIn = true, transparency = 0f, zIndex = -1f)
+                    }
+                }
+            }
+
+            if (tracerouteForwardPoints.size >= 2) {
+                Polyline(
+                    points = tracerouteForwardOffsetPoints,
+                    jointType = JointType.ROUND,
+                    color = TracerouteColors.OutgoingRoute,
+                    width = 9f,
+                    zIndex = 3.0f,
+                )
+            }
+            if (tracerouteReturnPoints.size >= 2) {
+                Polyline(
+                    points = tracerouteReturnOffsetPoints,
+                    jointType = JointType.ROUND,
+                    color = TracerouteColors.ReturnRoute,
+                    width = 7f,
+                    zIndex = 2.5f,
+                )
+            }
+
+            if (nodeTracks != null && focusedNodeNum != null) {
+                val lastHeardTrackFilter = mapFilterState.lastHeardTrackFilter
+                val timeFilteredPositions =
+                    nodeTracks.filter {
+                        lastHeardTrackFilter == LastHeardFilter.Any ||
+                            it.time > nowSeconds - lastHeardTrackFilter.seconds
+                    }
+                val sortedPositions = timeFilteredPositions.sortedBy { it.time }
+                allNodes
+                    .find { it.num == focusedNodeNum }
+                    ?.let { focusedNode ->
+                        sortedPositions.forEachIndexed { index, position ->
+                            key(position.time) {
+                                val markerState = rememberUpdatedMarkerState(position = position.toLatLng())
+                                val alpha = (index.toFloat() / (sortedPositions.size.toFloat() - 1))
+                                val color = Color(focusedNode.colors.second).copy(alpha = alpha)
+                                val isHighPriority = focusedNode.num == myNodeNum || focusedNode.isFavorite
+                                val activeNodeZIndex = if (isHighPriority) 5f else 4f
+
+                                if (index == sortedPositions.lastIndex) {
+                                    MarkerComposable(
+                                        state = markerState,
+                                        zIndex = activeNodeZIndex,
+                                        alpha = if (isHighPriority) 1.0f else 0.9f,
+                                    ) {
+                                        NodeChip(node = focusedNode)
+                                    }
+                                } else {
+                                    MarkerInfoWindowComposable(
+                                        state = markerState,
+                                        title = stringResource(Res.string.position),
+                                        snippet = formatAgo(position.time),
+                                        zIndex = 1f + alpha,
+                                        infoContent = {
+                                            PositionInfoWindowContent(position = position, displayUnits = displayUnits)
+                                        },
+                                    ) {
+                                        Icon(
+                                            imageVector = androidx.compose.material.icons.Icons.Rounded.TripOrigin,
+                                            contentDescription = stringResource(Res.string.track_point),
+                                            tint = color,
+                                        )
+                                    }
+                                }
+                            }
+                        }
+
+                        if (sortedPositions.size > 1) {
+                            val segments = sortedPositions.windowed(size = 2, step = 1, partialWindows = false)
+                            segments.forEachIndexed { index, segmentPoints ->
+                                val alpha = (index.toFloat() / (segments.size.toFloat() - 1))
+                                Polyline(
+                                    points = segmentPoints.map { it.toLatLng() },
+                                    jointType = JointType.ROUND,
+                                    color = Color(focusedNode.colors.second).copy(alpha = alpha),
+                                    width = 8f,
+                                    zIndex = 0.6f,
+                                )
+                            }
+                        }
+                    }
+            } else {
+                NodeClusterMarkers(
+                    nodeClusterItems = nodeClusterItems,
+                    mapFilterState = mapFilterState,
+                    navigateToNodeDetails = navigateToNodeDetails,
+                    onClusterClick = { cluster ->
+                        val items = cluster.items.toList()
+                        val allSameLocation = items.size > 1 && items.all { it.position == items.first().position }
+
+                        if (allSameLocation) {
+                            showClusterItemsDialog = items
+                        } else {
+                            val bounds = LatLngBounds.builder()
+                            cluster.items.forEach { bounds.include(it.position) }
+                            coroutineScope.launch {
+                                cameraPositionState.animate(
+                                    CameraUpdateFactory.newCameraPosition(
+                                        CameraPosition.Builder()
+                                            .target(bounds.build().center)
+                                            .zoom(cameraPositionState.position.zoom + 1)
+                                            .build(),
+                                    ),
+                                )
+                            }
+                            Logger.d { "Cluster clicked! $cluster" }
+                        }
+                        true
+                    },
+                )
+            }
+
+            WaypointMarkers(
+                displayableWaypoints = displayableWaypoints,
+                mapFilterState = mapFilterState,
+                myNodeNum = mapViewModel.myNodeNum ?: 0,
+                isConnected = isConnected,
+                unicodeEmojiToBitmapProvider = ::unicodeEmojiToBitmap,
+                onEditWaypointRequest = { waypointToEdit -> editingWaypoint = waypointToEdit },
+                selectedWaypointId = selectedWaypointId,
+            )
+
+            mapLayers.forEach { layerItem -> key(layerItem.id) { MapLayerOverlay(layerItem, mapViewModel) } }
+        }
+
+        ScaleBar(
+            cameraPositionState = cameraPositionState,
+            modifier = Modifier.align(Alignment.BottomStart).padding(bottom = 48.dp),
+        )
+        editingWaypoint?.let { waypointToEdit ->
+            EditWaypointDialog(
+                waypoint = waypointToEdit,
+                onSendClicked = { updatedWp ->
+                    var finalWp = updatedWp
+                    if (updatedWp.id == 0) {
+                        finalWp = finalWp.copy(id = mapViewModel.generatePacketId() ?: 0)
+                    }
+                    if ((updatedWp.icon ?: 0) == 0) {
+                        finalWp = finalWp.copy(icon = 0x1F4CD)
+                    }
+
+                    mapViewModel.sendWaypoint(finalWp)
+                    editingWaypoint = null
+                },
+                onDeleteClicked = { wpToDelete ->
+                    if ((wpToDelete.locked_to ?: 0) == 0 && isConnected && wpToDelete.id != 0) {
+                        val deleteMarkerWp = wpToDelete.copy(expire = 1)
+                        mapViewModel.sendWaypoint(deleteMarkerWp)
+                    }
+                    mapViewModel.deleteWaypoint(wpToDelete.id)
+                    editingWaypoint = null
+                },
+                onDismissRequest = { editingWaypoint = null },
+            )
+        }
+
+        val visibleNetworkLayers = mapLayers.filter { it.isNetwork && it.isVisible }
+        val showRefresh = visibleNetworkLayers.isNotEmpty()
+        val isRefreshingLayers = visibleNetworkLayers.any { it.isRefreshing }
+
+        MapControlsOverlay(
+            modifier = Modifier.align(Alignment.TopCenter).padding(top = 8.dp),
+            mapFilterMenuExpanded = mapFilterMenuExpanded,
+            onMapFilterMenuDismissRequest = { mapFilterMenuExpanded = false },
+            onToggleMapFilterMenu = { mapFilterMenuExpanded = true },
+            mapViewModel = mapViewModel,
+            mapTypeMenuExpanded = mapTypeMenuExpanded,
+            onMapTypeMenuDismissRequest = { mapTypeMenuExpanded = false },
+            onToggleMapTypeMenu = { mapTypeMenuExpanded = true },
+            onManageLayersClicked = { showLayersBottomSheet = true },
+            onManageCustomTileProvidersClicked = {
+                mapTypeMenuExpanded = false
+                showCustomTileManagerSheet = true
+            },
+            isNodeMap = focusedNodeNum != null,
+            isLocationTrackingEnabled = isLocationTrackingEnabled,
+            onToggleLocationTracking = {
+                if (locationPermissionsState.allPermissionsGranted) {
+                    isLocationTrackingEnabled = !isLocationTrackingEnabled
+                    if (!isLocationTrackingEnabled) {
+                        followPhoneBearing = false
+                    }
+                } else {
+                    triggerLocationToggleAfterPermission = true
+                    locationPermissionsState.launchMultiplePermissionRequest()
+                }
+            },
+            bearing = cameraPositionState.position.bearing,
+            onCompassClick = {
+                if (isLocationTrackingEnabled) {
+                    followPhoneBearing = !followPhoneBearing
+                } else {
+                    coroutineScope.launch {
+                        try {
+                            val currentPosition = cameraPositionState.position
+                            val newCameraPosition = CameraPosition.Builder(currentPosition).bearing(0f).build()
+                            cameraPositionState.animate(CameraUpdateFactory.newCameraPosition(newCameraPosition))
+                            Logger.d { "Oriented map to north" }
+                        } catch (e: IllegalStateException) {
+                            Logger.d { "Error orienting map to north: ${e.message}" }
+                        }
+                    }
+                }
+            },
+            followPhoneBearing = followPhoneBearing,
+            showRefresh = showRefresh,
+            isRefreshing = isRefreshingLayers,
+            onRefresh = { mapViewModel.refreshAllVisibleNetworkLayers() },
+        )
+    }
+    if (showLayersBottomSheet) {
+        ModalBottomSheet(onDismissRequest = { showLayersBottomSheet = false }) {
+            CustomMapLayersSheet(
+                mapLayers = mapLayers,
+                onToggleVisibility = onToggleVisibility,
+                onRemoveLayer = onRemoveLayer,
+                onAddLayerClicked = onAddLayerClicked,
+                onRefreshLayer = { mapViewModel.refreshMapLayer(it) },
+                onAddNetworkLayer = { name, url -> mapViewModel.addNetworkMapLayer(name, url) },
+            )
+        }
+    }
+    showClusterItemsDialog?.let {
+        ClusterItemsListDialog(
+            items = it,
+            onDismiss = { showClusterItemsDialog = null },
+            onItemClick = { item ->
+                navigateToNodeDetails(item.node.num)
+                showClusterItemsDialog = null
+            },
+        )
+    }
+    if (showCustomTileManagerSheet) {
+        ModalBottomSheet(onDismissRequest = { showCustomTileManagerSheet = false }) {
+            CustomTileProviderManagerSheet(mapViewModel = mapViewModel)
+        }
+    }
+}
+
+@Composable
+private fun MapLayerOverlay(layerItem: MapLayerItem, mapViewModel: MapViewModel) {
+    val context = LocalContext.current
+    var currentLayer by remember { mutableStateOf<com.google.maps.android.data.Layer?>(null) }
+
+    MapEffect(layerItem.id, layerItem.isRefreshing) { map ->
+        val inputStream = mapViewModel.getInputStreamFromUri(layerItem) ?: return@MapEffect
+        val layer =
+            try {
+                when (layerItem.layerType) {
+                    LayerType.KML -> KmlLayer(map, inputStream, context)
+                    LayerType.GEOJSON ->
+                        GeoJsonLayer(map, JSONObject(inputStream.bufferedReader().use { it.readText() }))
+                }
+            } catch (e: Exception) {
+                Logger.withTag("MapView").e(e) { "Error loading map layer: ${layerItem.name}" }
+                null
+            }
+
+        layer?.let {
+            if (layerItem.isVisible) {
+                it.addLayerToMap()
+            }
+            currentLayer = it
+        }
+    }
+
+    DisposableEffect(layerItem.id) {
+        onDispose {
+            currentLayer?.removeLayerFromMap()
+            currentLayer = null
+        }
+    }
+
+    // Handle visibility changes without reloading the whole layer if possible,
+    // though KmlLayer.addLayerToMap() / removeLayerFromMap() is what we have.
+    LaunchedEffect(layerItem.isVisible) {
+        val layer = currentLayer ?: return@LaunchedEffect
+        if (layerItem.isVisible) {
+            if (!layer.isLayerOnMap) layer.addLayerToMap()
+        } else {
+            if (layer.isLayerOnMap) layer.removeLayerFromMap()
+        }
+    }
+}
+
+internal fun convertIntToEmoji(unicodeCodePoint: Int): String = try {
+    String(Character.toChars(unicodeCodePoint))
+} catch (e: IllegalArgumentException) {
+    Logger.w(e) { "Invalid unicode code point: $unicodeCodePoint" }
+    "\uD83D\uDCCD"
+}
+
+internal fun unicodeEmojiToBitmap(icon: Int): BitmapDescriptor {
+    val unicodeEmoji = convertIntToEmoji(icon)
+    val paint =
+        Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            textSize = 64f
+            color = android.graphics.Color.BLACK
+            textAlign = Paint.Align.CENTER
+        }
+
+    val baseline = -paint.ascent()
+    val width = (paint.measureText(unicodeEmoji) + 0.5f).toInt()
+    val height = (baseline + paint.descent() + 0.5f).toInt()
+    val image = createBitmap(width, height, android.graphics.Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(image)
+    canvas.drawText(unicodeEmoji, width / 2f, baseline, paint)
+
+    return BitmapDescriptorFactory.fromBitmap(image)
+}
+
+@Suppress("NestedBlockDepth")
+fun Uri.getFileName(context: android.content.Context): String {
+    var name = this.lastPathSegment ?: "layer_$nowMillis"
+    if (this.scheme == "content") {
+        context.contentResolver.query(this, null, null, null, null)?.use { cursor ->
+            if (cursor.moveToFirst()) {
+                val displayNameIndex = cursor.getColumnIndex(android.provider.OpenableColumns.DISPLAY_NAME)
+                if (displayNameIndex != -1) {
+                    name = cursor.getString(displayNameIndex)
+                }
+            }
+        }
+    }
+    return name
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+@Suppress("LongMethod")
+private fun PositionInfoWindowContent(position: Position, displayUnits: DisplayUnits = DisplayUnits.METRIC) {
+    @Composable
+    fun PositionRow(label: String, value: String) {
+        Row(modifier = Modifier.padding(horizontal = 8.dp), verticalAlignment = Alignment.CenterVertically) {
+            Text(label, style = MaterialTheme.typography.labelMedium)
+            Spacer(modifier = Modifier.width(16.dp))
+            Text(value, style = MaterialTheme.typography.labelMediumEmphasized)
+        }
+    }
+
+    Card {
+        Column(modifier = Modifier.padding(8.dp)) {
+            PositionRow(
+                label = stringResource(Res.string.latitude),
+                value = "%.5f".format((position.latitude_i ?: 0) * DEG_D),
+            )
+
+            PositionRow(
+                label = stringResource(Res.string.longitude),
+                value = "%.5f".format((position.longitude_i ?: 0) * DEG_D),
+            )
+
+            PositionRow(label = stringResource(Res.string.sats), value = position.sats_in_view?.toString() ?: "")
+
+            PositionRow(
+                label = stringResource(Res.string.alt),
+                value = (position.altitude ?: 0).metersIn(displayUnits).toString(displayUnits),
+            )
+
+            PositionRow(label = stringResource(Res.string.speed), value = speedFromPosition(position, displayUnits))
+
+            PositionRow(
+                label = stringResource(Res.string.heading),
+                value = "%.0f°".format((position.ground_track ?: 0) * HEADING_DEG),
+            )
+
+            PositionRow(label = stringResource(Res.string.timestamp), value = position.formatPositionTime())
+        }
+    }
+}
+
+@Composable
+private fun speedFromPosition(position: Position, displayUnits: DisplayUnits): String {
+    val speedInMps = position.ground_speed ?: 0
+    val mpsText = "%d m/s".format(speedInMps)
+    val speedText =
+        if (speedInMps > 10) {
+            when (displayUnits) {
+                DisplayUnits.METRIC -> "%.1f Km/h".format(speedInMps.mpsToKmph())
+                DisplayUnits.IMPERIAL -> "%.1f mph".format(speedInMps.mpsToMph())
+                else -> mpsText
+            }
+        } else {
+            mpsText
+        }
+    return speedText
+}
+
+internal fun Position.toLatLng(): LatLng = LatLng((this.latitude_i ?: 0) * DEG_D, (this.longitude_i ?: 0) * DEG_D)
+
+private fun Node.toLatLng(): LatLng? = this.position.toLatLng()
+
+private fun Waypoint.toLatLng(): LatLng = LatLng((this.latitude_i ?: 0) * DEG_D, (this.longitude_i ?: 0) * DEG_D)
+
+private fun offsetPolyline(
+    points: List<LatLng>,
+    offsetMeters: Double,
+    headingReferencePoints: List<LatLng> = points,
+    sideMultiplier: Double = 1.0,
+): List<LatLng> {
+    val headingPoints = headingReferencePoints.takeIf { it.size >= 2 } ?: points
+    if (points.size < 2 || headingPoints.size < 2 || offsetMeters == 0.0) return points
+
+    val headings =
+        headingPoints.mapIndexed { index, _ ->
+            when (index) {
+                0 -> SphericalUtil.computeHeading(headingPoints[0], headingPoints[1])
+                headingPoints.lastIndex ->
+                    SphericalUtil.computeHeading(
+                        headingPoints[headingPoints.lastIndex - 1],
+                        headingPoints[headingPoints.lastIndex],
+                    )
+
+                else -> SphericalUtil.computeHeading(headingPoints[index - 1], headingPoints[index + 1])
+            }
+        }
+
+    return points.mapIndexed { index, point ->
+        val heading = headings[index.coerceIn(0, headings.lastIndex)]
+        val perpendicularHeading = heading + (90.0 * sideMultiplier)
+        SphericalUtil.computeOffset(point, abs(offsetMeters), perpendicularHeading)
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/MapViewModel.kt

@@ -0,0 +1,666 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map
+
+import android.app.Application
+import android.net.Uri
+import androidx.core.net.toFile
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.viewModelScope
+import androidx.navigation.toRoute
+import co.touchlab.kermit.Logger
+import com.google.android.gms.maps.model.CameraPosition
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.TileProvider
+import com.google.android.gms.maps.model.UrlTileProvider
+import com.google.maps.android.compose.CameraPositionState
+import com.google.maps.android.compose.MapType
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.Serializable
+import org.meshtastic.app.map.model.CustomTileProviderConfig
+import org.meshtastic.app.map.prefs.map.GoogleMapsPrefs
+import org.meshtastic.app.map.repository.CustomTileProviderRepository
+import org.meshtastic.core.datastore.UiPreferencesDataSource
+import org.meshtastic.core.model.RadioController
+import org.meshtastic.core.navigation.MapRoutes
+import org.meshtastic.core.repository.MapPrefs
+import org.meshtastic.core.repository.NodeRepository
+import org.meshtastic.core.repository.PacketRepository
+import org.meshtastic.core.repository.RadioConfigRepository
+import org.meshtastic.core.ui.viewmodel.stateInWhileSubscribed
+import org.meshtastic.feature.map.BaseMapViewModel
+import org.meshtastic.proto.Config
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.InputStream
+import java.net.MalformedURLException
+import java.net.URL
+import javax.inject.Inject
+import kotlin.uuid.Uuid
+
+private const val TILE_SIZE = 256
+
+@Serializable
+data class MapCameraPosition(
+    val targetLat: Double,
+    val targetLng: Double,
+    val zoom: Float,
+    val tilt: Float,
+    val bearing: Float,
+)
+
+@Suppress("TooManyFunctions", "LongParameterList")
+@HiltViewModel
+class MapViewModel
+@Inject
+constructor(
+    private val application: Application,
+    mapPrefs: MapPrefs,
+    private val googleMapsPrefs: GoogleMapsPrefs,
+    nodeRepository: NodeRepository,
+    packetRepository: PacketRepository,
+    radioConfigRepository: RadioConfigRepository,
+    radioController: RadioController,
+    private val customTileProviderRepository: CustomTileProviderRepository,
+    uiPreferencesDataSource: UiPreferencesDataSource,
+    savedStateHandle: SavedStateHandle,
+) : BaseMapViewModel(mapPrefs, nodeRepository, packetRepository, radioController) {
+
+    private val _selectedWaypointId = MutableStateFlow(savedStateHandle.toRoute<MapRoutes.Map>().waypointId)
+    val selectedWaypointId: StateFlow<Int?> = _selectedWaypointId.asStateFlow()
+
+    private val targetLatLng =
+        googleMapsPrefs.cameraTargetLat.value
+            .takeIf { it != 0.0 }
+            ?.let { lat -> googleMapsPrefs.cameraTargetLng.value.takeIf { it != 0.0 }?.let { lng -> LatLng(lat, lng) } }
+            ?: ourNodeInfo.value?.position?.toLatLng()
+            ?: LatLng(0.0, 0.0)
+
+    val cameraPositionState =
+        CameraPositionState(
+            position =
+            CameraPosition(
+                targetLatLng,
+                googleMapsPrefs.cameraZoom.value,
+                googleMapsPrefs.cameraTilt.value,
+                googleMapsPrefs.cameraBearing.value,
+            ),
+        )
+
+    val theme: StateFlow<Int> = uiPreferencesDataSource.theme
+
+    private val _errorFlow = MutableSharedFlow<String>()
+    val errorFlow: SharedFlow<String> = _errorFlow.asSharedFlow()
+
+    val customTileProviderConfigs: StateFlow<List<CustomTileProviderConfig>> =
+        customTileProviderRepository.getCustomTileProviders().stateInWhileSubscribed(initialValue = emptyList())
+
+    private val _selectedCustomTileProviderUrl = MutableStateFlow<String?>(null)
+    val selectedCustomTileProviderUrl: StateFlow<String?> = _selectedCustomTileProviderUrl.asStateFlow()
+
+    private val _selectedGoogleMapType = MutableStateFlow(MapType.NORMAL)
+    val selectedGoogleMapType: StateFlow<MapType> = _selectedGoogleMapType.asStateFlow()
+
+    val displayUnits =
+        radioConfigRepository.deviceProfileFlow
+            .mapNotNull { it.config?.display?.units }
+            .stateInWhileSubscribed(initialValue = Config.DisplayConfig.DisplayUnits.METRIC)
+
+    fun addCustomTileProvider(name: String, urlTemplate: String, localUri: String? = null) {
+        viewModelScope.launch {
+            if (
+                name.isBlank() ||
+                (urlTemplate.isBlank() && localUri == null) ||
+                (localUri == null && !isValidTileUrlTemplate(urlTemplate))
+            ) {
+                _errorFlow.emit("Invalid name, URL template, or local URI for custom tile provider.")
+                return@launch
+            }
+            if (customTileProviderConfigs.value.any { it.name.equals(name, ignoreCase = true) }) {
+                _errorFlow.emit("Custom tile provider with name '$name' already exists.")
+                return@launch
+            }
+
+            var finalLocalUri = localUri
+            if (localUri != null) {
+                try {
+                    val uri = Uri.parse(localUri)
+                    val extension = "mbtiles"
+                    val finalFileName = "mbtiles_${Uuid.random()}.$extension"
+                    val copiedUri = copyFileToInternalStorage(uri, finalFileName)
+                    if (copiedUri != null) {
+                        finalLocalUri = copiedUri.toString()
+                    } else {
+                        _errorFlow.emit("Failed to copy MBTiles file to internal storage.")
+                        return@launch
+                    }
+                } catch (e: Exception) {
+                    Logger.withTag("MapViewModel").e(e) { "Error processing local URI" }
+                    _errorFlow.emit("Error processing local URI for MBTiles.")
+                    return@launch
+                }
+            }
+
+            val newConfig = CustomTileProviderConfig(name = name, urlTemplate = urlTemplate, localUri = finalLocalUri)
+            customTileProviderRepository.addCustomTileProvider(newConfig)
+        }
+    }
+
+    fun updateCustomTileProvider(configToUpdate: CustomTileProviderConfig) {
+        viewModelScope.launch {
+            if (
+                configToUpdate.name.isBlank() ||
+                (configToUpdate.urlTemplate.isBlank() && configToUpdate.localUri == null) ||
+                (configToUpdate.localUri == null && !isValidTileUrlTemplate(configToUpdate.urlTemplate))
+            ) {
+                _errorFlow.emit("Invalid name, URL template, or local URI for updating custom tile provider.")
+                return@launch
+            }
+            val existingConfigs = customTileProviderConfigs.value
+            if (
+                existingConfigs.any {
+                    it.id != configToUpdate.id && it.name.equals(configToUpdate.name, ignoreCase = true)
+                }
+            ) {
+                _errorFlow.emit("Another custom tile provider with name '${configToUpdate.name}' already exists.")
+                return@launch
+            }
+
+            customTileProviderRepository.updateCustomTileProvider(configToUpdate)
+
+            val originalConfig = customTileProviderRepository.getCustomTileProviderById(configToUpdate.id)
+            if (
+                _selectedCustomTileProviderUrl.value != null &&
+                originalConfig?.urlTemplate == _selectedCustomTileProviderUrl.value
+            ) {
+                // No change needed if URL didn't change, or handle if it did
+            } else if (originalConfig != null && _selectedCustomTileProviderUrl.value != originalConfig.urlTemplate) {
+                val currentlySelectedConfig =
+                    customTileProviderConfigs.value.find { it.urlTemplate == _selectedCustomTileProviderUrl.value }
+                if (currentlySelectedConfig?.id == configToUpdate.id) {
+                    _selectedCustomTileProviderUrl.value = configToUpdate.urlTemplate
+                }
+            }
+        }
+    }
+
+    fun removeCustomTileProvider(configId: String) {
+        viewModelScope.launch {
+            val configToRemove = customTileProviderRepository.getCustomTileProviderById(configId)
+            customTileProviderRepository.deleteCustomTileProvider(configId)
+
+            if (configToRemove != null) {
+                if (
+                    _selectedCustomTileProviderUrl.value == configToRemove.urlTemplate ||
+                    _selectedCustomTileProviderUrl.value == configToRemove.localUri
+                ) {
+                    _selectedCustomTileProviderUrl.value = null
+                    // Also clear from prefs
+                    googleMapsPrefs.setSelectedCustomTileUrl(null)
+                }
+
+                if (configToRemove.localUri != null) {
+                    val uri = Uri.parse(configToRemove.localUri)
+                    deleteFileToInternalStorage(uri)
+                }
+            }
+        }
+    }
+
+    fun selectCustomTileProvider(config: CustomTileProviderConfig?) {
+        if (config != null) {
+            if (!config.isLocal && !isValidTileUrlTemplate(config.urlTemplate)) {
+                Logger.withTag("MapViewModel").w("Attempted to select invalid URL template: ${config.urlTemplate}")
+                _selectedCustomTileProviderUrl.value = null
+                googleMapsPrefs.setSelectedCustomTileUrl(null)
+                return
+            }
+            // Use localUri if present, otherwise urlTemplate
+            val selectedUrl = config.localUri ?: config.urlTemplate
+            _selectedCustomTileProviderUrl.value = selectedUrl
+            _selectedGoogleMapType.value = MapType.NONE
+            googleMapsPrefs.setSelectedCustomTileUrl(selectedUrl)
+            googleMapsPrefs.setSelectedGoogleMapType(null)
+        } else {
+            _selectedCustomTileProviderUrl.value = null
+            _selectedGoogleMapType.value = MapType.NORMAL
+            googleMapsPrefs.setSelectedCustomTileUrl(null)
+            googleMapsPrefs.setSelectedGoogleMapType(MapType.NORMAL.name)
+        }
+    }
+
+    fun setSelectedGoogleMapType(mapType: MapType) {
+        _selectedGoogleMapType.value = mapType
+        _selectedCustomTileProviderUrl.value = null // Clear custom selection
+        googleMapsPrefs.setSelectedGoogleMapType(mapType.name)
+        googleMapsPrefs.setSelectedCustomTileUrl(null)
+    }
+
+    private var currentTileProvider: TileProvider? = null
+
+    fun getTileProvider(config: CustomTileProviderConfig?): TileProvider? {
+        if (config == null) {
+            (currentTileProvider as? MBTilesProvider)?.close()
+            currentTileProvider = null
+            return null
+        }
+
+        val selectedUrl = config.localUri ?: config.urlTemplate
+        if (currentTileProvider != null && _selectedCustomTileProviderUrl.value == selectedUrl) {
+            return currentTileProvider
+        }
+
+        // Close previous if it was a local provider
+        (currentTileProvider as? MBTilesProvider)?.close()
+
+        val newProvider =
+            if (config.isLocal) {
+                val uri = Uri.parse(config.localUri)
+                val file =
+                    try {
+                        uri.toFile()
+                    } catch (e: Exception) {
+                        File(uri.path ?: "")
+                    }
+                if (file.exists()) {
+                    MBTilesProvider(file)
+                } else {
+                    Logger.withTag("MapViewModel").e("Local MBTiles file does not exist: ${config.localUri}")
+                    null
+                }
+            } else {
+                val urlString = config.urlTemplate
+                if (!isValidTileUrlTemplate(urlString)) {
+                    Logger.withTag("MapViewModel")
+                        .e("Tile URL does not contain valid {x}, {y}, and {z} placeholders: $urlString")
+                    null
+                } else {
+                    object : UrlTileProvider(TILE_SIZE, TILE_SIZE) {
+                        override fun getTileUrl(x: Int, y: Int, zoom: Int): URL? {
+                            val subdomains = listOf("a", "b", "c")
+                            val subdomain = subdomains[(x + y) % subdomains.size]
+                            val formattedUrl =
+                                urlString
+                                    .replace("{s}", subdomain, ignoreCase = true)
+                                    .replace("{z}", zoom.toString(), ignoreCase = true)
+                                    .replace("{x}", x.toString(), ignoreCase = true)
+                                    .replace("{y}", y.toString(), ignoreCase = true)
+                            return try {
+                                URL(formattedUrl)
+                            } catch (e: MalformedURLException) {
+                                Logger.withTag("MapViewModel").e(e) { "Malformed URL: $formattedUrl" }
+                                null
+                            }
+                        }
+                    }
+                }
+            }
+
+        currentTileProvider = newProvider
+        return newProvider
+    }
+
+    private fun isValidTileUrlTemplate(urlTemplate: String): Boolean = urlTemplate.contains("{z}", ignoreCase = true) &&
+        urlTemplate.contains("{x}", ignoreCase = true) &&
+        urlTemplate.contains("{y}", ignoreCase = true)
+
+    private val _mapLayers = MutableStateFlow<List<MapLayerItem>>(emptyList())
+    val mapLayers: StateFlow<List<MapLayerItem>> = _mapLayers.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            customTileProviderRepository.getCustomTileProviders().first()
+            loadPersistedMapType()
+        }
+        loadPersistedLayers()
+
+        selectedWaypointId.value?.let { wpId ->
+            viewModelScope.launch {
+                val wpMap = waypoints.first { it.containsKey(wpId) }
+                wpMap[wpId]?.let { packet ->
+                    val waypoint = packet.waypoint!!
+                    val latLng = LatLng((waypoint.latitude_i ?: 0) / 1e7, (waypoint.longitude_i ?: 0) / 1e7)
+                    cameraPositionState.position = CameraPosition.fromLatLngZoom(latLng, 15f)
+                }
+            }
+        }
+    }
+
+    fun saveCameraPosition(cameraPosition: CameraPosition) {
+        viewModelScope.launch {
+            googleMapsPrefs.setCameraTargetLat(cameraPosition.target.latitude)
+            googleMapsPrefs.setCameraTargetLng(cameraPosition.target.longitude)
+            googleMapsPrefs.setCameraZoom(cameraPosition.zoom)
+            googleMapsPrefs.setCameraTilt(cameraPosition.tilt)
+            googleMapsPrefs.setCameraBearing(cameraPosition.bearing)
+        }
+    }
+
+    private fun loadPersistedMapType() {
+        val savedCustomUrl = googleMapsPrefs.selectedCustomTileUrl.value
+        if (savedCustomUrl != null) {
+            // Check if this custom provider still exists
+            if (
+                customTileProviderConfigs.value.any { it.urlTemplate == savedCustomUrl } &&
+                isValidTileUrlTemplate(savedCustomUrl)
+            ) {
+                _selectedCustomTileProviderUrl.value = savedCustomUrl
+                _selectedGoogleMapType.value =
+                    MapType.NONE // MapType.NONE to hide google basemap when using custom provider
+            } else {
+                // The saved custom URL is no longer valid or doesn't exist, remove preference
+                googleMapsPrefs.setSelectedCustomTileUrl(null)
+                // Fallback to default Google Map type
+                _selectedGoogleMapType.value = MapType.NORMAL
+            }
+        } else {
+            val savedGoogleMapTypeName = googleMapsPrefs.selectedGoogleMapType.value
+            try {
+                _selectedGoogleMapType.value = MapType.valueOf(savedGoogleMapTypeName ?: MapType.NORMAL.name)
+            } catch (e: IllegalArgumentException) {
+                Logger.e(e) { "Invalid saved Google Map type: $savedGoogleMapTypeName" }
+                _selectedGoogleMapType.value = MapType.NORMAL // Fallback in case of invalid stored name
+                googleMapsPrefs.setSelectedGoogleMapType(null)
+            }
+        }
+    }
+
+    private fun loadPersistedLayers() {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                val layersDir = File(application.filesDir, "map_layers")
+                if (layersDir.exists() && layersDir.isDirectory) {
+                    val persistedLayerFiles = layersDir.listFiles()
+
+                    if (persistedLayerFiles != null) {
+                        val hiddenLayerUrls = googleMapsPrefs.hiddenLayerUrls.value
+                        val loadedItems =
+                            persistedLayerFiles.mapNotNull { file ->
+                                if (file.isFile) {
+                                    val layerType =
+                                        when (file.extension.lowercase()) {
+                                            "kml",
+                                            "kmz",
+                                            -> LayerType.KML
+                                            "geojson",
+                                            "json",
+                                            -> LayerType.GEOJSON
+                                            else -> null
+                                        }
+
+                                    layerType?.let {
+                                        val uri = Uri.fromFile(file)
+                                        MapLayerItem(
+                                            name = file.nameWithoutExtension,
+                                            uri = uri,
+                                            isVisible = !hiddenLayerUrls.contains(uri.toString()),
+                                            layerType = it,
+                                        )
+                                    }
+                                } else {
+                                    null
+                                }
+                            }
+
+                        val networkItems =
+                            googleMapsPrefs.networkMapLayers.value.mapNotNull { networkString ->
+                                try {
+                                    val parts = networkString.split("|:|")
+                                    if (parts.size == 3) {
+                                        val id = parts[0]
+                                        val name = parts[1]
+                                        val uri = Uri.parse(parts[2])
+                                        MapLayerItem(
+                                            id = id,
+                                            name = name,
+                                            uri = uri,
+                                            isVisible = !hiddenLayerUrls.contains(uri.toString()),
+                                            layerType = LayerType.KML,
+                                            isNetwork = true,
+                                        )
+                                    } else {
+                                        null
+                                    }
+                                } catch (e: Exception) {
+                                    null
+                                }
+                            }
+
+                        _mapLayers.value = loadedItems + networkItems
+                        if (_mapLayers.value.isNotEmpty()) {
+                            Logger.withTag("MapViewModel").i("Loaded ${_mapLayers.value.size} persisted map layers.")
+                        }
+                    }
+                } else {
+                    Logger.withTag("MapViewModel").i("Map layers directory does not exist. No layers loaded.")
+                }
+            } catch (e: Exception) {
+                Logger.withTag("MapViewModel").e(e) { "Error loading persisted map layers" }
+                _mapLayers.value = emptyList()
+            }
+        }
+    }
+
+    fun addMapLayer(uri: Uri, fileName: String?) {
+        viewModelScope.launch {
+            val layerName = fileName?.substringBeforeLast('.') ?: "Layer ${mapLayers.value.size + 1}"
+
+            val extension =
+                fileName?.substringAfterLast('.', "")?.lowercase()
+                    ?: application.contentResolver.getType(uri)?.split('/')?.last()
+
+            val kmlExtensions = listOf("kml", "kmz", "vnd.google-earth.kml+xml", "vnd.google-earth.kmz")
+            val geoJsonExtensions = listOf("geojson", "json")
+
+            val layerType =
+                when (extension) {
+                    in kmlExtensions -> LayerType.KML
+                    in geoJsonExtensions -> LayerType.GEOJSON
+                    else -> null
+                }
+
+            if (layerType == null) {
+                Logger.withTag("MapViewModel").e("Unsupported map layer file type: $extension")
+                return@launch
+            }
+
+            val finalFileName =
+                if (fileName != null) {
+                    "$layerName.$extension"
+                } else {
+                    "layer_${Uuid.random()}.$extension"
+                }
+
+            val localFileUri = copyFileToInternalStorage(uri, finalFileName)
+
+            if (localFileUri != null) {
+                val newItem = MapLayerItem(name = layerName, uri = localFileUri, layerType = layerType)
+                _mapLayers.value = _mapLayers.value + newItem
+            } else {
+                Logger.withTag("MapViewModel").e("Failed to copy file to internal storage.")
+            }
+        }
+    }
+
+    fun addNetworkMapLayer(name: String, url: String) {
+        viewModelScope.launch {
+            if (name.isBlank() || url.isBlank()) {
+                _errorFlow.emit("Invalid name or URL for network layer.")
+                return@launch
+            }
+            try {
+                val uri = Uri.parse(url)
+                if (uri.scheme != "http" && uri.scheme != "https") {
+                    _errorFlow.emit("URL must be http or https.")
+                    return@launch
+                }
+
+                val path = uri.path?.lowercase() ?: ""
+                val layerType =
+                    when {
+                        path.endsWith(".geojson") || path.endsWith(".json") -> LayerType.GEOJSON
+                        else -> LayerType.KML // Default to KML
+                    }
+
+                val newItem = MapLayerItem(name = name, uri = uri, layerType = layerType, isNetwork = true)
+                _mapLayers.value = _mapLayers.value + newItem
+
+                val networkLayerString = "${newItem.id}|:|${newItem.name}|:|${newItem.uri}"
+                googleMapsPrefs.setNetworkMapLayers(googleMapsPrefs.networkMapLayers.value + networkLayerString)
+            } catch (e: Exception) {
+                _errorFlow.emit("Invalid URL.")
+            }
+        }
+    }
+
+    private suspend fun copyFileToInternalStorage(uri: Uri, fileName: String): Uri? = withContext(Dispatchers.IO) {
+        try {
+            val inputStream = application.contentResolver.openInputStream(uri)
+            val directory = File(application.filesDir, "map_layers")
+            if (!directory.exists()) {
+                directory.mkdirs()
+            }
+            val outputFile = File(directory, fileName)
+            val outputStream = FileOutputStream(outputFile)
+
+            inputStream?.use { input -> outputStream.use { output -> input.copyTo(output) } }
+            Uri.fromFile(outputFile)
+        } catch (e: IOException) {
+            Logger.withTag("MapViewModel").e(e) { "Error copying file to internal storage" }
+            null
+        }
+    }
+
+    fun toggleLayerVisibility(layerId: String) {
+        var toggledLayer: MapLayerItem? = null
+        val updatedLayers =
+            _mapLayers.value.map {
+                if (it.id == layerId) {
+                    toggledLayer = it.copy(isVisible = !it.isVisible)
+                    toggledLayer
+                } else {
+                    it
+                }
+            }
+        _mapLayers.value = updatedLayers
+
+        toggledLayer?.let {
+            if (it.isVisible) {
+                googleMapsPrefs.setHiddenLayerUrls(googleMapsPrefs.hiddenLayerUrls.value - it.uri.toString())
+            } else {
+                googleMapsPrefs.setHiddenLayerUrls(googleMapsPrefs.hiddenLayerUrls.value + it.uri.toString())
+            }
+        }
+    }
+
+    fun removeMapLayer(layerId: String) {
+        viewModelScope.launch {
+            val layerToRemove = _mapLayers.value.find { it.id == layerId }
+            layerToRemove?.uri?.let { uri ->
+                if (layerToRemove.isNetwork) {
+                    googleMapsPrefs.setNetworkMapLayers(
+                        googleMapsPrefs.networkMapLayers.value.filterNot { it.startsWith("$layerId|:|") }.toSet(),
+                    )
+                } else {
+                    deleteFileToInternalStorage(uri)
+                }
+                googleMapsPrefs.setHiddenLayerUrls(googleMapsPrefs.hiddenLayerUrls.value - uri.toString())
+            }
+            _mapLayers.value = _mapLayers.value.filterNot { it.id == layerId }
+        }
+    }
+
+    fun refreshMapLayer(layerId: String) {
+        viewModelScope.launch {
+            _mapLayers.update { layers -> layers.map { if (it.id == layerId) it.copy(isRefreshing = true) else it } }
+            // By resetting the layer data in the UI (implied by just refreshing),
+            // we trigger a reload in the Composable.
+            _mapLayers.update { layers -> layers.map { if (it.id == layerId) it.copy(isRefreshing = false) else it } }
+        }
+    }
+
+    fun refreshAllVisibleNetworkLayers() {
+        _mapLayers.value.filter { it.isNetwork && it.isVisible }.forEach { refreshMapLayer(it.id) }
+    }
+
+    private suspend fun deleteFileToInternalStorage(uri: Uri) {
+        withContext(Dispatchers.IO) {
+            try {
+                val file = uri.toFile()
+                if (file.exists()) {
+                    file.delete()
+                }
+            } catch (e: Exception) {
+                Logger.withTag("MapViewModel").e(e) { "Error deleting file from internal storage" }
+            }
+        }
+    }
+
+    @Suppress("Recycle")
+    suspend fun getInputStreamFromUri(layerItem: MapLayerItem): InputStream? {
+        val uriToLoad = layerItem.uri ?: return null
+        return withContext(Dispatchers.IO) {
+            try {
+                if (layerItem.isNetwork && (uriToLoad.scheme == "http" || uriToLoad.scheme == "https")) {
+                    val url = java.net.URL(uriToLoad.toString())
+                    java.io.BufferedInputStream(url.openStream())
+                } else {
+                    application.contentResolver.openInputStream(uriToLoad)
+                }
+            } catch (e: Exception) {
+                Logger.withTag("MapViewModel").e(e) { "Error opening InputStream from URI: $uriToLoad" }
+                null
+            }
+        }
+    }
+
+    override fun onCleared() {
+        super.onCleared()
+        (currentTileProvider as? MBTilesProvider)?.close()
+    }
+
+    override fun getUser(userId: String?) =
+        nodeRepository.getUser(userId ?: org.meshtastic.core.model.DataPacket.ID_BROADCAST)
+}
+
+enum class LayerType {
+    KML,
+    GEOJSON,
+}
+
+data class MapLayerItem(
+    val id: String = Uuid.random().toString(),
+    val name: String,
+    val uri: Uri? = null,
+    val isVisible: Boolean = true,
+    val layerType: LayerType,
+    val isNetwork: Boolean = false,
+    val isRefreshing: Boolean = false,
+)

app/src/google/kotlin/org/meshtastic/app/map/component/ClusterItemsListDialog.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.app.map.model.NodeClusterItem
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.nodes_at_this_location
+import org.meshtastic.core.resources.okay
+import org.meshtastic.core.ui.component.NodeChip
+
+@Composable
+fun ClusterItemsListDialog(
+    items: List<NodeClusterItem>,
+    onDismiss: () -> Unit,
+    onItemClick: (NodeClusterItem) -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(text = stringResource(Res.string.nodes_at_this_location)) },
+        text = {
+            // Use a LazyColumn for potentially long lists of items
+            LazyColumn(contentPadding = PaddingValues(vertical = 8.dp)) {
+                items(items, key = { it.node.num }) { item ->
+                    ClusterDialogListItem(item = item, onClick = { onItemClick(item) })
+                }
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(Res.string.okay)) } },
+    )
+}
+
+@Composable
+private fun ClusterDialogListItem(item: NodeClusterItem, onClick: () -> Unit, modifier: Modifier = Modifier) {
+    ListItem(
+        leadingContent = { NodeChip(node = item.node) },
+        headlineContent = { Text(item.nodeTitle) },
+        supportingContent = {
+            if (item.nodeSnippet.isNotBlank()) {
+                Text(item.nodeSnippet)
+            }
+        },
+        modifier =
+        modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 8.dp, vertical = 4.dp), // Add some padding around list items
+    )
+}

app/src/google/kotlin/org/meshtastic/app/map/component/CustomMapLayersSheet.kt

@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+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.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Visibility
+import androidx.compose.material.icons.filled.VisibilityOff
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+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.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.app.map.MapLayerItem
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.add_layer
+import org.meshtastic.core.resources.add_network_layer
+import org.meshtastic.core.resources.cancel
+import org.meshtastic.core.resources.hide_layer
+import org.meshtastic.core.resources.manage_map_layers
+import org.meshtastic.core.resources.map_layer_formats
+import org.meshtastic.core.resources.name
+import org.meshtastic.core.resources.network_layer_url_hint
+import org.meshtastic.core.resources.no_map_layers_loaded
+import org.meshtastic.core.resources.refresh
+import org.meshtastic.core.resources.remove_layer
+import org.meshtastic.core.resources.save
+import org.meshtastic.core.resources.show_layer
+import org.meshtastic.core.resources.url
+import org.meshtastic.core.ui.component.MeshtasticDialog
+
+@Suppress("LongMethod")
+@Composable
+@OptIn(ExperimentalMaterial3Api::class)
+fun CustomMapLayersSheet(
+    mapLayers: List<MapLayerItem>,
+    onToggleVisibility: (String) -> Unit,
+    onRemoveLayer: (String) -> Unit,
+    onAddLayerClicked: () -> Unit,
+    onRefreshLayer: (String) -> Unit,
+    onAddNetworkLayer: (String, String) -> Unit,
+) {
+    var showAddNetworkLayerDialog by remember { mutableStateOf(false) }
+    LazyColumn(contentPadding = PaddingValues(bottom = 16.dp)) {
+        item {
+            Text(
+                modifier = Modifier.padding(16.dp),
+                text = stringResource(Res.string.manage_map_layers),
+                style = MaterialTheme.typography.headlineSmall,
+            )
+            HorizontalDivider()
+        }
+        item {
+            Text(
+                modifier = Modifier.padding(start = 16.dp, end = 16.dp, top = 8.dp, bottom = 0.dp),
+                text = stringResource(Res.string.map_layer_formats),
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+
+        if (mapLayers.isEmpty()) {
+            item {
+                Text(
+                    modifier = Modifier.padding(16.dp),
+                    text = stringResource(Res.string.no_map_layers_loaded),
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+            }
+        } else {
+            items(mapLayers, key = { it.id }) { layer ->
+                ListItem(
+                    headlineContent = { Text(layer.name) },
+                    trailingContent = {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            if (layer.isNetwork) {
+                                if (layer.isRefreshing) {
+                                    CircularProgressIndicator(
+                                        modifier = Modifier.size(24.dp).padding(4.dp),
+                                        strokeWidth = 2.dp,
+                                    )
+                                } else {
+                                    IconButton(onClick = { onRefreshLayer(layer.id) }) {
+                                        Icon(
+                                            imageVector = Icons.Filled.Refresh,
+                                            contentDescription = stringResource(Res.string.refresh),
+                                        )
+                                    }
+                                }
+                            }
+                            IconButton(onClick = { onToggleVisibility(layer.id) }) {
+                                Icon(
+                                    imageVector =
+                                    if (layer.isVisible) {
+                                        Icons.Filled.Visibility
+                                    } else {
+                                        Icons.Filled.VisibilityOff
+                                    },
+                                    contentDescription =
+                                    stringResource(
+                                        if (layer.isVisible) {
+                                            Res.string.hide_layer
+                                        } else {
+                                            Res.string.show_layer
+                                        },
+                                    ),
+                                )
+                            }
+                            IconButton(onClick = { onRemoveLayer(layer.id) }) {
+                                Icon(
+                                    imageVector = Icons.Filled.Delete,
+                                    contentDescription = stringResource(Res.string.remove_layer),
+                                )
+                            }
+                        }
+                    },
+                )
+                HorizontalDivider()
+            }
+        }
+        item {
+            Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Button(modifier = Modifier.fillMaxWidth(), onClick = onAddLayerClicked) {
+                    Text(stringResource(Res.string.add_layer))
+                }
+                Button(modifier = Modifier.fillMaxWidth(), onClick = { showAddNetworkLayerDialog = true }) {
+                    Text(stringResource(Res.string.add_network_layer))
+                }
+            }
+        }
+    }
+
+    if (showAddNetworkLayerDialog) {
+        AddNetworkLayerDialog(
+            onDismiss = { showAddNetworkLayerDialog = false },
+            onConfirm = { name, url ->
+                onAddNetworkLayer(name, url)
+                showAddNetworkLayerDialog = false
+            },
+        )
+    }
+}
+
+@Composable
+fun AddNetworkLayerDialog(onDismiss: () -> Unit, onConfirm: (String, String) -> Unit) {
+    var name by remember { mutableStateOf("") }
+    var url by remember { mutableStateOf("") }
+
+    MeshtasticDialog(
+        onDismiss = onDismiss,
+        title = stringResource(Res.string.add_network_layer),
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedTextField(
+                    value = name,
+                    onValueChange = { name = it },
+                    label = { Text(stringResource(Res.string.name)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                OutlinedTextField(
+                    value = url,
+                    onValueChange = { url = it },
+                    label = { Text(stringResource(Res.string.url)) },
+                    placeholder = { Text(stringResource(Res.string.network_layer_url_hint)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            }
+        },
+        onConfirm = { onConfirm(name, url) },
+        confirmTextRes = Res.string.save,
+        dismissTextRes = Res.string.cancel,
+    )
+}

app/src/google/kotlin/org/meshtastic/app/map/component/CustomTileProviderManagerSheet.kt

@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import android.content.Intent
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material3.Button
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import kotlinx.coroutines.flow.collectLatest
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.app.map.MapViewModel
+import org.meshtastic.app.map.model.CustomTileProviderConfig
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.add_custom_tile_source
+import org.meshtastic.core.resources.add_local_mbtiles_file
+import org.meshtastic.core.resources.cancel
+import org.meshtastic.core.resources.delete_custom_tile_source
+import org.meshtastic.core.resources.edit_custom_tile_source
+import org.meshtastic.core.resources.local_mbtiles_file
+import org.meshtastic.core.resources.manage_custom_tile_sources
+import org.meshtastic.core.resources.name
+import org.meshtastic.core.resources.name_cannot_be_empty
+import org.meshtastic.core.resources.no_custom_tile_sources_found
+import org.meshtastic.core.resources.provider_name_exists
+import org.meshtastic.core.resources.save
+import org.meshtastic.core.resources.url_cannot_be_empty
+import org.meshtastic.core.resources.url_must_contain_placeholders
+import org.meshtastic.core.resources.url_template
+import org.meshtastic.core.resources.url_template_hint
+import org.meshtastic.core.ui.component.MeshtasticDialog
+import org.meshtastic.core.ui.util.showToast
+
+@Suppress("LongMethod")
+@Composable
+fun CustomTileProviderManagerSheet(mapViewModel: MapViewModel) {
+    val customTileProviders by mapViewModel.customTileProviderConfigs.collectAsStateWithLifecycle()
+    var editingConfig by remember { mutableStateOf<CustomTileProviderConfig?>(null) }
+    var showEditDialog by remember { mutableStateOf(false) }
+    val context = LocalContext.current
+
+    val mbtilesPickerLauncher =
+        rememberLauncherForActivityResult(contract = ActivityResultContracts.StartActivityForResult()) { result ->
+            if (result.resultCode == android.app.Activity.RESULT_OK) {
+                result.data?.data?.let { uri ->
+                    val fileName = uri.getFileName(context)
+                    val baseName = fileName.substringBeforeLast('.')
+                    mapViewModel.addCustomTileProvider(
+                        name = baseName,
+                        urlTemplate = "", // Empty for local
+                        localUri = uri.toString(),
+                    )
+                }
+            }
+        }
+
+    LaunchedEffect(Unit) { mapViewModel.errorFlow.collectLatest { errorMessage -> context.showToast(errorMessage) } }
+
+    if (showEditDialog) {
+        AddEditCustomTileProviderDialog(
+            config = editingConfig,
+            onDismiss = { showEditDialog = false },
+            onSave = { name, url ->
+                if (editingConfig == null) { // Adding new
+                    mapViewModel.addCustomTileProvider(name, url)
+                } else { // Editing existing
+                    mapViewModel.updateCustomTileProvider(editingConfig!!.copy(name = name, urlTemplate = url))
+                }
+                showEditDialog = false
+            },
+            mapViewModel = mapViewModel,
+        )
+    }
+
+    LazyColumn(contentPadding = PaddingValues(bottom = 16.dp)) {
+        item {
+            Text(
+                text = stringResource(Res.string.manage_custom_tile_sources),
+                style = MaterialTheme.typography.headlineSmall,
+                modifier = Modifier.padding(16.dp),
+            )
+            HorizontalDivider()
+        }
+
+        if (customTileProviders.isEmpty()) {
+            item {
+                Text(
+                    text = stringResource(Res.string.no_custom_tile_sources_found),
+                    modifier = Modifier.padding(16.dp),
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+            }
+        } else {
+            items(customTileProviders, key = { it.id }) { config ->
+                ListItem(
+                    headlineContent = { Text(config.name) },
+                    supportingContent = {
+                        if (config.isLocal) {
+                            Text(
+                                stringResource(Res.string.local_mbtiles_file),
+                                style = MaterialTheme.typography.bodySmall,
+                            )
+                        } else {
+                            Text(config.urlTemplate, style = MaterialTheme.typography.bodySmall)
+                        }
+                    },
+                    trailingContent = {
+                        Row {
+                            IconButton(
+                                onClick = {
+                                    editingConfig = config
+                                    showEditDialog = true
+                                },
+                            ) {
+                                Icon(
+                                    Icons.Filled.Edit,
+                                    contentDescription = stringResource(Res.string.edit_custom_tile_source),
+                                )
+                            }
+                            IconButton(onClick = { mapViewModel.removeCustomTileProvider(config.id) }) {
+                                Icon(
+                                    Icons.Filled.Delete,
+                                    contentDescription = stringResource(Res.string.delete_custom_tile_source),
+                                )
+                            }
+                        }
+                    },
+                )
+                HorizontalDivider()
+            }
+        }
+
+        item {
+            Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Button(
+                    onClick = {
+                        editingConfig = null
+                        showEditDialog = true
+                    },
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Text(stringResource(Res.string.add_custom_tile_source))
+                }
+
+                Button(
+                    onClick = {
+                        val intent =
+                            Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+                                addCategory(Intent.CATEGORY_OPENABLE)
+                                type = "*/*"
+                            }
+                        mbtilesPickerLauncher.launch(intent)
+                    },
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Text(stringResource(Res.string.add_local_mbtiles_file))
+                }
+            }
+        }
+    }
+}
+
+@Suppress("LongMethod")
+@Composable
+private fun AddEditCustomTileProviderDialog(
+    config: CustomTileProviderConfig?,
+    onDismiss: () -> Unit,
+    onSave: (String, String) -> Unit,
+    mapViewModel: MapViewModel,
+) {
+    var name by rememberSaveable { mutableStateOf(config?.name ?: "") }
+    var url by rememberSaveable { mutableStateOf(config?.urlTemplate ?: "") }
+    var nameError by remember { mutableStateOf<String?>(null) }
+    var urlError by remember { mutableStateOf<String?>(null) }
+    val customTileProviders by mapViewModel.customTileProviderConfigs.collectAsStateWithLifecycle()
+
+    val emptyNameError = stringResource(Res.string.name_cannot_be_empty)
+    val providerNameExistsError = stringResource(Res.string.provider_name_exists)
+    val urlCannotBeEmptyError = stringResource(Res.string.url_cannot_be_empty)
+    val urlMustContainPlaceholdersError = stringResource(Res.string.url_must_contain_placeholders)
+
+    fun validateAndSave() {
+        val currentNameError =
+            validateName(name, customTileProviders, config?.id, emptyNameError, providerNameExistsError)
+        val currentUrlError = validateUrl(url, urlCannotBeEmptyError, urlMustContainPlaceholdersError)
+
+        nameError = currentNameError
+        urlError = currentUrlError
+
+        if (currentNameError == null && currentUrlError == null) {
+            onSave(name, url)
+        }
+    }
+
+    MeshtasticDialog(
+        onDismiss = onDismiss,
+        title =
+        if (config == null) {
+            stringResource(Res.string.add_custom_tile_source)
+        } else {
+            stringResource(Res.string.edit_custom_tile_source)
+        },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedTextField(
+                    value = name,
+                    onValueChange = {
+                        name = it
+                        nameError = null
+                    },
+                    label = { Text(stringResource(Res.string.name)) },
+                    isError = nameError != null,
+                    supportingText = { nameError?.let { Text(it) } },
+                    singleLine = true,
+                )
+                OutlinedTextField(
+                    value = url,
+                    onValueChange = {
+                        url = it
+                        urlError = null
+                    },
+                    label = { Text(stringResource(Res.string.url_template)) },
+                    isError = urlError != null,
+                    supportingText = {
+                        if (urlError != null) {
+                            Text(urlError!!)
+                        } else {
+                            Text(stringResource(Res.string.url_template_hint))
+                        }
+                    },
+                    singleLine = false,
+                    maxLines = 2,
+                )
+            }
+        },
+        onConfirm = { validateAndSave() },
+        confirmTextRes = Res.string.save,
+        dismissTextRes = Res.string.cancel,
+    )
+}
+
+private fun validateName(
+    name: String,
+    providers: List<CustomTileProviderConfig>,
+    currentId: String?,
+    emptyNameError: String,
+    nameExistsError: String,
+): String? = if (name.isBlank()) {
+    emptyNameError
+} else if (providers.any { it.name.equals(name, ignoreCase = true) && it.id != currentId }) {
+    nameExistsError
+} else {
+    null
+}
+
+private fun validateUrl(url: String, emptyUrlError: String, mustContainPlaceholdersError: String): String? =
+    if (url.isBlank()) {
+        emptyUrlError
+    } else if (
+        !url.contains("{z}", ignoreCase = true) ||
+        !url.contains("{x}", ignoreCase = true) ||
+        !url.contains("{y}", ignoreCase = true)
+    ) {
+        mustContainPlaceholdersError
+    } else {
+        null
+    }
+
+private fun android.net.Uri.getFileName(context: android.content.Context): String {
+    var name = this.lastPathSegment ?: "mbtiles_file"
+    if (this.scheme == "content") {
+        context.contentResolver.query(this, null, null, null, null)?.use { cursor ->
+            if (cursor.moveToFirst()) {
+                val displayNameIndex = cursor.getColumnIndex(android.provider.OpenableColumns.DISPLAY_NAME)
+                if (displayNameIndex != -1) {
+                    name = cursor.getString(displayNameIndex)
+                }
+            }
+        }
+    }
+    return name
+}

app/src/google/kotlin/org/meshtastic/app/map/component/EditWaypointDialog.kt

@@ -0,0 +1,376 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import android.app.DatePickerDialog
+import android.app.TimePickerDialog
+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.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.CalendarMonth
+import androidx.compose.material.icons.rounded.Lock
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+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.platform.LocalContext
+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.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.Month
+import kotlinx.datetime.atTime
+import kotlinx.datetime.number
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.common.util.systemTimeZone
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.cancel
+import org.meshtastic.core.resources.date
+import org.meshtastic.core.resources.delete
+import org.meshtastic.core.resources.description
+import org.meshtastic.core.resources.expires
+import org.meshtastic.core.resources.locked
+import org.meshtastic.core.resources.name
+import org.meshtastic.core.resources.send
+import org.meshtastic.core.resources.time
+import org.meshtastic.core.resources.waypoint_edit
+import org.meshtastic.core.resources.waypoint_new
+import org.meshtastic.core.ui.emoji.EmojiPickerDialog
+import org.meshtastic.proto.Waypoint
+import kotlin.time.Duration.Companion.hours
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Suppress("LongMethod", "CyclomaticComplexMethod", "MagicNumber")
+@Composable
+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) Res.string.waypoint_new else Res.string.waypoint_edit
+    val defaultEmoji = 0x1F4CD // 📍 Round Pushpin
+    val currentEmojiCodepoint = if ((waypointInput.icon ?: 0) == 0) defaultEmoji else waypointInput.icon!!
+    var showEmojiPickerView by remember { mutableStateOf(false) }
+
+    val context = LocalContext.current
+    val tz = systemTimeZone
+
+    // Initialize date and time states from waypointInput.expire
+    var selectedDateString by remember { mutableStateOf("") }
+    var selectedTimeString by remember { mutableStateOf("") }
+    var isExpiryEnabled by remember {
+        mutableStateOf((waypointInput.expire ?: 0) != 0 && waypointInput.expire != Int.MAX_VALUE)
+    }
+
+    val dateFormat = remember { android.text.format.DateFormat.getDateFormat(context) }
+    val timeFormat = remember { android.text.format.DateFormat.getTimeFormat(context) }
+    dateFormat.timeZone = java.util.TimeZone.getDefault()
+    timeFormat.timeZone = java.util.TimeZone.getDefault()
+
+    LaunchedEffect(waypointInput.expire, isExpiryEnabled) {
+        val expireValue = waypointInput.expire ?: 0
+        if (isExpiryEnabled) {
+            if (expireValue != 0 && expireValue != Int.MAX_VALUE) {
+                val instant = Instant.fromEpochSeconds(expireValue.toLong())
+                val date = java.util.Date(instant.toEpochMilliseconds())
+                selectedDateString = dateFormat.format(date)
+                selectedTimeString = timeFormat.format(date)
+            } else { // If enabled but not set, default to 8 hours from now
+                val futureInstant = kotlinx.datetime.Clock.System.now() + 8.hours
+                val date = java.util.Date(futureInstant.toEpochMilliseconds())
+                selectedDateString = dateFormat.format(date)
+                selectedTimeString = timeFormat.format(date)
+                waypointInput = waypointInput.copy(expire = futureInstant.epochSeconds.toInt())
+            }
+        } else {
+            selectedDateString = ""
+            selectedTimeString = ""
+        }
+    }
+
+    if (!showEmojiPickerView) {
+        AlertDialog(
+            onDismissRequest = onDismissRequest,
+            title = {
+                Text(
+                    text = stringResource(title),
+                    style = MaterialTheme.typography.titleLarge.copy(fontWeight = FontWeight.Bold),
+                    textAlign = TextAlign.Center,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            },
+            text = {
+                Column(modifier = modifier.fillMaxWidth()) {
+                    OutlinedTextField(
+                        value = waypointInput.name ?: "",
+                        onValueChange = { waypointInput = waypointInput.copy(name = it.take(29)) },
+                        label = { Text(stringResource(Res.string.name)) },
+                        singleLine = true,
+                        keyboardOptions =
+                        KeyboardOptions.Default.copy(keyboardType = KeyboardType.Text, imeAction = ImeAction.Next),
+                        modifier = Modifier.fillMaxWidth(),
+                        trailingIcon = {
+                            IconButton(onClick = { showEmojiPickerView = true }) {
+                                Text(
+                                    text = String(Character.toChars(currentEmojiCodepoint)),
+                                    modifier =
+                                    Modifier.background(MaterialTheme.colorScheme.surfaceVariant, CircleShape)
+                                        .padding(6.dp),
+                                    fontSize = 20.sp,
+                                )
+                            }
+                        },
+                    )
+                    Spacer(modifier = Modifier.size(8.dp))
+                    OutlinedTextField(
+                        value = waypointInput.description ?: "",
+                        onValueChange = { waypointInput = waypointInput.copy(description = it.take(99)) },
+                        label = { Text(stringResource(Res.string.description)) },
+                        keyboardOptions =
+                        KeyboardOptions.Default.copy(keyboardType = KeyboardType.Text, imeAction = ImeAction.Done),
+                        keyboardActions = KeyboardActions(onDone = { /* Handle next/done focus */ }),
+                        modifier = Modifier.fillMaxWidth(),
+                        minLines = 2,
+                        maxLines = 3,
+                    )
+                    Spacer(modifier = Modifier.size(8.dp))
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                    ) {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            Image(
+                                imageVector = Icons.Rounded.Lock,
+                                contentDescription = stringResource(Res.string.locked),
+                            )
+                            Spacer(modifier = Modifier.width(8.dp))
+                            Text(stringResource(Res.string.locked))
+                        }
+                        Switch(
+                            checked = (waypointInput.locked_to ?: 0) != 0,
+                            onCheckedChange = { waypointInput = waypointInput.copy(locked_to = if (it) 1 else 0) },
+                        )
+                    }
+                    Spacer(modifier = Modifier.size(8.dp))
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                    ) {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            Image(
+                                imageVector = Icons.Rounded.CalendarMonth,
+                                contentDescription = stringResource(Res.string.expires),
+                            )
+                            Spacer(modifier = Modifier.width(8.dp))
+                            Text(stringResource(Res.string.expires))
+                        }
+                        Switch(
+                            checked = isExpiryEnabled,
+                            onCheckedChange = { checked ->
+                                isExpiryEnabled = checked
+                                if (checked) {
+                                    val expireValue = waypointInput.expire ?: 0
+                                    // Default to 8 hours from now if not already set
+                                    if (expireValue == 0 || expireValue == Int.MAX_VALUE) {
+                                        val futureInstant = kotlinx.datetime.Clock.System.now() + 8.hours
+                                        waypointInput = waypointInput.copy(expire = futureInstant.epochSeconds.toInt())
+                                    }
+                                } else {
+                                    waypointInput = waypointInput.copy(expire = Int.MAX_VALUE)
+                                }
+                            },
+                        )
+                    }
+
+                    if (isExpiryEnabled) {
+                        val currentInstant =
+                            (waypointInput.expire ?: 0).let {
+                                if (it != 0 && it != Int.MAX_VALUE) {
+                                    Instant.fromEpochSeconds(it.toLong())
+                                } else {
+                                    kotlinx.datetime.Clock.System.now() + 8.hours
+                                }
+                            }
+                        val ldt = currentInstant.toLocalDateTime(tz)
+
+                        val datePickerDialog =
+                            DatePickerDialog(
+                                context,
+                                { _: DatePicker, selectedYear: Int, selectedMonth: Int, selectedDay: Int ->
+                                    val currentLdt =
+                                        (waypointInput.expire ?: 0)
+                                            .let {
+                                                if (it != 0 && it != Int.MAX_VALUE) {
+                                                    Instant.fromEpochSeconds(it.toLong())
+                                                } else {
+                                                    kotlinx.datetime.Clock.System.now() + 8.hours
+                                                }
+                                            }
+                                            .toLocalDateTime(tz)
+
+                                    val newLdt =
+                                        LocalDate(
+                                            year = selectedYear,
+                                            month = Month(selectedMonth + 1),
+                                            day = selectedDay,
+                                        )
+                                            .atTime(
+                                                hour = currentLdt.hour,
+                                                minute = currentLdt.minute,
+                                                second = currentLdt.second,
+                                                nanosecond = currentLdt.nanosecond,
+                                            )
+                                    waypointInput =
+                                        waypointInput.copy(expire = newLdt.toInstant(tz).epochSeconds.toInt())
+                                },
+                                ldt.year,
+                                ldt.month.number - 1,
+                                ldt.day,
+                            )
+
+                        val timePickerDialog =
+                            TimePickerDialog(
+                                context,
+                                { _: TimePicker, selectedHour: Int, selectedMinute: Int ->
+                                    val currentLdt =
+                                        (waypointInput.expire ?: 0)
+                                            .let {
+                                                if (it != 0 && it != Int.MAX_VALUE) {
+                                                    Instant.fromEpochSeconds(it.toLong())
+                                                } else {
+                                                    kotlinx.datetime.Clock.System.now() + 8.hours
+                                                }
+                                            }
+                                            .toLocalDateTime(tz)
+
+                                    val newLdt =
+                                        LocalDate(
+                                            year = currentLdt.year,
+                                            month = currentLdt.month,
+                                            day = currentLdt.day,
+                                        )
+                                            .atTime(
+                                                hour = selectedHour,
+                                                minute = selectedMinute,
+                                                second = currentLdt.second,
+                                                nanosecond = currentLdt.nanosecond,
+                                            )
+                                    waypointInput =
+                                        waypointInput.copy(expire = newLdt.toInstant(tz).epochSeconds.toInt())
+                                },
+                                ldt.hour,
+                                ldt.minute,
+                                android.text.format.DateFormat.is24HourFormat(context),
+                            )
+                        Spacer(modifier = Modifier.size(8.dp))
+                        Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.SpaceEvenly,
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                                Button(onClick = { datePickerDialog.show() }) { Text(stringResource(Res.string.date)) }
+                                Text(
+                                    modifier = Modifier.padding(top = 4.dp),
+                                    text = selectedDateString,
+                                    style = MaterialTheme.typography.bodyMedium,
+                                )
+                            }
+                            Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                                Button(onClick = { timePickerDialog.show() }) { Text(stringResource(Res.string.time)) }
+                                Text(
+                                    modifier = Modifier.padding(top = 4.dp),
+                                    text = selectedTimeString,
+                                    style = MaterialTheme.typography.bodyMedium,
+                                )
+                            }
+                        }
+                    }
+                }
+            },
+            confirmButton = {
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(start = 8.dp, end = 8.dp, bottom = 8.dp),
+                    horizontalArrangement = Arrangement.End,
+                ) {
+                    if (waypoint.id != 0) {
+                        TextButton(
+                            onClick = { onDeleteClicked(waypointInput) },
+                            modifier = Modifier.padding(end = 8.dp),
+                        ) {
+                            Text(stringResource(Res.string.delete), color = MaterialTheme.colorScheme.error)
+                        }
+                    }
+                    Spacer(modifier = Modifier.weight(1f)) // Pushes delete to left and cancel/send to right
+                    TextButton(onClick = onDismissRequest, modifier = Modifier.padding(end = 8.dp)) {
+                        Text(stringResource(Res.string.cancel))
+                    }
+                    Button(
+                        onClick = { onSendClicked(waypointInput) },
+                        enabled = (waypointInput.name ?: "").isNotBlank(),
+                    ) {
+                        Text(stringResource(Res.string.send))
+                    }
+                }
+            },
+            dismissButton = null, // Using custom buttons in confirmButton Row
+            modifier = modifier,
+        )
+    } else {
+        EmojiPickerDialog(onDismiss = { showEmojiPickerView = false }) { selectedEmoji ->
+            showEmojiPickerView = false
+            waypointInput = waypointInput.copy(icon = selectedEmoji.codePointAt(0))
+        }
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/component/MapButton.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.material3.FilledIconButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButtonDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+
+@Composable
+fun MapButton(
+    modifier: Modifier = Modifier,
+    icon: ImageVector,
+    iconTint: Color? = null,
+    contentDescription: String,
+    onClick: () -> Unit,
+) {
+    FilledIconButton(onClick = onClick, modifier = modifier) {
+        Icon(
+            imageVector = icon,
+            contentDescription = contentDescription,
+            tint = iconTint ?: IconButtonDefaults.filledIconButtonColors().contentColor,
+        )
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/component/MapControlsOverlay.kt

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Navigation
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.outlined.Layers
+import androidx.compose.material.icons.outlined.Map
+import androidx.compose.material.icons.outlined.MyLocation
+import androidx.compose.material.icons.outlined.Navigation
+import androidx.compose.material.icons.outlined.Tune
+import androidx.compose.material.icons.rounded.LocationDisabled
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.HorizontalFloatingToolbar
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.app.map.MapViewModel
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.manage_map_layers
+import org.meshtastic.core.resources.map_filter
+import org.meshtastic.core.resources.map_tile_source
+import org.meshtastic.core.resources.orient_north
+import org.meshtastic.core.resources.refresh
+import org.meshtastic.core.resources.toggle_my_position
+import org.meshtastic.core.ui.theme.StatusColors.StatusRed
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun MapControlsOverlay(
+    modifier: Modifier = Modifier,
+    mapFilterMenuExpanded: Boolean,
+    onMapFilterMenuDismissRequest: () -> Unit,
+    onToggleMapFilterMenu: () -> Unit,
+    mapViewModel: MapViewModel, // For MapFilterDropdown and MapTypeDropdown
+    mapTypeMenuExpanded: Boolean,
+    onMapTypeMenuDismissRequest: () -> Unit,
+    onToggleMapTypeMenu: () -> Unit,
+    onManageLayersClicked: () -> Unit,
+    onManageCustomTileProvidersClicked: () -> Unit, // New parameter
+    isNodeMap: Boolean,
+    // Location tracking parameters
+    isLocationTrackingEnabled: Boolean = false,
+    onToggleLocationTracking: () -> Unit = {},
+    bearing: Float = 0f,
+    onCompassClick: () -> Unit = {},
+    followPhoneBearing: Boolean,
+    showRefresh: Boolean = false,
+    isRefreshing: Boolean = false,
+    onRefresh: () -> Unit = {},
+) {
+    HorizontalFloatingToolbar(
+        modifier = modifier,
+        expanded = true,
+        leadingContent = {},
+        trailingContent = {},
+        content = {
+            CompassButton(onClick = onCompassClick, bearing = bearing, isFollowing = followPhoneBearing)
+            if (isNodeMap) {
+                MapButton(
+                    icon = Icons.Outlined.Tune,
+                    contentDescription = stringResource(Res.string.map_filter),
+                    onClick = onToggleMapFilterMenu,
+                )
+                NodeMapFilterDropdown(
+                    expanded = mapFilterMenuExpanded,
+                    onDismissRequest = onMapFilterMenuDismissRequest,
+                    mapViewModel = mapViewModel,
+                )
+            } else {
+                Box {
+                    MapButton(
+                        icon = Icons.Outlined.Tune,
+                        contentDescription = stringResource(Res.string.map_filter),
+                        onClick = onToggleMapFilterMenu,
+                    )
+                    MapFilterDropdown(
+                        expanded = mapFilterMenuExpanded,
+                        onDismissRequest = onMapFilterMenuDismissRequest,
+                        mapViewModel = mapViewModel,
+                    )
+                }
+            }
+
+            Box {
+                MapButton(
+                    icon = Icons.Outlined.Map,
+                    contentDescription = stringResource(Res.string.map_tile_source),
+                    onClick = onToggleMapTypeMenu,
+                )
+                MapTypeDropdown(
+                    expanded = mapTypeMenuExpanded,
+                    onDismissRequest = onMapTypeMenuDismissRequest,
+                    mapViewModel = mapViewModel, // Pass mapViewModel
+                    onManageCustomTileProvidersClicked = onManageCustomTileProvidersClicked, // Pass new callback
+                )
+            }
+
+            MapButton(
+                icon = Icons.Outlined.Layers,
+                contentDescription = stringResource(Res.string.manage_map_layers),
+                onClick = onManageLayersClicked,
+            )
+
+            if (showRefresh) {
+                if (isRefreshing) {
+                    Box(modifier = Modifier.padding(8.dp)) {
+                        CircularProgressIndicator(modifier = Modifier.size(24.dp), strokeWidth = 2.dp)
+                    }
+                } else {
+                    MapButton(
+                        icon = Icons.Filled.Refresh,
+                        contentDescription = stringResource(Res.string.refresh),
+                        onClick = onRefresh,
+                    )
+                }
+            }
+
+            // Location tracking button
+            MapButton(
+                icon =
+                if (isLocationTrackingEnabled) {
+                    Icons.Rounded.LocationDisabled
+                } else {
+                    Icons.Outlined.MyLocation
+                },
+                contentDescription = stringResource(Res.string.toggle_my_position),
+                onClick = onToggleLocationTracking,
+            )
+        },
+    )
+}
+
+@Composable
+private fun CompassButton(onClick: () -> Unit, bearing: Float, isFollowing: Boolean) {
+    val icon = if (isFollowing) Icons.Filled.Navigation else Icons.Outlined.Navigation
+
+    MapButton(
+        modifier = Modifier.rotate(-bearing),
+        icon = icon,
+        iconTint = MaterialTheme.colorScheme.StatusRed.takeIf { bearing == 0f },
+        contentDescription = stringResource(Res.string.orient_north),
+        onClick = onClick,
+    )
+}

app/src/google/kotlin/org/meshtastic/app/map/component/MapFilterDropdown.kt

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Place
+import androidx.compose.material.icons.filled.Star
+import androidx.compose.material.icons.outlined.RadioButtonUnchecked
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.app.map.MapViewModel
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.last_heard_filter_label
+import org.meshtastic.core.resources.only_favorites
+import org.meshtastic.core.resources.show_precision_circle
+import org.meshtastic.core.resources.show_waypoints
+import org.meshtastic.feature.map.LastHeardFilter
+import kotlin.math.roundToInt
+
+@Composable
+internal fun MapFilterDropdown(expanded: Boolean, onDismissRequest: () -> Unit, mapViewModel: MapViewModel) {
+    val mapFilterState by mapViewModel.mapFilterStateFlow.collectAsStateWithLifecycle()
+    DropdownMenu(expanded = expanded, onDismissRequest = onDismissRequest) {
+        DropdownMenuItem(
+            text = { Text(stringResource(Res.string.only_favorites)) },
+            onClick = { mapViewModel.toggleOnlyFavorites() },
+            leadingIcon = {
+                Icon(imageVector = Icons.Filled.Star, contentDescription = stringResource(Res.string.only_favorites))
+            },
+            trailingIcon = {
+                Checkbox(
+                    checked = mapFilterState.onlyFavorites,
+                    onCheckedChange = { mapViewModel.toggleOnlyFavorites() },
+                )
+            },
+        )
+        DropdownMenuItem(
+            text = { Text(stringResource(Res.string.show_waypoints)) },
+            onClick = { mapViewModel.toggleShowWaypointsOnMap() },
+            leadingIcon = {
+                Icon(imageVector = Icons.Filled.Place, contentDescription = stringResource(Res.string.show_waypoints))
+            },
+            trailingIcon = {
+                Checkbox(
+                    checked = mapFilterState.showWaypoints,
+                    onCheckedChange = { mapViewModel.toggleShowWaypointsOnMap() },
+                )
+            },
+        )
+        DropdownMenuItem(
+            text = { Text(stringResource(Res.string.show_precision_circle)) },
+            onClick = { mapViewModel.toggleShowPrecisionCircleOnMap() },
+            leadingIcon = {
+                Icon(
+                    imageVector = Icons.Outlined.RadioButtonUnchecked, // Placeholder icon
+                    contentDescription = stringResource(Res.string.show_precision_circle),
+                )
+            },
+            trailingIcon = {
+                Checkbox(
+                    checked = mapFilterState.showPrecisionCircle,
+                    onCheckedChange = { mapViewModel.toggleShowPrecisionCircleOnMap() },
+                )
+            },
+        )
+        HorizontalDivider()
+        Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) {
+            val filterOptions = LastHeardFilter.entries
+            val selectedIndex = filterOptions.indexOf(mapFilterState.lastHeardFilter)
+            var sliderPosition by remember(selectedIndex) { mutableFloatStateOf(selectedIndex.toFloat()) }
+
+            Text(
+                text =
+                stringResource(
+                    Res.string.last_heard_filter_label,
+                    stringResource(mapFilterState.lastHeardFilter.label),
+                ),
+                style = MaterialTheme.typography.labelLarge,
+            )
+            Slider(
+                value = sliderPosition,
+                onValueChange = { sliderPosition = it },
+                onValueChangeFinished = {
+                    val newIndex = sliderPosition.roundToInt().coerceIn(0, filterOptions.size - 1)
+                    mapViewModel.setLastHeardFilter(filterOptions[newIndex])
+                },
+                valueRange = 0f..(filterOptions.size - 1).toFloat(),
+                steps = filterOptions.size - 2,
+            )
+        }
+    }
+}
+
+@Composable
+internal fun NodeMapFilterDropdown(expanded: Boolean, onDismissRequest: () -> Unit, mapViewModel: MapViewModel) {
+    val mapFilterState by mapViewModel.mapFilterStateFlow.collectAsStateWithLifecycle()
+    DropdownMenu(expanded = expanded, onDismissRequest = onDismissRequest) {
+        Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) {
+            val filterOptions = LastHeardFilter.entries
+            val selectedIndex = filterOptions.indexOf(mapFilterState.lastHeardTrackFilter)
+            var sliderPosition by remember(selectedIndex) { mutableFloatStateOf(selectedIndex.toFloat()) }
+
+            Text(
+                text =
+                stringResource(
+                    Res.string.last_heard_filter_label,
+                    stringResource(mapFilterState.lastHeardTrackFilter.label),
+                ),
+                style = MaterialTheme.typography.labelLarge,
+            )
+            Slider(
+                value = sliderPosition,
+                onValueChange = { sliderPosition = it },
+                onValueChangeFinished = {
+                    val newIndex = sliderPosition.roundToInt().coerceIn(0, filterOptions.size - 1)
+                    mapViewModel.setLastHeardTrackFilter(filterOptions[newIndex])
+                },
+                valueRange = 0f..(filterOptions.size - 1).toFloat(),
+                steps = filterOptions.size - 2,
+            )
+        }
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/component/MapTypeDropdown.kt

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.google.maps.android.compose.MapType
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.app.map.MapViewModel
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.manage_custom_tile_sources
+import org.meshtastic.core.resources.map_type_hybrid
+import org.meshtastic.core.resources.map_type_normal
+import org.meshtastic.core.resources.map_type_satellite
+import org.meshtastic.core.resources.map_type_terrain
+import org.meshtastic.core.resources.selected_map_type
+
+@Suppress("LongMethod")
+@Composable
+internal fun MapTypeDropdown(
+    expanded: Boolean,
+    onDismissRequest: () -> Unit,
+    mapViewModel: MapViewModel,
+    onManageCustomTileProvidersClicked: () -> Unit,
+) {
+    val customTileProviders by mapViewModel.customTileProviderConfigs.collectAsStateWithLifecycle()
+    val selectedCustomUrl by mapViewModel.selectedCustomTileProviderUrl.collectAsStateWithLifecycle()
+    val selectedGoogleMapType by mapViewModel.selectedGoogleMapType.collectAsStateWithLifecycle()
+
+    val googleMapTypes =
+        listOf(
+            stringResource(Res.string.map_type_normal) to MapType.NORMAL,
+            stringResource(Res.string.map_type_satellite) to MapType.SATELLITE,
+            stringResource(Res.string.map_type_terrain) to MapType.TERRAIN,
+            stringResource(Res.string.map_type_hybrid) to MapType.HYBRID,
+        )
+
+    DropdownMenu(expanded = expanded, onDismissRequest = onDismissRequest) {
+        googleMapTypes.forEach { (name, type) ->
+            DropdownMenuItem(
+                text = { Text(name) },
+                onClick = {
+                    mapViewModel.setSelectedGoogleMapType(type)
+                    onDismissRequest() // Close menu
+                },
+                trailingIcon =
+                if (selectedCustomUrl == null && selectedGoogleMapType == type) {
+                    { Icon(Icons.Filled.Check, contentDescription = stringResource(Res.string.selected_map_type)) }
+                } else {
+                    null
+                },
+            )
+        }
+
+        if (customTileProviders.isNotEmpty()) {
+            HorizontalDivider()
+            customTileProviders.forEach { config ->
+                DropdownMenuItem(
+                    text = { Text(config.name) },
+                    onClick = {
+                        mapViewModel.selectCustomTileProvider(config)
+                        onDismissRequest() // Close menu
+                    },
+                    trailingIcon =
+                    if (selectedCustomUrl == config.urlTemplate) {
+                        {
+                            Icon(
+                                Icons.Filled.Check,
+                                contentDescription = stringResource(Res.string.selected_map_type),
+                            )
+                        }
+                    } else {
+                        null
+                    },
+                )
+            }
+        }
+        HorizontalDivider()
+        DropdownMenuItem(
+            text = { Text(stringResource(Res.string.manage_custom_tile_sources)) },
+            onClick = {
+                onManageCustomTileProvidersClicked()
+                onDismissRequest()
+            },
+        )
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/component/NodeClusterMarkers.kt

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalView
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.findViewTreeLifecycleOwner
+import androidx.lifecycle.setViewTreeLifecycleOwner
+import androidx.savedstate.compose.LocalSavedStateRegistryOwner
+import androidx.savedstate.findViewTreeSavedStateRegistryOwner
+import androidx.savedstate.setViewTreeSavedStateRegistryOwner
+import com.google.maps.android.clustering.Cluster
+import com.google.maps.android.clustering.view.DefaultClusterRenderer
+import com.google.maps.android.compose.Circle
+import com.google.maps.android.compose.MapsComposeExperimentalApi
+import com.google.maps.android.compose.clustering.Clustering
+import com.google.maps.android.compose.clustering.ClusteringMarkerProperties
+import org.meshtastic.app.map.model.NodeClusterItem
+import org.meshtastic.feature.map.BaseMapViewModel
+
+@OptIn(MapsComposeExperimentalApi::class)
+@Suppress("NestedBlockDepth")
+@Composable
+fun NodeClusterMarkers(
+    nodeClusterItems: List<NodeClusterItem>,
+    mapFilterState: BaseMapViewModel.MapFilterState,
+    navigateToNodeDetails: (Int) -> Unit,
+    onClusterClick: (Cluster<NodeClusterItem>) -> Boolean,
+) {
+    val view = LocalView.current
+    val lifecycleOwner = LocalLifecycleOwner.current
+    val savedStateRegistryOwner = LocalSavedStateRegistryOwner.current
+
+    // Workaround for https://github.com/googlemaps/android-maps-compose/issues/858
+    // The maps clustering library creates an internal ComposeView to snapshot markers.
+    // If that view is not attached to the hierarchy (which it often isn't during rendering),
+    // it fails to find the Lifecycle and SavedState owners. We propagate them to the root view
+    // so the internal snapshot view can find them when walking up the tree.
+    LaunchedEffect(view, lifecycleOwner, savedStateRegistryOwner) {
+        val root = view.rootView
+        if (root.findViewTreeLifecycleOwner() == null) {
+            root.setViewTreeLifecycleOwner(lifecycleOwner)
+        }
+        if (root.findViewTreeSavedStateRegistryOwner() == null) {
+            root.setViewTreeSavedStateRegistryOwner(savedStateRegistryOwner)
+        }
+    }
+
+    Clustering(
+        items = nodeClusterItems,
+        onClusterClick = onClusterClick,
+        onClusterItemInfoWindowClick = { item ->
+            navigateToNodeDetails(item.node.num)
+            false
+        },
+        clusterItemContent = { clusterItem -> PulsingNodeChip(node = clusterItem.node) },
+        onClusterManager = { clusterManager ->
+            (clusterManager.renderer as DefaultClusterRenderer).minClusterSize = 10
+        },
+        clusterItemDecoration = { clusterItem ->
+            if (mapFilterState.showPrecisionCircle) {
+                clusterItem.getPrecisionMeters()?.let { precisionMeters ->
+                    if (precisionMeters > 0) {
+                        Circle(
+                            center = clusterItem.position,
+                            radius = precisionMeters,
+                            fillColor = Color(clusterItem.node.colors.second).copy(alpha = 0.2f),
+                            strokeColor = Color(clusterItem.node.colors.second),
+                            strokeWidth = 2f,
+                            zIndex = 0f,
+                        )
+                    }
+                }
+            }
+            // Use the item's own priority-based zIndex (5f for My Node/Favorites, 4f for others)
+            ClusteringMarkerProperties(zIndex = clusterItem.getZIndex())
+        },
+    )
+}

app/src/google/kotlin/org/meshtastic/app/map/component/PulsingNodeChip.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.layout.Box
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+import org.meshtastic.core.common.util.nowSeconds
+import org.meshtastic.core.model.Node
+import org.meshtastic.core.ui.component.NodeChip
+
+@Composable
+fun PulsingNodeChip(node: Node, modifier: Modifier = Modifier) {
+    val animatedProgress = remember { Animatable(0f) }
+
+    LaunchedEffect(node) {
+        if ((nowSeconds - node.lastHeard) <= 5) {
+            launch {
+                animatedProgress.snapTo(0f)
+                animatedProgress.animateTo(
+                    targetValue = 1f,
+                    animationSpec = tween(durationMillis = 1000, easing = LinearEasing),
+                )
+            }
+        }
+    }
+
+    Box(
+        modifier =
+        modifier.drawWithContent {
+            drawContent()
+            if (animatedProgress.value > 0 && animatedProgress.value < 1f) {
+                val alpha = (1f - animatedProgress.value) * 0.3f
+                drawRoundRect(
+                    size = size,
+                    cornerRadius = CornerRadius(8.dp.toPx()),
+                    color = Color.White.copy(alpha = alpha),
+                )
+            }
+        },
+    ) {
+        NodeChip(node = node)
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/component/WaypointMarkers.kt

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.component
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.platform.LocalContext
+import com.google.android.gms.maps.model.BitmapDescriptor
+import com.google.android.gms.maps.model.LatLng
+import com.google.maps.android.compose.Marker
+import com.google.maps.android.compose.rememberUpdatedMarkerState
+import kotlinx.coroutines.launch
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.locked
+import org.meshtastic.core.ui.util.showToast
+import org.meshtastic.feature.map.BaseMapViewModel
+import org.meshtastic.proto.Waypoint
+
+private const val DEG_D = 1e-7
+
+@Composable
+fun WaypointMarkers(
+    displayableWaypoints: List<Waypoint>,
+    mapFilterState: BaseMapViewModel.MapFilterState,
+    myNodeNum: Int,
+    isConnected: Boolean,
+    unicodeEmojiToBitmapProvider: (Int) -> BitmapDescriptor,
+    onEditWaypointRequest: (Waypoint) -> Unit,
+    selectedWaypointId: Int? = null,
+) {
+    val scope = rememberCoroutineScope()
+    val context = LocalContext.current
+    if (mapFilterState.showWaypoints) {
+        displayableWaypoints.forEach { waypoint ->
+            val markerState =
+                rememberUpdatedMarkerState(
+                    position = LatLng((waypoint.latitude_i ?: 0) * DEG_D, (waypoint.longitude_i ?: 0) * DEG_D),
+                )
+
+            LaunchedEffect(selectedWaypointId) {
+                if (selectedWaypointId == waypoint.id) {
+                    markerState.showInfoWindow()
+                }
+            }
+
+            Marker(
+                state = markerState,
+                icon =
+                if ((waypoint.icon ?: 0) == 0) {
+                    unicodeEmojiToBitmapProvider(PUSHPIN) // Default icon (Round Pushpin)
+                } else {
+                    unicodeEmojiToBitmapProvider(waypoint.icon!!)
+                },
+                title = (waypoint.name ?: "").replace('\n', ' ').replace('\b', ' '),
+                snippet = (waypoint.description ?: "").replace('\n', ' ').replace('\b', ' '),
+                visible = true,
+                onInfoWindowClick = {
+                    if ((waypoint.locked_to ?: 0) == 0 || waypoint.locked_to == myNodeNum || !isConnected) {
+                        onEditWaypointRequest(waypoint)
+                    } else {
+                        scope.launch { context.showToast(Res.string.locked) }
+                    }
+                },
+            )
+        }
+    }
+}
+
+private const val PUSHPIN = 0x1F4CD // Unicode for Round Pushpin

app/src/google/kotlin/org/meshtastic/app/map/model/CustomTileProviderConfig.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.model
+
+import kotlinx.serialization.Serializable
+import kotlin.uuid.Uuid
+
+@Serializable
+data class CustomTileProviderConfig(
+    val id: String = Uuid.random().toString(),
+    val name: String,
+    val urlTemplate: String,
+    val localUri: String? = null,
+) {
+    val isLocal: Boolean
+        get() = localUri != null
+}

app/src/google/kotlin/org/meshtastic/app/map/model/CustomTileSource.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.model
+
+class CustomTileSource {
+
+    companion object {
+        fun getTileSource(index: Int) {
+            index
+        }
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/model/NodeClusterItem.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.model
+
+import com.google.android.gms.maps.model.LatLng
+import com.google.maps.android.clustering.ClusterItem
+import org.meshtastic.core.model.Node
+
+data class NodeClusterItem(
+    val node: Node,
+    val nodePosition: LatLng,
+    val nodeTitle: String,
+    val nodeSnippet: String,
+    val myNodeNum: Int? = null,
+) : ClusterItem {
+    override fun getPosition(): LatLng = nodePosition
+
+    override fun getTitle(): String = nodeTitle
+
+    override fun getSnippet(): String = nodeSnippet
+
+    override fun getZIndex(): Float = when {
+        node.num == myNodeNum -> 5.0f // My node is always highest
+        node.isFavorite -> 5.0f // Favorites are equally high priority
+        else -> 4.0f
+    }
+
+    fun getPrecisionMeters(): Double? {
+        val precisionMap =
+            mapOf(
+                10 to 23345.484932,
+                11 to 11672.7369,
+                12 to 5836.36288,
+                13 to 2918.175876,
+                14 to 1459.0823719999053,
+                15 to 729.53562,
+                16 to 364.7622,
+                17 to 182.375556,
+                18 to 91.182212,
+                19 to 45.58554,
+            )
+        return precisionMap[this.node.position.precision_bits ?: 0]
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/node/NodeMapScreen.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.node
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Scaffold
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.meshtastic.app.map.MapView
+import org.meshtastic.core.ui.component.MainAppBar
+
+@Composable
+fun NodeMapScreen(nodeMapViewModel: NodeMapViewModel, onNavigateUp: () -> Unit) {
+    val node by nodeMapViewModel.node.collectAsStateWithLifecycle()
+    val positions by nodeMapViewModel.positionLogs.collectAsStateWithLifecycle()
+    val destNum = node?.num
+
+    Scaffold(
+        topBar = {
+            MainAppBar(
+                title = node?.user?.long_name ?: "",
+                ourNode = null,
+                showNodeChip = false,
+                canNavigateUp = true,
+                onNavigateUp = onNavigateUp,
+                actions = {},
+                onClickChip = {},
+            )
+        },
+    ) { paddingValues ->
+        Box(modifier = Modifier.padding(paddingValues)) {
+            MapView(focusedNodeNum = destNum, nodeTracks = positions, navigateToNodeDetails = {})
+        }
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/prefs/di/GoogleMapsModule.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.prefs.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.SharedPreferencesMigration
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+import dagger.Binds
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import org.meshtastic.app.map.prefs.map.GoogleMapsPrefs
+import org.meshtastic.app.map.prefs.map.GoogleMapsPrefsImpl
+import org.meshtastic.app.map.repository.CustomTileProviderRepository
+import org.meshtastic.app.map.repository.CustomTileProviderRepositoryImpl
+import javax.inject.Qualifier
+import javax.inject.Singleton
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class GoogleMapsDataStore
+
+@InstallIn(SingletonComponent::class)
+@Module
+interface GoogleMapsModule {
+
+    @Binds fun bindGoogleMapsPrefs(googleMapsPrefsImpl: GoogleMapsPrefsImpl): GoogleMapsPrefs
+
+    @Binds
+    @Singleton
+    fun bindCustomTileProviderRepository(impl: CustomTileProviderRepositoryImpl): CustomTileProviderRepository
+
+    companion object {
+        private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+        @Provides
+        @Singleton
+        @GoogleMapsDataStore
+        fun provideGoogleMapsDataStore(@ApplicationContext context: Context): DataStore<Preferences> =
+            PreferenceDataStoreFactory.create(
+                migrations = listOf(SharedPreferencesMigration(context, "google_maps_prefs")),
+                scope = scope,
+                produceFile = { context.preferencesDataStoreFile("google_maps_ds") },
+            )
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/prefs/map/GoogleMapsPrefs.kt

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.prefs.map
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.doublePreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.floatPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.core.stringSetPreferencesKey
+import com.google.maps.android.compose.MapType
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import org.meshtastic.app.map.prefs.di.GoogleMapsDataStore
+import org.meshtastic.core.di.CoroutineDispatchers
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/** Interface for prefs specific to Google Maps. For general map prefs, see MapPrefs. */
+interface GoogleMapsPrefs {
+    val selectedGoogleMapType: StateFlow<String?>
+
+    fun setSelectedGoogleMapType(value: String?)
+
+    val selectedCustomTileUrl: StateFlow<String?>
+
+    fun setSelectedCustomTileUrl(value: String?)
+
+    val hiddenLayerUrls: StateFlow<Set<String>>
+
+    fun setHiddenLayerUrls(value: Set<String>)
+
+    val cameraTargetLat: StateFlow<Double>
+
+    fun setCameraTargetLat(value: Double)
+
+    val cameraTargetLng: StateFlow<Double>
+
+    fun setCameraTargetLng(value: Double)
+
+    val cameraZoom: StateFlow<Float>
+
+    fun setCameraZoom(value: Float)
+
+    val cameraTilt: StateFlow<Float>
+
+    fun setCameraTilt(value: Float)
+
+    val cameraBearing: StateFlow<Float>
+
+    fun setCameraBearing(value: Float)
+
+    val networkMapLayers: StateFlow<Set<String>>
+
+    fun setNetworkMapLayers(value: Set<String>)
+}
+
+@Singleton
+class GoogleMapsPrefsImpl
+@Inject
+constructor(
+    @GoogleMapsDataStore private val dataStore: DataStore<Preferences>,
+    dispatchers: CoroutineDispatchers,
+) : GoogleMapsPrefs {
+    private val scope = CoroutineScope(SupervisorJob() + dispatchers.default)
+
+    override val selectedGoogleMapType: StateFlow<String?> =
+        dataStore.data
+            .map { it[KEY_SELECTED_GOOGLE_MAP_TYPE_PREF] ?: MapType.NORMAL.name }
+            .stateIn(scope, SharingStarted.Eagerly, MapType.NORMAL.name)
+
+    override fun setSelectedGoogleMapType(value: String?) {
+        scope.launch {
+            dataStore.edit { prefs ->
+                if (value == null) {
+                    prefs.remove(KEY_SELECTED_GOOGLE_MAP_TYPE_PREF)
+                } else {
+                    prefs[KEY_SELECTED_GOOGLE_MAP_TYPE_PREF] = value
+                }
+            }
+        }
+    }
+
+    override val selectedCustomTileUrl: StateFlow<String?> =
+        dataStore.data.map { it[KEY_SELECTED_CUSTOM_TILE_URL_PREF] }.stateIn(scope, SharingStarted.Eagerly, null)
+
+    override fun setSelectedCustomTileUrl(value: String?) {
+        scope.launch {
+            dataStore.edit { prefs ->
+                if (value == null) {
+                    prefs.remove(KEY_SELECTED_CUSTOM_TILE_URL_PREF)
+                } else {
+                    prefs[KEY_SELECTED_CUSTOM_TILE_URL_PREF] = value
+                }
+            }
+        }
+    }
+
+    override val hiddenLayerUrls: StateFlow<Set<String>> =
+        dataStore.data
+            .map { it[KEY_HIDDEN_LAYER_URLS_PREF] ?: emptySet() }
+            .stateIn(scope, SharingStarted.Eagerly, emptySet())
+
+    override fun setHiddenLayerUrls(value: Set<String>) {
+        scope.launch { dataStore.edit { it[KEY_HIDDEN_LAYER_URLS_PREF] = value } }
+    }
+
+    override val cameraTargetLat: StateFlow<Double> =
+        dataStore.data.map { it[KEY_CAMERA_TARGET_LAT_PREF] ?: 0.0 }.stateIn(scope, SharingStarted.Eagerly, 0.0)
+
+    override fun setCameraTargetLat(value: Double) {
+        scope.launch { dataStore.edit { it[KEY_CAMERA_TARGET_LAT_PREF] = value } }
+    }
+
+    override val cameraTargetLng: StateFlow<Double> =
+        dataStore.data.map { it[KEY_CAMERA_TARGET_LNG_PREF] ?: 0.0 }.stateIn(scope, SharingStarted.Eagerly, 0.0)
+
+    override fun setCameraTargetLng(value: Double) {
+        scope.launch { dataStore.edit { it[KEY_CAMERA_TARGET_LNG_PREF] = value } }
+    }
+
+    override val cameraZoom: StateFlow<Float> =
+        dataStore.data.map { it[KEY_CAMERA_ZOOM_PREF] ?: 7f }.stateIn(scope, SharingStarted.Eagerly, 7f)
+
+    override fun setCameraZoom(value: Float) {
+        scope.launch { dataStore.edit { it[KEY_CAMERA_ZOOM_PREF] = value } }
+    }
+
+    override val cameraTilt: StateFlow<Float> =
+        dataStore.data.map { it[KEY_CAMERA_TILT_PREF] ?: 0f }.stateIn(scope, SharingStarted.Eagerly, 0f)
+
+    override fun setCameraTilt(value: Float) {
+        scope.launch { dataStore.edit { it[KEY_CAMERA_TILT_PREF] = value } }
+    }
+
+    override val cameraBearing: StateFlow<Float> =
+        dataStore.data.map { it[KEY_CAMERA_BEARING_PREF] ?: 0f }.stateIn(scope, SharingStarted.Eagerly, 0f)
+
+    override fun setCameraBearing(value: Float) {
+        scope.launch { dataStore.edit { it[KEY_CAMERA_BEARING_PREF] = value } }
+    }
+
+    override val networkMapLayers: StateFlow<Set<String>> =
+        dataStore.data
+            .map { it[KEY_NETWORK_MAP_LAYERS_PREF] ?: emptySet() }
+            .stateIn(scope, SharingStarted.Eagerly, emptySet())
+
+    override fun setNetworkMapLayers(value: Set<String>) {
+        scope.launch { dataStore.edit { it[KEY_NETWORK_MAP_LAYERS_PREF] = value } }
+    }
+
+    companion object {
+        val KEY_SELECTED_GOOGLE_MAP_TYPE_PREF = stringPreferencesKey("selected_google_map_type")
+        val KEY_SELECTED_CUSTOM_TILE_URL_PREF = stringPreferencesKey("selected_custom_tile_url")
+        val KEY_HIDDEN_LAYER_URLS_PREF = stringSetPreferencesKey("hidden_layer_urls")
+        val KEY_CAMERA_TARGET_LAT_PREF = doublePreferencesKey("camera_target_lat")
+        val KEY_CAMERA_TARGET_LNG_PREF = doublePreferencesKey("camera_target_lng")
+        val KEY_CAMERA_ZOOM_PREF = floatPreferencesKey("camera_zoom")
+        val KEY_CAMERA_TILT_PREF = floatPreferencesKey("camera_tilt")
+        val KEY_CAMERA_BEARING_PREF = floatPreferencesKey("camera_bearing")
+        val KEY_NETWORK_MAP_LAYERS_PREF = stringSetPreferencesKey("network_map_layers")
+    }
+}

app/src/google/kotlin/org/meshtastic/app/map/repository/CustomTileProviderRepository.kt

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.meshtastic.app.map.repository
+
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import org.meshtastic.app.map.model.CustomTileProviderConfig
+import org.meshtastic.core.di.CoroutineDispatchers
+import org.meshtastic.core.repository.MapTileProviderPrefs
+import javax.inject.Inject
+import javax.inject.Singleton
+
+interface CustomTileProviderRepository {
+    fun getCustomTileProviders(): Flow<List<CustomTileProviderConfig>>
+
+    suspend fun addCustomTileProvider(config: CustomTileProviderConfig)
+
+    suspend fun updateCustomTileProvider(config: CustomTileProviderConfig)
+
+    suspend fun deleteCustomTileProvider(configId: String)
+
+    suspend fun getCustomTileProviderById(configId: String): CustomTileProviderConfig?
+}
+
+@Singleton
+class CustomTileProviderRepositoryImpl
+@Inject
+constructor(
+    private val json: Json,
+    private val dispatchers: CoroutineDispatchers,
+    private val mapTileProviderPrefs: MapTileProviderPrefs,
+) : CustomTileProviderRepository {
+
+    private val customTileProvidersStateFlow = MutableStateFlow<List<CustomTileProviderConfig>>(emptyList())
+
+    init {
+        loadDataFromPrefs()
+    }
+
+    override fun getCustomTileProviders(): Flow<List<CustomTileProviderConfig>> =
+        customTileProvidersStateFlow.asStateFlow()
+
+    override suspend fun addCustomTileProvider(config: CustomTileProviderConfig) {
+        val newList = customTileProvidersStateFlow.value + config
+        customTileProvidersStateFlow.value = newList
+        saveDataToPrefs(newList)
+    }
+
+    override suspend fun updateCustomTileProvider(config: CustomTileProviderConfig) {
+        val newList = customTileProvidersStateFlow.value.map { if (it.id == config.id) config else it }
+        customTileProvidersStateFlow.value = newList
+        saveDataToPrefs(newList)
+    }
+
+    override suspend fun deleteCustomTileProvider(configId: String) {
+        val newList = customTileProvidersStateFlow.value.filterNot { it.id == configId }
+        customTileProvidersStateFlow.value = newList
+        saveDataToPrefs(newList)
+    }
+
+    override suspend fun getCustomTileProviderById(configId: String): CustomTileProviderConfig? =
+        customTileProvidersStateFlow.value.find { it.id == configId }
+
+    private fun loadDataFromPrefs() {
+        val jsonString = mapTileProviderPrefs.customTileProviders.value
+        if (jsonString != null) {
+            try {
+                customTileProvidersStateFlow.value = json.decodeFromString<List<CustomTileProviderConfig>>(jsonString)
+            } catch (e: SerializationException) {
+                Logger.e(e) { "Error deserializing tile providers" }
+                customTileProvidersStateFlow.value = emptyList()
+            }
+        } else {
+            customTileProvidersStateFlow.value = emptyList()
+        }
+    }
+
+    private suspend fun saveDataToPrefs(providers: List<CustomTileProviderConfig>) {
+        withContext(dispatchers.io) {
+            try {
+                val jsonString = json.encodeToString(providers)
+                mapTileProviderPrefs.setCustomTileProviders(jsonString)
+            } catch (e: SerializationException) {
+                Logger.e(e) { "Error serializing tile providers" }
+            }
+        }
+    }
+}