refactor: maps (#2097)

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

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

@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2025 Meshtastic LLC
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.geeksville.mesh.ui.node
-
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.viewinterop.AndroidView
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.geeksville.mesh.model.MetricsViewModel
-import com.geeksville.mesh.ui.map.rememberMapViewWithLifecycle
-import com.geeksville.mesh.util.addCopyright
-import com.geeksville.mesh.util.addPolyline
-import com.geeksville.mesh.util.addPositionMarkers
-import com.geeksville.mesh.util.addScaleBarOverlay
-import org.osmdroid.util.BoundingBox
-import org.osmdroid.util.GeoPoint
-
-private const val DegD = 1e-7
-
-@Composable
-fun NodeMapScreen(
-    viewModel: MetricsViewModel = hiltViewModel(),
-) {
-    val density = LocalDensity.current
-    val state by viewModel.state.collectAsStateWithLifecycle()
-    val geoPoints = state.positionLogs.map { GeoPoint(it.latitudeI * DegD, it.longitudeI * DegD) }
-    val cameraView = remember { BoundingBox.fromGeoPoints(geoPoints) }
-    val mapView = rememberMapViewWithLifecycle(cameraView, viewModel.tileSource)
-
-    AndroidView(
-        modifier = Modifier.fillMaxSize(),
-        factory = { mapView },
-        update = { map ->
-            map.overlays.clear()
-            map.addCopyright()
-            map.addScaleBarOverlay(density)
-
-            map.addPolyline(density, geoPoints) {}
-            map.addPositionMarkers(state.positionLogs) {}
-        }
-    )
-}

app/src/main/java/com/geeksville/mesh/ui/node/NodeScreen.kt

@@ -115,7 +115,6 @@ fun NodeScreen(
                     modifier = Modifier.animateItem(),
                     thisNode = ourNode,
                     thatNode = node,
-                    gpsFormat = state.gpsFormat,
                     distanceUnits = state.distanceUnits,
                     tempInFahrenheit = state.tempInFahrenheit,
                     onAction = { menuItem ->

app/src/main/java/com/geeksville/mesh/ui/node/components/LinkedCoordinates.kt

@@ -39,10 +39,7 @@ import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.PreviewLightDark
-import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import androidx.core.net.toUri
-import com.geeksville.mesh.ConfigProtos.Config.DisplayConfig.GpsCoordinateFormat
 import com.geeksville.mesh.android.BuildUtils.debug
 import com.geeksville.mesh.ui.common.theme.AppTheme
 import com.geeksville.mesh.ui.common.theme.HyperlinkBlue
@@ -52,91 +49,61 @@ import java.net.URLEncoder
 
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
-fun LinkedCoordinates(
-    modifier: Modifier = Modifier,
-    latitude: Double,
-    longitude: Double,
-    format: Int,
-    nodeName: String,
-) {
+fun LinkedCoordinates(modifier: Modifier = Modifier, latitude: Double, longitude: Double, nodeName: String) {
     val context = LocalContext.current
     val clipboard: Clipboard = LocalClipboard.current
     val coroutineScope = rememberCoroutineScope()
-    val style = SpanStyle(
-        color = HyperlinkBlue,
-        fontSize = MaterialTheme.typography.labelLarge.fontSize,
-        textDecoration = TextDecoration.Underline
-    )
+    val style =
+        SpanStyle(
+            color = HyperlinkBlue,
+            fontSize = MaterialTheme.typography.labelLarge.fontSize,
+            textDecoration = TextDecoration.Underline,
+        )
 
-    val annotatedString = rememberAnnotatedString(latitude, longitude, format, nodeName, style)
+    val annotatedString = rememberAnnotatedString(latitude, longitude, nodeName, style)
 
     Text(
-        modifier = modifier.combinedClickable(
-            onClick = {
-                handleClick(context, annotatedString)
-            },
+        modifier =
+        modifier.combinedClickable(
+            onClick = { handleClick(context, annotatedString) },
             onLongClick = {
                 coroutineScope.launch {
-                    clipboard.setClipEntry(
-                        ClipEntry(
-                            ClipData.newPlainText("", annotatedString)
-                        )
-                    )
+                    clipboard.setClipEntry(ClipEntry(ClipData.newPlainText("", annotatedString)))
                     debug("Copied to clipboard")
                 }
-            }
+            },
         ),
-        text = annotatedString
+        text = annotatedString,
     )
 }
 
 @Composable
-private fun rememberAnnotatedString(
-    latitude: Double,
-    longitude: Double,
-    format: Int,
-    nodeName: String,
-    style: SpanStyle
-) = buildAnnotatedString {
-    pushStringAnnotation(
-        tag = "gps",
-        annotation = "geo:0,0?q=$latitude,$longitude&z=17&label=${
-            URLEncoder.encode(nodeName, "utf-8")
-        }"
-    )
-    withStyle(style = style) {
-        val gpsString = when (format) {
-            GpsCoordinateFormat.DEC_VALUE -> GPSFormat.toDEC(latitude, longitude)
-            GpsCoordinateFormat.DMS_VALUE -> GPSFormat.toDMS(latitude, longitude)
-            GpsCoordinateFormat.UTM_VALUE -> GPSFormat.toUTM(latitude, longitude)
-            GpsCoordinateFormat.MGRS_VALUE -> GPSFormat.toMGRS(latitude, longitude)
-            else -> GPSFormat.toDEC(latitude, longitude)
+private fun rememberAnnotatedString(latitude: Double, longitude: Double, nodeName: String, style: SpanStyle) =
+    buildAnnotatedString {
+        pushStringAnnotation(
+            tag = "gps",
+            annotation =
+            "geo:0,0?q=$latitude,$longitude&z=17&label=${
+                URLEncoder.encode(nodeName, "utf-8")
+            }",
+        )
+        withStyle(style = style) {
+            val gpsString = GPSFormat.toDec(latitude, longitude)
+            append(gpsString)
         }
-        append(gpsString)
+        pop()
     }
-    pop()
-}
 
 private fun handleClick(context: Context, annotatedString: AnnotatedString) {
-    annotatedString.getStringAnnotations(
-        tag = "gps",
-        start = 0,
-        end = annotatedString.length
-    ).firstOrNull()?.let {
+    annotatedString.getStringAnnotations(tag = "gps", start = 0, end = annotatedString.length).firstOrNull()?.let {
         val uri = it.item.toUri()
-        val intent = Intent(Intent.ACTION_VIEW, uri).apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        }
+        val intent = Intent(Intent.ACTION_VIEW, uri).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) }
 
         try {
             if (intent.resolveActivity(context.packageManager) != null) {
                 context.startActivity(intent)
             } else {
-                Toast.makeText(
-                    context,
-                    "No application available to open this location!",
-                    Toast.LENGTH_LONG
-                ).show()
+                Toast.makeText(context, "No application available to open this location!", Toast.LENGTH_LONG).show()
             }
         } catch (ex: ActivityNotFoundException) {
             debug("Failed to open geo intent: $ex")
@@ -146,20 +113,6 @@ private fun handleClick(context: Context, annotatedString: AnnotatedString) {
 
 @PreviewLightDark
 @Composable
-fun LinkedCoordinatesPreview(
-    @PreviewParameter(GPSFormatPreviewParameterProvider::class) format: Int
-) {
-    AppTheme {
-        LinkedCoordinates(
-            latitude = 37.7749,
-            longitude = -122.4194,
-            format = format,
-            nodeName = "Test Node Name"
-        )
-    }
-}
-
-class GPSFormatPreviewParameterProvider : PreviewParameterProvider<Int> {
-    override val values: Sequence<Int>
-        get() = sequenceOf(0, 1, 2)
+fun LinkedCoordinatesPreview() {
+    AppTheme { LinkedCoordinates(latitude = 37.7749, longitude = -122.4194, nodeName = "Test Node Name") }
 }

app/src/main/java/com/geeksville/mesh/ui/node/components/NodeChip.kt

@@ -49,6 +49,7 @@ import com.geeksville.mesh.model.Node
 @Composable
 fun NodeChip(
     modifier: Modifier = Modifier,
+    enabled: Boolean = true,
     node: Node,
     isThisNode: Boolean,
     isConnected: Boolean,
@@ -87,6 +88,7 @@ fun NodeChip(
             modifier =
             Modifier.matchParentSize()
                 .combinedClickable(
+                    enabled = enabled,
                     onClick = { onAction(NodeMenuAction.MoreDetails(node)) },
                     onLongClick = { menuExpanded = true },
                     interactionSource = inputChipInteractionSource,

app/src/main/java/com/geeksville/mesh/ui/node/components/NodeItem.kt

@@ -65,7 +65,6 @@ import com.geeksville.mesh.util.toDistanceString
 fun NodeItem(
     thisNode: Node?,
     thatNode: Node,
-    gpsFormat: Int,
     distanceUnits: Int,
     tempInFahrenheit: Boolean,
     modifier: Modifier = Modifier,
@@ -79,76 +78,64 @@ fun NodeItem(
     val longName = thatNode.user.longName.ifEmpty { stringResource(id = R.string.unknown_username) }
     val isThisNode = remember(thatNode) { thisNode?.num == thatNode.num }
     val system = remember(distanceUnits) { DisplayConfig.DisplayUnits.forNumber(distanceUnits) }
-    val distance = remember(thisNode, thatNode) {
-        thisNode?.distance(thatNode)?.takeIf { it > 0 }?.toDistanceString(system)
-    }
+    val distance =
+        remember(thisNode, thatNode) { thisNode?.distance(thatNode)?.takeIf { it > 0 }?.toDistanceString(system) }
 
-    val hwInfoString = when (val hwModel = thatNode.user.hwModel) {
-        MeshProtos.HardwareModel.UNSET -> MeshProtos.HardwareModel.UNSET.name
-        else -> hwModel.name.replace('_', '-').replace('p', '.').lowercase()
-    }
-    val roleName = if (thatNode.isUnknownUser) {
-        DeviceConfig.Role.UNRECOGNIZED.name
-    } else {
-        thatNode.user.role.name
-    }
+    val hwInfoString =
+        when (val hwModel = thatNode.user.hwModel) {
+            MeshProtos.HardwareModel.UNSET -> MeshProtos.HardwareModel.UNSET.name
+            else -> hwModel.name.replace('_', '-').replace('p', '.').lowercase()
+        }
+    val roleName =
+        if (thatNode.isUnknownUser) {
+            DeviceConfig.Role.UNRECOGNIZED.name
+        } else {
+            thatNode.user.role.name
+        }
 
-    val style = if (thatNode.isUnknownUser) {
-        LocalTextStyle.current.copy(fontStyle = FontStyle.Italic)
-    } else {
-        LocalTextStyle.current
-    }
+    val style =
+        if (thatNode.isUnknownUser) {
+            LocalTextStyle.current.copy(fontStyle = FontStyle.Italic)
+        } else {
+            LocalTextStyle.current
+        }
 
-    val cardColors = if (isThisNode) {
-        thisNode?.colors?.second
-    } else {
-        thatNode.colors.second
-    }?.let {
-        val containerColor = Color(it).copy(alpha = 0.2f)
-        CardDefaults.cardColors().copy(
-            containerColor = containerColor,
-            contentColor = contentColorFor(containerColor)
-        )
-    } ?: (CardDefaults.cardColors())
+    val cardColors =
+        if (isThisNode) {
+            thisNode?.colors?.second
+        } else {
+            thatNode.colors.second
+        }
+            ?.let {
+                val containerColor = Color(it).copy(alpha = 0.2f)
+                CardDefaults.cardColors()
+                    .copy(containerColor = containerColor, contentColor = contentColorFor(containerColor))
+            } ?: (CardDefaults.cardColors())
 
     val (detailsShown, showDetails) = remember { mutableStateOf(expanded) }
-    val unmessageable = remember(thatNode) {
-        when {
-            thatNode.user.hasIsUnmessagable() -> thatNode.user.isUnmessagable
-            else -> thatNode.user.role.isUnmessageableRole()
+    val unmessageable =
+        remember(thatNode) {
+            when {
+                thatNode.user.hasIsUnmessagable() -> thatNode.user.isUnmessagable
+                else -> thatNode.user.role.isUnmessageableRole()
+            }
         }
-    }
 
     Card(
-        modifier = modifier
-            .fillMaxWidth()
-            .padding(horizontal = 8.dp, vertical = 4.dp)
-            .defaultMinSize(minHeight = 80.dp),
+        modifier =
+        modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp).defaultMinSize(minHeight = 80.dp),
         onClick = { showDetails(!detailsShown) },
-        colors = cardColors
+        colors = cardColors,
     ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(8.dp),
-        ) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically,
-            ) {
-                NodeChip(
-                    node = thatNode,
-                    isThisNode = isThisNode,
-                    isConnected = isConnected,
-                    onAction = onAction,
-                )
+        Column(modifier = Modifier.fillMaxWidth().padding(8.dp)) {
+            Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+                NodeChip(node = thatNode, isThisNode = isThisNode, isConnected = isConnected, onAction = onAction)
 
                 NodeKeyStatusIcon(
                     hasPKC = thatNode.hasPKC,
                     mismatchKey = thatNode.mismatchKey,
                     publicKey = thatNode.user.publicKey,
-                    modifier = Modifier.size(32.dp)
+                    modifier = Modifier.size(32.dp),
                 )
                 Text(
                     modifier = Modifier.weight(1f),
@@ -157,34 +144,21 @@ fun NodeItem(
                     textDecoration = TextDecoration.LineThrough.takeIf { isIgnored },
                     softWrap = true,
                 )
-                LastHeardInfo(
-                    lastHeard = thatNode.lastHeard,
-                    currentTimeMillis = currentTimeMillis
-                )
+                LastHeardInfo(lastHeard = thatNode.lastHeard, currentTimeMillis = currentTimeMillis)
                 NodeStatusIcons(
                     isThisNode = isThisNode,
                     isFavorite = isFavorite,
                     isUnmessageable = unmessageable,
-                    isConnected = isConnected
+                    isConnected = isConnected,
                 )
             }
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
+            Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
                 if (distance != null) {
-                    Text(
-                        text = distance,
-                        fontSize = MaterialTheme.typography.labelLarge.fontSize,
-                    )
+                    Text(text = distance, fontSize = MaterialTheme.typography.labelLarge.fontSize)
                 } else {
                     Spacer(modifier = Modifier.width(16.dp))
                 }
-                BatteryInfo(
-                    batteryLevel = thatNode.batteryLevel,
-                    voltage = thatNode.voltage
-                )
+                BatteryInfo(batteryLevel = thatNode.batteryLevel, voltage = thatNode.voltage)
             }
             Spacer(modifier = Modifier.height(4.dp))
             Row(
@@ -192,10 +166,7 @@ fun NodeItem(
                 horizontalArrangement = Arrangement.SpaceBetween,
                 verticalAlignment = Alignment.CenterVertically,
             ) {
-                SignalInfo(
-                    node = thatNode,
-                    isThisNode = isThisNode
-                )
+                SignalInfo(node = thatNode, isThisNode = isThisNode)
                 thatNode.validPosition?.let { position ->
                     val satCount = position.satsInView
                     if (satCount > 0) {
@@ -204,10 +175,7 @@ fun NodeItem(
                 }
             }
             Spacer(modifier = Modifier.height(4.dp))
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
+            Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
                 val telemetryString = thatNode.getTelemetryString(tempInFahrenheit)
                 if (telemetryString.isNotEmpty()) {
                     Text(
@@ -222,31 +190,24 @@ fun NodeItem(
                 Spacer(modifier = Modifier.height(8.dp))
                 HorizontalDivider()
                 Spacer(modifier = Modifier.height(8.dp))
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                ) {
+                Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
                     thatNode.validPosition?.let {
                         LinkedCoordinates(
                             latitude = thatNode.latitude,
                             longitude = thatNode.longitude,
-                            format = gpsFormat,
-                            nodeName = longName
+                            nodeName = longName,
                         )
                     }
                     thatNode.validPosition?.let { position ->
                         ElevationInfo(
                             altitude = position.altitude,
                             system = system,
-                            suffix = stringResource(id = R.string.elevation_suffix)
+                            suffix = stringResource(id = R.string.elevation_suffix),
                         )
                     }
                 }
                 Spacer(modifier = Modifier.height(4.dp))
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                ) {
+                Row(modifier = Modifier.fillMaxWidth()) {
                     Text(
                         modifier = Modifier.weight(1f),
                         text = hwInfoString,
@@ -279,50 +240,29 @@ fun NodeInfoSimplePreview() {
     AppTheme {
         val thisNode = NodePreviewParameterProvider().values.first()
         val thatNode = NodePreviewParameterProvider().values.last()
-        NodeItem(
-            thisNode = thisNode,
-            thatNode = thatNode,
-            1,
-            0,
-            true,
-            currentTimeMillis = System.currentTimeMillis(),
-        )
+        NodeItem(thisNode = thisNode, thatNode = thatNode, 0, true, currentTimeMillis = System.currentTimeMillis())
     }
 }
 
 @Composable
-@Preview(
-    showBackground = true,
-    uiMode = Configuration.UI_MODE_NIGHT_YES,
-)
-fun NodeInfoPreview(
-    @PreviewParameter(NodePreviewParameterProvider::class)
-    thatNode: Node
-) {
+@Preview(showBackground = true, uiMode = Configuration.UI_MODE_NIGHT_YES)
+fun NodeInfoPreview(@PreviewParameter(NodePreviewParameterProvider::class) thatNode: Node) {
     AppTheme {
         val thisNode = NodePreviewParameterProvider().values.first()
         Column {
-            Text(
-                text = "Details Collapsed",
-                color = MaterialTheme.colorScheme.onBackground
-            )
+            Text(text = "Details Collapsed", color = MaterialTheme.colorScheme.onBackground)
             NodeItem(
                 thisNode = thisNode,
                 thatNode = thatNode,
-                gpsFormat = 0,
                 distanceUnits = 1,
                 tempInFahrenheit = true,
                 expanded = false,
                 currentTimeMillis = System.currentTimeMillis(),
             )
-            Text(
-                text = "Details Shown",
-                color = MaterialTheme.colorScheme.onBackground
-            )
+            Text(text = "Details Shown", color = MaterialTheme.colorScheme.onBackground)
             NodeItem(
                 thisNode = thisNode,
                 thatNode = thatNode,
-                gpsFormat = 0,
                 distanceUnits = 1,
                 tempInFahrenheit = true,
                 expanded = true,