Perplexity Computer
4226 lines
204 KiB
Kotlin
4226 lines
204 KiB
Kotlin
package de.waypointaudio.ui
|
||
|
||
import android.Manifest
|
||
import android.annotation.SuppressLint
|
||
import android.content.pm.PackageManager
|
||
import android.graphics.Bitmap
|
||
import android.graphics.Canvas
|
||
import android.graphics.Paint
|
||
import android.os.Looper
|
||
import androidx.compose.animation.AnimatedVisibility
|
||
import androidx.compose.animation.fadeIn
|
||
import androidx.compose.animation.fadeOut
|
||
import androidx.compose.animation.slideInVertically
|
||
import androidx.compose.animation.slideOutVertically
|
||
import androidx.compose.foundation.clickable
|
||
import androidx.compose.foundation.layout.Arrangement
|
||
import androidx.compose.foundation.layout.Box
|
||
import androidx.compose.foundation.layout.Column
|
||
import androidx.compose.foundation.layout.Row
|
||
import androidx.compose.foundation.layout.Spacer
|
||
import androidx.compose.foundation.layout.fillMaxSize
|
||
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.RoundedCornerShape
|
||
import androidx.compose.material.icons.Icons
|
||
import androidx.compose.material.icons.automirrored.filled.ArrowBack
|
||
import androidx.compose.material.icons.filled.AddLocation
|
||
import androidx.compose.material.icons.filled.AltRoute
|
||
import androidx.compose.material.icons.filled.Bookmarks
|
||
import androidx.compose.material.icons.filled.Flag
|
||
import androidx.compose.material.icons.filled.Delete
|
||
import androidx.compose.material.icons.filled.Edit
|
||
import androidx.compose.material.icons.filled.Explore
|
||
import androidx.compose.material.icons.filled.FiberManualRecord
|
||
import androidx.compose.material.icons.filled.GpsFixed
|
||
import androidx.compose.material.icons.filled.GpsOff
|
||
import androidx.compose.material.icons.filled.MovieFilter
|
||
import androidx.compose.material.icons.filled.MyLocation
|
||
import androidx.compose.material.icons.filled.OpenWith
|
||
import androidx.compose.material.icons.filled.Pause
|
||
import androidx.compose.material.icons.filled.PinDrop
|
||
import androidx.compose.material.icons.filled.Place
|
||
import androidx.compose.material.icons.filled.PlayArrow
|
||
import androidx.compose.material.icons.filled.Search
|
||
import androidx.compose.material.icons.filled.Stop
|
||
import androidx.compose.material.icons.filled.Timeline
|
||
import androidx.compose.material.icons.filled.Explore
|
||
import androidx.compose.material.icons.filled.NearMe
|
||
import androidx.compose.material.icons.filled.Navigation
|
||
import androidx.compose.material.icons.filled.TouchApp
|
||
import androidx.compose.foundation.layout.height
|
||
import androidx.compose.foundation.layout.heightIn
|
||
import androidx.compose.foundation.rememberScrollState
|
||
import androidx.compose.foundation.verticalScroll
|
||
import androidx.compose.material3.AlertDialog
|
||
import androidx.compose.material3.CircularProgressIndicator
|
||
import androidx.compose.material3.Snackbar
|
||
import androidx.compose.material3.SnackbarHost
|
||
import androidx.compose.material3.SnackbarHostState
|
||
import androidx.compose.material3.Button
|
||
import androidx.compose.material3.ButtonDefaults
|
||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||
import androidx.compose.material3.ExtendedFloatingActionButton
|
||
import androidx.compose.material3.FilterChip
|
||
import androidx.compose.material3.FloatingActionButton
|
||
import androidx.compose.material3.Icon
|
||
import androidx.compose.material3.IconButton
|
||
import androidx.compose.material3.MaterialTheme
|
||
import androidx.compose.material3.ModalBottomSheet
|
||
import androidx.compose.material3.Scaffold
|
||
import androidx.compose.material3.SmallFloatingActionButton
|
||
import androidx.compose.material3.surfaceColorAtElevation
|
||
import androidx.compose.material3.Surface
|
||
import androidx.compose.material3.Text
|
||
import androidx.compose.material3.TextButton
|
||
import androidx.compose.material3.TopAppBar
|
||
import androidx.compose.material3.TopAppBarDefaults
|
||
import androidx.compose.material3.rememberModalBottomSheetState
|
||
import androidx.compose.runtime.Composable
|
||
import androidx.compose.runtime.DisposableEffect
|
||
import androidx.compose.runtime.LaunchedEffect
|
||
import androidx.compose.runtime.collectAsState
|
||
import androidx.compose.runtime.getValue
|
||
import androidx.compose.runtime.mutableStateMapOf
|
||
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.graphics.toArgb
|
||
import androidx.compose.ui.text.font.FontWeight
|
||
import androidx.compose.ui.unit.sp
|
||
import androidx.compose.ui.platform.LocalContext
|
||
import androidx.compose.ui.platform.LocalUriHandler
|
||
import androidx.compose.ui.res.stringResource
|
||
import androidx.compose.ui.unit.dp
|
||
import androidx.compose.ui.viewinterop.AndroidView
|
||
import androidx.core.content.ContextCompat
|
||
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 de.waypointaudio.R
|
||
import de.waypointaudio.data.ExplorerSettingsStore
|
||
import de.waypointaudio.data.GpsTrackPoint
|
||
import de.waypointaudio.data.MapBaseStyle
|
||
import de.waypointaudio.data.MapStyleSettings
|
||
import de.waypointaudio.data.MapStyleStore
|
||
import de.waypointaudio.data.PoiCategory
|
||
import de.waypointaudio.data.PoiLayerSettings
|
||
import de.waypointaudio.data.TrackDraft
|
||
import de.waypointaudio.data.Waypoint
|
||
import de.waypointaudio.util.ExplorerPoiClient
|
||
import de.waypointaudio.util.ExplorerPoiResult
|
||
import de.waypointaudio.util.LatLngBbox
|
||
import de.waypointaudio.util.WaypointAudioDuration
|
||
import de.waypointaudio.viewmodel.WaypointViewModel
|
||
import kotlinx.coroutines.Dispatchers
|
||
import kotlinx.coroutines.Job
|
||
import kotlinx.coroutines.delay
|
||
import kotlinx.coroutines.launch
|
||
import kotlinx.coroutines.withContext
|
||
import de.waypointaudio.util.PoiSubtype
|
||
import org.maplibre.android.annotations.IconFactory
|
||
import org.maplibre.android.annotations.Marker
|
||
import org.maplibre.android.annotations.MarkerOptions
|
||
import org.maplibre.android.annotations.Polygon
|
||
import org.maplibre.android.annotations.PolygonOptions
|
||
import org.maplibre.android.annotations.Polyline
|
||
import org.maplibre.android.annotations.PolylineOptions
|
||
import org.maplibre.android.camera.CameraPosition
|
||
import org.maplibre.android.camera.CameraUpdateFactory
|
||
import org.maplibre.android.geometry.LatLng
|
||
import org.maplibre.android.maps.MapLibreMap
|
||
import org.maplibre.android.maps.MapView
|
||
import org.maplibre.android.maps.Style
|
||
|
||
/**
|
||
* v2.4.0 — MapLibre Engine Cutover.
|
||
*
|
||
* Aktiver Renderer im Explorer ist jetzt MapLibre Native (org.maplibre.gl:android-sdk:11.5.0).
|
||
* Die osmdroid-basierte Variante in [ExplorerScreen] bleibt im Quelltext erhalten und
|
||
* dient ausschließlich als interner Fallback — die Standard-Navigation (siehe
|
||
* [MainActivity]) ruft nun [ExplorerScreenMapLibre] auf.
|
||
*
|
||
* Funktionsumfang (Parität zu v2.3.1):
|
||
* - Wegpunkt-Marker (Auswahl/Aktionsdialog mit Clip-Playback)
|
||
* - Wegpunkt setzen via FAB / Tap / LongPress
|
||
* - Eigener Standort + Genauigkeitskreis + Follow-Schalter
|
||
* - Trigger-Radius/Audiozone je Waypoint
|
||
* - Audio-Längen-Ring/Badge (am Marker, layerable)
|
||
* - GPS-Aufzeichnung als Polyline (live/Draft/persistiert)
|
||
* - Routing-Polyline (OSRM-Endpunkt) + POI-MVP
|
||
* - Storyboard-/Planlinie unverändert über BottomSheet
|
||
* - Suche, Drafts-Sheet, persistente Follow-Einstellung
|
||
*
|
||
* Wesentliche Unterschiede zum osmdroid-Renderer:
|
||
* - Karten-Tiles werden als raster source/layer programmatisch erzeugt (kein API-Key).
|
||
* - Perspektive (3D-Vorschau) nutzt jetzt echte MapLibre Pitch/Tilt.
|
||
* - Map-Listener für Follow-Disable verwenden onMoveStart/CameraIdle.
|
||
* - Wegpunkt-/Track-Tap läuft über setOnMarkerClickListener.
|
||
*
|
||
* Clip-Längenlinien (v2.4.0 Korrektur): Diese werden nur noch dann gezeichnet, wenn
|
||
* eine bekannte Geometrie vorliegt (aufgezeichneter Track, Draft, berechnete Route).
|
||
* Ohne Geometrie wird ausschließlich Trigger-Radius/Audiodauer-Badge angezeigt
|
||
* — keine frei projizierten Fantasielinien mehr.
|
||
*/
|
||
@SuppressLint("MissingPermission")
|
||
@OptIn(ExperimentalMaterial3Api::class)
|
||
@Composable
|
||
fun ExplorerScreenMapLibre(
|
||
viewModel: WaypointViewModel,
|
||
onNavigateBack: () -> Unit,
|
||
onOpenInEditor: () -> Unit,
|
||
onOpenDraft: (String) -> Unit = {},
|
||
currentMode: MapMode? = null,
|
||
onModeChange: ((MapMode) -> Unit)? = null
|
||
) {
|
||
val context = LocalContext.current
|
||
val allWaypoints by viewModel.waypoints.collectAsState()
|
||
val selectedTour by viewModel.selectedTour.collectAsState()
|
||
val tourList by viewModel.tourList.collectAsState()
|
||
val tourDefaults by viewModel.tourDefaults.collectAsState()
|
||
val isRecording by viewModel.isRecording.collectAsState()
|
||
val currentTrack by viewModel.currentTrack.collectAsState()
|
||
val persistedTrack by viewModel.persistedTrack.collectAsState()
|
||
val drafts by viewModel.trackDrafts.collectAsState()
|
||
val lastSavedDraftId by viewModel.lastSavedDraftId.collectAsState()
|
||
val singlePlayingWaypointId by viewModel.singlePlayingWaypointId.collectAsState()
|
||
val singlePlayingActive by viewModel.singlePlayingActive.collectAsState()
|
||
// v2.4.6 — Aktive Tourroute (persistente Route der ausgewählten Tour).
|
||
val activeTourRoute by viewModel.activeTourRoute.collectAsState()
|
||
|
||
val waypoints = allWaypoints.filter {
|
||
it.tourName.ifBlank { Waypoint.DEFAULT_TOUR_NAME } == selectedTour
|
||
}
|
||
|
||
val primaryColor = MaterialTheme.colorScheme.primary
|
||
val primaryArgb = primaryColor.toArgb()
|
||
val tertiaryArgb = MaterialTheme.colorScheme.tertiary.toArgb()
|
||
|
||
val settingsStore = remember { ExplorerSettingsStore(context.applicationContext) }
|
||
val persistedSettings by settingsStore.settings.collectAsState(
|
||
initial = de.waypointaudio.data.ExplorerSettings()
|
||
)
|
||
|
||
val mapStyleStore = remember { MapStyleStore(context.applicationContext) }
|
||
val mapStyleSettings by mapStyleStore.settings.collectAsState(
|
||
initial = MapStyleSettings()
|
||
)
|
||
val scope = rememberCoroutineScope()
|
||
|
||
// Audio-Dauer-Cache je Wegpunkt-URI.
|
||
val audioDurationsMs = remember { mutableStateMapOf<String, Long>() }
|
||
LaunchedEffect(waypoints.map { it.soundUri }) {
|
||
for (wp in waypoints) {
|
||
val uri = wp.soundUri
|
||
if (uri.isBlank()) continue
|
||
if (audioDurationsMs.containsKey(uri)) continue
|
||
val d = withContext(Dispatchers.IO) {
|
||
WaypointAudioDuration.resolveDurationMs(context, uri)
|
||
}
|
||
audioDurationsMs[uri] = d
|
||
}
|
||
}
|
||
|
||
var showRoutingInfo by remember { mutableStateOf(false) }
|
||
var showRoutePlanner by remember { mutableStateOf(false) }
|
||
var routeLine by remember { mutableStateOf<List<LatLng>>(emptyList()) }
|
||
var routeStatus by remember { mutableStateOf<String?>(null) }
|
||
var routeLoading by remember { mutableStateOf(false) }
|
||
var showRouteOverlay by remember { mutableStateOf(true) }
|
||
var routePlan by remember { mutableStateOf(RoutePlan()) }
|
||
// v2.4.6 — Distanz/Dauer der zuletzt berechneten Route (für persistente Speicherung).
|
||
var lastComputedDistanceMeters by remember { mutableStateOf<Double?>(null) }
|
||
var lastComputedDurationSeconds by remember { mutableStateOf<Double?>(null) }
|
||
var lastComputedEndpoint by remember { mutableStateOf<String>("") }
|
||
|
||
// v2.5.35 — Phantom-GPX-Line-Fix: Im neutralen Standard-Kontext (keine laufende
|
||
// Aufzeichnung, kein aktiver Draft) dürfen keine persistierten Linien angezeigt
|
||
// werden. isNeutralStandard ist true, wenn die aktuelle Tour die Standardtour ist
|
||
// UND kein eigener aktiver Kontext (Aufzeichnung / Draft) vorliegt.
|
||
// isNeutralStandard wird auch für visibleTrack verwendet (s. u.).
|
||
val isNeutralStandard: Boolean =
|
||
selectedTour == de.waypointaudio.data.Waypoint.DEFAULT_TOUR_NAME
|
||
|
||
// v2.4.6 — Gespeicherte Tourroute als sekundäre Quelle für Clip-Linien
|
||
// und als Visualisierung, wenn keine aktuelle Route/Planlinie aktiv ist.
|
||
// v2.5.3 — Manuelle Routen werden separat (als manualRoutePolylines)
|
||
// gezeichnet und über manualRoutePoints dargestellt. Hier liefern wir
|
||
// sie deshalb NICHT als saved-route, damit sie nicht doppelt erscheinen.
|
||
// v2.5.35 — Im neutralen Standard-Kontext (isNeutralStandard + keine Aufzeichnung
|
||
// + kein Draft) wird savedRouteLine explizit leer gehalten, damit keine alte
|
||
// persistierte TourRoute als Phantom-Linie erscheint. Daten werden NICHT gelöscht.
|
||
val savedRouteLine: List<LatLng> = remember(activeTourRoute, isNeutralStandard, isRecording) {
|
||
val r = activeTourRoute
|
||
if (r == null || r.source == de.waypointaudio.data.RouteSourceKind.MANUAL) emptyList()
|
||
// Phantom-Guard: Für die Standardtour keine gespeicherte Route zeigen,
|
||
// solange keine Aufzeichnung läuft (aktiver Draft wird unten behandelt).
|
||
else if (isNeutralStandard && !isRecording) emptyList()
|
||
else r.polyline.map { LatLng(it.lat, it.lon) }
|
||
}
|
||
|
||
// Beim Wechsel der ausgewählten Tour: Plan und berechnete Route verwerfen,
|
||
// damit der Routenplaner nicht eine fremde Route der Vortour zeigt.
|
||
//
|
||
// v2.5.2 — Wenn die neue Tour eine gespeicherte TourRoute hat, wird deren
|
||
// Profil als Default in den frischen Plan übernommen. So bleibt das
|
||
// Fortbewegungsmittel beim Neuberechnen konsistent zur gespeicherten Route.
|
||
LaunchedEffect(selectedTour, activeTourRoute?.id) {
|
||
val storedProfile = RoutingProfile.fromKey(activeTourRoute?.profile)
|
||
routePlan = RoutePlan(profile = storedProfile)
|
||
routeLine = emptyList()
|
||
routeStatus = null
|
||
lastComputedDistanceMeters = null
|
||
lastComputedDurationSeconds = null
|
||
lastComputedEndpoint = ""
|
||
}
|
||
// Planlinie wird automatisch aus dem Plan abgeleitet — Luftlinie zwischen
|
||
// Start/Via/Ziel. Sie ersetzt die Route nur, wenn keine echte Route da ist
|
||
// (kein konfigurierter Endpunkt oder Fehler).
|
||
val routePlanline: List<LatLng> = remember(routePlan) {
|
||
routePlan.orderedStops().map { LatLng(it.latitude, it.longitude) }
|
||
.takeIf { it.size >= 2 } ?: emptyList()
|
||
}
|
||
val routingPoiCtx = LocalContext.current
|
||
|
||
// MapLibre-spezifische State-Halter
|
||
var mapView by remember { mutableStateOf<MapView?>(null) }
|
||
var mapLibreMap by remember { mutableStateOf<MapLibreMap?>(null) }
|
||
var styleReady by remember { mutableStateOf(false) }
|
||
|
||
// Annotation-Caches: wir entfernen/erzeugen pro Update neu, halten aber die
|
||
// Referenzen zu den eigenen Annotations, um sie gezielt löschen zu können.
|
||
val waypointMarkers = remember { mutableListOf<Marker>() }
|
||
val waypointMarkerIdToWaypoint = remember { mutableMapOf<Long, Waypoint>() }
|
||
val waypointRadiusPolygons = remember { mutableListOf<Polygon>() }
|
||
val trackMarkers = remember { mutableListOf<Marker>() }
|
||
val trackMarkerIdToIndex = remember { mutableMapOf<Long, Int>() }
|
||
val trackPolylines = remember { mutableListOf<Polyline>() }
|
||
val routePolylines = remember { mutableListOf<Polyline>() }
|
||
val planlinePolylines = remember { mutableListOf<Polyline>() }
|
||
val routeStopMarkers = remember { mutableListOf<Marker>() }
|
||
val audioLinePolylines = remember { mutableListOf<Polyline>() }
|
||
// v2.5.3 — Annotations der manuell gezeichneten Route.
|
||
val manualRoutePolylines = remember { mutableListOf<Polyline>() }
|
||
val manualRouteMarkers = remember { mutableListOf<Marker>() }
|
||
val manualRouteMarkerIdToIndex = remember { mutableMapOf<Long, Int>() }
|
||
var myLocationMarker by remember { mutableStateOf<Marker?>(null) }
|
||
var accuracyPolygon by remember { mutableStateOf<Polygon?>(null) }
|
||
var searchPinMarker by remember { mutableStateOf<Marker?>(null) }
|
||
|
||
// v2.5.40 — Explorer-POI-State
|
||
val explorerPoiMarkers = remember { mutableListOf<Marker>() }
|
||
val explorerPoiMarkerIdToResult = remember { mutableMapOf<Long, ExplorerPoiResult>() }
|
||
var explorerPoiResults by remember { mutableStateOf<Map<PoiCategory, List<ExplorerPoiResult>>>(emptyMap()) }
|
||
var explorerPoiLoading by remember { mutableStateOf(false) }
|
||
var explorerPoiSnackbar by remember { mutableStateOf<String?>(null) }
|
||
var selectedExplorerPoi by remember { mutableStateOf<ExplorerPoiResult?>(null) }
|
||
// v2.5.42 — Legende standardmäßig eingeklappt
|
||
var poiLegendExpanded by remember { mutableStateOf(false) }
|
||
var currentMapZoom by remember { mutableStateOf(13.0) }
|
||
val snackbarHostState = remember { SnackbarHostState() }
|
||
|
||
// v2.5.45 — Auto-POI-Load State
|
||
var autoPoiLoadEnabled by remember { mutableStateOf(true) } // standardmäßig aktiviert
|
||
var poiAutoLoadJob by remember { mutableStateOf<Job?>(null) }
|
||
var lastAutoLoadLat by remember { mutableStateOf<Double?>(null) }
|
||
var lastAutoLoadLon by remember { mutableStateOf<Double?>(null) }
|
||
var lastAutoLoadZoom by remember { mutableStateOf<Double?>(null) }
|
||
var lastAutoLoadCats by remember { mutableStateOf<Set<de.waypointaudio.data.PoiCategory>?>(null) }
|
||
var autoPoiStatus by remember { mutableStateOf<String?>(null) } // kurzer Status-Text
|
||
|
||
var lastLat by remember { mutableStateOf<Double?>(null) }
|
||
var lastLng by remember { mutableStateOf<Double?>(null) }
|
||
var lastAccuracyM by remember { mutableStateOf<Float?>(null) }
|
||
var hasPermission by remember {
|
||
mutableStateOf(
|
||
ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED ||
|
||
ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
|
||
)
|
||
}
|
||
|
||
var followLocation by remember { mutableStateOf(persistedSettings.followLocation) }
|
||
var followInitialized by remember { mutableStateOf(false) }
|
||
LaunchedEffect(persistedSettings.followLocation) {
|
||
if (!followInitialized) {
|
||
followLocation = persistedSettings.followLocation
|
||
followInitialized = true
|
||
}
|
||
}
|
||
|
||
var actionMenuWaypoint by remember { mutableStateOf<Waypoint?>(null) }
|
||
var editDialogWaypoint by remember { mutableStateOf<Waypoint?>(null) }
|
||
var editDialogPrefill by remember { mutableStateOf<Pair<Double, Double>?>(null) }
|
||
var showEditDialog by remember { mutableStateOf(false) }
|
||
var deleteConfirm by remember { mutableStateOf<Waypoint?>(null) }
|
||
var tapMode by remember { mutableStateOf<TapModeMl>(TapModeMl.None) }
|
||
|
||
// v2.5.3 — Manueller Routemodus ("Route zeichnen").
|
||
// Die `manualRoutePoints`-Liste hält den aktuellen Wegverlauf rein lokal
|
||
// (LatLng). Stille Punkte: Sie erscheinen NICHT in der Wegpunkt-/Track-Liste,
|
||
// lösen KEIN Audio aus, beeinflussen KEINE Clip-/Audio-Funktionen.
|
||
// Persistenz: bei jeder Änderung wird in [TourRoute] mit
|
||
// [RouteSourceKind.MANUAL] gespeichert. Beim Tour-Wechsel laden wir die
|
||
// gespeicherte manuelle Route falls vorhanden.
|
||
var manualRouteMode by remember { mutableStateOf(false) }
|
||
var manualRoutePoints by remember { mutableStateOf<List<LatLng>>(emptyList()) }
|
||
var selectedRoutePointIndex by remember { mutableStateOf<Int?>(null) }
|
||
var showRoutePointDialog by remember { mutableStateOf(false) }
|
||
|
||
// Beim Tour-Wechsel: bestehende manuelle Route laden.
|
||
// v2.5.35 — Phantom-Guard: Für die Standardtour keine manuelle Route laden,
|
||
// die aus einem früheren Zeichnen-Vorgang ohne explizite Tour-Auswahl stammt.
|
||
LaunchedEffect(selectedTour, activeTourRoute?.id, activeTourRoute?.source) {
|
||
val r = activeTourRoute
|
||
manualRoutePoints = if (
|
||
r?.source == de.waypointaudio.data.RouteSourceKind.MANUAL
|
||
&& !isNeutralStandard // Phantom-Guard: Standardtour bleibt leer
|
||
) {
|
||
r.polyline.map { LatLng(it.lat, it.lon) }
|
||
} else emptyList()
|
||
// Modus aufheben, damit man nicht versehentlich weiterzeichnet
|
||
if (manualRouteMode) manualRouteMode = false
|
||
if (tapMode is TapModeMl.DrawRoutePoint || tapMode is TapModeMl.MoveRoutePoint) {
|
||
tapMode = TapModeMl.None
|
||
}
|
||
selectedRoutePointIndex = null
|
||
showRoutePointDialog = false
|
||
}
|
||
|
||
// Auto-Save: jede Änderung der manuellen Route in TourRoute persistieren.
|
||
// Beim Leeren wird die Tourroute entfernt (nur, wenn sie zuvor MANUAL war —
|
||
// berechnete Routen bleiben unangetastet).
|
||
LaunchedEffect(manualRoutePoints, selectedTour) {
|
||
val currentSaved = activeTourRoute
|
||
val wasManual = currentSaved?.source == de.waypointaudio.data.RouteSourceKind.MANUAL
|
||
if (manualRoutePoints.isEmpty()) {
|
||
if (wasManual) viewModel.deleteTourRouteForCurrent()
|
||
return@LaunchedEffect
|
||
}
|
||
val polyline = manualRoutePoints.map {
|
||
de.waypointaudio.data.TourRoutePoint(lat = it.latitude, lon = it.longitude)
|
||
}
|
||
val updated = de.waypointaudio.data.TourRoute(
|
||
id = currentSaved?.id?.takeIf { wasManual }
|
||
?: java.util.UUID.randomUUID().toString(),
|
||
polyline = polyline,
|
||
source = de.waypointaudio.data.RouteSourceKind.MANUAL,
|
||
endpoint = "Manuell gezeichnet",
|
||
profile = currentSaved?.profile?.takeIf { wasManual } ?: "",
|
||
createdAtMillis = currentSaved?.createdAtMillis?.takeIf { wasManual }
|
||
?: System.currentTimeMillis(),
|
||
updatedAtMillis = System.currentTimeMillis(),
|
||
)
|
||
viewModel.saveTourRouteForCurrent(updated)
|
||
}
|
||
|
||
val puckBitmap = remember { explorerMlLocationPuckBitmap(context) }
|
||
|
||
var layerState by remember {
|
||
mutableStateOf(MapLayerState(followLocation = persistedSettings.followLocation))
|
||
}
|
||
var styleHydrated by remember { mutableStateOf(false) }
|
||
LaunchedEffect(mapStyleSettings) {
|
||
if (!styleHydrated) {
|
||
// v2.5.38 — Beim ersten Laden alle persistierten Einstellungen übernehmen,
|
||
// inkl. baseStyle (Kartentyp-Persistenz) und poiLayers.
|
||
layerState = layerState.copy(
|
||
baseStyle = mapStyleSettings.baseStyle,
|
||
showAudioLength = mapStyleSettings.showAudioLength,
|
||
showAudioLines = mapStyleSettings.showAudioLines,
|
||
poiLayers = mapStyleSettings.poiLayers,
|
||
)
|
||
styleHydrated = true
|
||
}
|
||
}
|
||
LaunchedEffect(followLocation) {
|
||
if (layerState.followLocation != followLocation) {
|
||
layerState = layerState.copy(followLocation = followLocation)
|
||
}
|
||
runCatching { settingsStore.setFollowLocation(followLocation) }
|
||
}
|
||
LaunchedEffect(layerState.followLocation) {
|
||
if (followLocation != layerState.followLocation) {
|
||
followLocation = layerState.followLocation
|
||
}
|
||
}
|
||
LaunchedEffect(layerState.baseStyle) {
|
||
if (styleHydrated && layerState.baseStyle != mapStyleSettings.baseStyle) {
|
||
runCatching { mapStyleStore.setBaseStyle(layerState.baseStyle) }
|
||
}
|
||
}
|
||
LaunchedEffect(layerState.showAudioLength) {
|
||
if (styleHydrated && layerState.showAudioLength != mapStyleSettings.showAudioLength) {
|
||
runCatching { mapStyleStore.setShowAudioLength(layerState.showAudioLength) }
|
||
}
|
||
}
|
||
LaunchedEffect(layerState.showAudioLines) {
|
||
if (styleHydrated && layerState.showAudioLines != mapStyleSettings.showAudioLines) {
|
||
runCatching { mapStyleStore.setShowAudioLines(layerState.showAudioLines) }
|
||
}
|
||
}
|
||
// v2.5.38 — POI-Layer-Auswahl persistent speichern.
|
||
// v2.5.45 — Bei Kategorie-Änderung: Cache leeren und Auto-Load-Cursor zurücksetzen.
|
||
LaunchedEffect(layerState.poiLayers) {
|
||
if (styleHydrated && layerState.poiLayers != mapStyleSettings.poiLayers) {
|
||
runCatching { mapStyleStore.setPoiLayers(layerState.poiLayers) }
|
||
}
|
||
// Kategorie-Wechsel → nächster Camera-Idle lädt frisch
|
||
lastAutoLoadCats = null
|
||
de.waypointaudio.util.ExplorerPoiClient.clearCache()
|
||
}
|
||
// v2.5.38 — POI-Sichtbarkeit auf den geladenen MapLibre-Style anwenden.
|
||
// Greift auf heuristische Layer-ID-Präfixe des OpenMapTiles-Schemas zurück.
|
||
// Wenn ein Layer nicht existiert, passiert nichts (kein Crash).
|
||
LaunchedEffect(layerState.poiLayers, layerState.baseStyle, styleReady) {
|
||
if (!styleReady) return@LaunchedEffect
|
||
val ml = mapLibreMap ?: return@LaunchedEffect
|
||
val style = ml.style ?: return@LaunchedEffect
|
||
// Klassisch (Raster): keine Vektor-Layer anwendbar.
|
||
if (layerState.baseStyle == MapBaseStyle.CLASSIC ||
|
||
layerState.baseStyle == MapBaseStyle.SATELLITE) return@LaunchedEffect
|
||
applyPoiLayerVisibility(style, layerState.poiLayers)
|
||
}
|
||
|
||
// v2.5.40 — Snackbar-Anzeige für Explorer-POI-Meldungen
|
||
LaunchedEffect(explorerPoiSnackbar) {
|
||
val msg = explorerPoiSnackbar ?: return@LaunchedEffect
|
||
snackbarHostState.showSnackbar(msg)
|
||
explorerPoiSnackbar = null
|
||
}
|
||
|
||
// v2.5.42 — Namen-Labels über Toggle (nicht mehr zoom-abhängig automatisch)
|
||
val showPoiNames = layerState.poiLayers.showPoiNames
|
||
|
||
// v2.5.42 — Explorer-POI-Marker zeichnen/aktualisieren.
|
||
// Schlüssel inkl. showPoiNames: Marker werden bei Toggle-Änderung neu gezeichnet.
|
||
// Fix: Kategorie-Bitmap wird per buildExplorerPoiIcon(cat, showPoiNames, name) mit
|
||
// eindeutiger Kategorie-Kennung erzeugt — verhindert Icon-Cache-Kollisionen in MapLibre.
|
||
// v2.5.46 — Atomare POI-Marker-Aktualisierung: erst neue Marker hinzufügen,
|
||
// dann alte entfernen. So gibt es keine sichtbare Lücke (kein Flackern) beim
|
||
// Kartennachladen. Außerdem: maximale Anzahl angezeigter Marker auf 280 begrenzt,
|
||
// benannte und wichtige Subtypen werden priorisiert.
|
||
LaunchedEffect(explorerPoiResults, styleReady, showPoiNames) {
|
||
if (!styleReady) return@LaunchedEffect
|
||
val ml = mapLibreMap ?: return@LaunchedEffect
|
||
if (explorerPoiResults.isEmpty()) {
|
||
// Nur leeren wenn wirklich leer (z.B. manueller Clear)
|
||
explorerPoiMarkers.forEach { runCatching { ml.removeMarker(it) } }
|
||
explorerPoiMarkers.clear()
|
||
explorerPoiMarkerIdToResult.clear()
|
||
return@LaunchedEffect
|
||
}
|
||
|
||
val iconFactory = IconFactory.getInstance(context)
|
||
|
||
// v2.5.46 — POI-Dichte-Begrenzung: max. 280 Marker pro Viewport,
|
||
// priorisiere benannte POIs und wichtige Subtypen.
|
||
val MAX_VISIBLE_POIS = 280
|
||
val importantSubtypes = setOf(
|
||
de.waypointaudio.util.PoiSubtype.CASTLE,
|
||
de.waypointaudio.util.PoiSubtype.CHURCH,
|
||
de.waypointaudio.util.PoiSubtype.MUSEUM,
|
||
de.waypointaudio.util.PoiSubtype.VIEWPOINT,
|
||
de.waypointaudio.util.PoiSubtype.MONUMENT,
|
||
de.waypointaudio.util.PoiSubtype.TRAIN_STATION,
|
||
de.waypointaudio.util.PoiSubtype.HOSPITAL,
|
||
de.waypointaudio.util.PoiSubtype.PHARMACY,
|
||
)
|
||
// Alle POIs flach aufsammeln, sortieren (benannte + wichtige zuerst)
|
||
val allPois: List<Pair<de.waypointaudio.data.PoiCategory, de.waypointaudio.util.ExplorerPoiResult>> =
|
||
explorerPoiResults.flatMap { (cat, pois) -> pois.map { cat to it } }
|
||
val totalCount = allPois.size
|
||
val sortedPois = allPois.sortedWith(
|
||
compareByDescending<Pair<de.waypointaudio.data.PoiCategory, de.waypointaudio.util.ExplorerPoiResult>> {
|
||
val poi = it.second
|
||
// Priorität: benannter POI + wichtiger Subtype = höchste Priorität
|
||
val isNamed = poi.displayName.isNotBlank() && poi.displayName != poi.subtype.displayLabel
|
||
val isImportant = poi.subtype in importantSubtypes
|
||
when {
|
||
isNamed && isImportant -> 3
|
||
isNamed -> 2
|
||
isImportant -> 1
|
||
else -> 0
|
||
}
|
||
}
|
||
)
|
||
val visiblePois = if (totalCount > MAX_VISIBLE_POIS) sortedPois.take(MAX_VISIBLE_POIS) else sortedPois
|
||
val shownCount = visiblePois.size
|
||
|
||
// v2.5.46 — Status-Text (zeigt "N von M" wenn begrenzt)
|
||
if (totalCount > MAX_VISIBLE_POIS) {
|
||
autoPoiStatus = "POIs: $shownCount von $totalCount angezeigt"
|
||
}
|
||
|
||
// Neue Marker aufbauen (noch nicht auf der Karte)
|
||
val newMarkers = mutableListOf<org.maplibre.android.annotations.Marker>()
|
||
val newMarkerIdToResult = mutableMapOf<Long, de.waypointaudio.util.ExplorerPoiResult>()
|
||
|
||
for ((cat, poi) in visiblePois) {
|
||
// v2.5.45 — Subtype-Icon: Piktogramm variiert nach Untertyp, Farbe bleibt Kategorie
|
||
val iconBitmap = if (showPoiNames) {
|
||
buildExplorerPoiIconWithLabel(cat, poi.subtype, poi.displayName)
|
||
} else {
|
||
buildExplorerPoiIcon(cat, poi.subtype)
|
||
}
|
||
val icon = iconFactory.fromBitmap(iconBitmap)
|
||
val mo = MarkerOptions()
|
||
.position(LatLng(poi.latitude, poi.longitude))
|
||
.title(poi.displayName)
|
||
.snippet(poi.subtype.displayLabel) // v2.5.45: Subtype-Label statt categoryLabel
|
||
.icon(icon)
|
||
val marker = runCatching { ml.addMarker(mo) }.getOrNull() ?: continue
|
||
newMarkers.add(marker)
|
||
newMarkerIdToResult[marker.id] = poi
|
||
}
|
||
|
||
// v2.5.46 — ERST nach Hinzufügen der neuen Marker die alten entfernen
|
||
// → atomare Aktualisierung ohne sichtbare Lücke / Flackern
|
||
explorerPoiMarkers.forEach { runCatching { ml.removeMarker(it) } }
|
||
explorerPoiMarkers.clear()
|
||
explorerPoiMarkerIdToResult.clear()
|
||
|
||
explorerPoiMarkers.addAll(newMarkers)
|
||
explorerPoiMarkerIdToResult.putAll(newMarkerIdToResult)
|
||
}
|
||
|
||
var showSearchDialog by remember { mutableStateOf(false) }
|
||
var searchPin by remember { mutableStateOf<LatLng?>(null) }
|
||
var showDraftsSheet by remember { mutableStateOf(false) }
|
||
var showStoryboardSheet by remember { mutableStateOf(false) }
|
||
var showDraftPointMenu by remember { mutableStateOf<DraftPointSelectionMl?>(null) }
|
||
var activeDraftId by remember { mutableStateOf<String?>(null) }
|
||
val activeDraft = activeDraftId?.let { id -> drafts.firstOrNull { it.id == id } }
|
||
var selectedTrackIndex by remember { mutableStateOf<Int?>(null) }
|
||
|
||
LaunchedEffect(lastSavedDraftId) {
|
||
val id = lastSavedDraftId
|
||
if (id != null) {
|
||
activeDraftId = id
|
||
showDraftsSheet = true
|
||
viewModel.consumeLastSavedDraftId()
|
||
}
|
||
}
|
||
|
||
// v2.5.36 — Phantom-Guard für persistedTrack (verschärft):
|
||
// Im neutralen Standard-Kontext (Standardtour, keine Aufzeichnung, kein Draft)
|
||
// darf KEIN Track angezeigt werden — weder persistedTrack noch currentTrack
|
||
// aus dem TrackRecordingManager, der beim Tour-Wechsel mit _persistedTrack
|
||
// befüllt wird (v2.5.33-Logik). Die isNeutralStandard-Prüfung muss deshalb
|
||
// VOR der currentTrack.isNotEmpty()-Prüfung stehen, da der Manager-Track
|
||
// sonst die Guard umgeht und die weiße Phantom-Linie weiterhin erscheint.
|
||
val visibleTrack: List<GpsTrackPoint> = when {
|
||
isRecording -> currentTrack
|
||
activeDraft != null -> activeDraft.points
|
||
// Phantom-Guard (v2.5.36): Standardtour ohne aktive Aufzeichnung/Draft
|
||
// → ALLE Tracks (inkl. currentTrack/Manager-Track) unterdrücken.
|
||
// Wird bewusst vor currentTrack.isNotEmpty() geprüft, damit der
|
||
// Manager-Track (aus loadPersistedTrackForCurrentTour) nicht durch
|
||
// die currentTrack-Prüfung sichtbar wird.
|
||
isNeutralStandard -> emptyList()
|
||
currentTrack.isNotEmpty() -> currentTrack
|
||
else -> persistedTrack
|
||
}
|
||
val visibleMarkedIndexes: List<Int> = activeDraft?.markedIndexes ?: emptyList()
|
||
|
||
// v2.5.37 — Style nachziehen, wenn Basis-Stil wechselt.
|
||
// OpenFreeMap Vektor-Stile werden über Style.Builder().fromUri() geladen.
|
||
// CLASSIC nutzt weiterhin den raster-JSON-Weg.
|
||
// Phantom-Layer-Cleanup vor setStyle: alle Annotations-Caches leeren,
|
||
// damit nach styleReady=true ein kompletter Rehydration-Durchlauf startet.
|
||
LaunchedEffect(
|
||
layerState.baseStyle,
|
||
mapStyleSettings.perspectiveTilt,
|
||
styleReady
|
||
) {
|
||
val ml = mapLibreMap ?: return@LaunchedEffect
|
||
if (!styleReady) return@LaunchedEffect
|
||
|
||
// Phantom-Layer-Cleanup vor Stilwechsel.
|
||
styleReady = false
|
||
clearAllAnnotationsCaches(
|
||
waypointMarkers, waypointMarkerIdToWaypoint, waypointRadiusPolygons,
|
||
trackMarkers, trackMarkerIdToIndex, trackPolylines, routePolylines,
|
||
audioLinePolylines,
|
||
manualRoutePolylines, manualRouteMarkers, manualRouteMarkerIdToIndex
|
||
)
|
||
myLocationMarker = null
|
||
accuracyPolygon = null
|
||
searchPinMarker = null
|
||
|
||
val pitchDeg = if (layerState.baseStyle == MapBaseStyle.CITY_3D ||
|
||
layerState.baseStyle == MapBaseStyle.TERRAIN_3D ||
|
||
layerState.baseStyle == MapBaseStyle.PERSPECTIVE) {
|
||
mapStyleSettings.perspectiveTilt.toDouble().coerceIn(0.0, 60.0)
|
||
} else 0.0
|
||
|
||
val onStyleReady: (Style) -> Unit = { loadedStyle ->
|
||
// v2.5.37 — 3D Stadt: Gebäude-Extrusion hinzufügen falls building-Layer vorhanden.
|
||
// Robust: wenn Source/Layer fehlt, kein Crash — einfach 2D-Fallback.
|
||
if (layerState.baseStyle == MapBaseStyle.CITY_3D) {
|
||
try {
|
||
addBuildingExtrusionIfAvailable(loadedStyle)
|
||
} catch (_: Exception) { /* 2D-Fallback: Layer existiert nicht */ }
|
||
}
|
||
// v2.5.38 — POI-Layer-Sichtbarkeit nach Style-Load anwenden.
|
||
if (layerState.baseStyle != MapBaseStyle.CLASSIC &&
|
||
layerState.baseStyle != MapBaseStyle.SATELLITE) {
|
||
try {
|
||
applyPoiLayerVisibility(loadedStyle, layerState.poiLayers)
|
||
} catch (_: Exception) { /* Kein Crash wenn Layer nicht vorhanden */ }
|
||
}
|
||
// Kamera-Pitch setzen.
|
||
val pos = ml.cameraPosition
|
||
ml.cameraPosition = CameraPosition.Builder(pos).tilt(pitchDeg).build()
|
||
styleReady = true
|
||
}
|
||
|
||
when (layerState.baseStyle) {
|
||
MapBaseStyle.MODERN_2D -> {
|
||
ml.setStyle(
|
||
Style.Builder().fromUri("https://tiles.openfreemap.org/styles/positron"),
|
||
onStyleReady
|
||
)
|
||
}
|
||
MapBaseStyle.DARK -> {
|
||
ml.setStyle(
|
||
Style.Builder().fromUri("https://tiles.openfreemap.org/styles/dark"),
|
||
onStyleReady
|
||
)
|
||
}
|
||
MapBaseStyle.OUTDOOR, MapBaseStyle.TOPO -> {
|
||
ml.setStyle(
|
||
Style.Builder().fromUri("https://tiles.openfreemap.org/styles/liberty"),
|
||
onStyleReady
|
||
)
|
||
}
|
||
MapBaseStyle.CITY_3D, MapBaseStyle.TERRAIN_3D, MapBaseStyle.PERSPECTIVE -> {
|
||
// Positron als Basis für 3D-Stadt — nach Laden Gebäude-Extrusion einfügen.
|
||
ml.setStyle(
|
||
Style.Builder().fromUri("https://tiles.openfreemap.org/styles/positron"),
|
||
onStyleReady
|
||
)
|
||
}
|
||
MapBaseStyle.CLASSIC, MapBaseStyle.SATELLITE -> {
|
||
// Klassisch: OSM-Raster-Fallback (JSON-basiert, kein Vektor).
|
||
val classicJson = buildClassicOsmStyleJson()
|
||
ml.setStyle(Style.Builder().fromJson(classicJson), onStyleReady)
|
||
}
|
||
}
|
||
}
|
||
|
||
// Berechnete Routenlinie + Planlinie + Stop-Marker als eigene Polyline-Schicht.
|
||
LaunchedEffect(routeLine, routePlanline, routePlan, showRouteOverlay, styleReady, savedRouteLine) {
|
||
val ml = mapLibreMap ?: return@LaunchedEffect
|
||
if (!styleReady) return@LaunchedEffect
|
||
for (pl in routePolylines) runCatching { ml.removePolyline(pl) }
|
||
routePolylines.clear()
|
||
for (pl in planlinePolylines) runCatching { ml.removePolyline(pl) }
|
||
planlinePolylines.clear()
|
||
for (m in routeStopMarkers) runCatching { ml.removeMarker(m) }
|
||
routeStopMarkers.clear()
|
||
|
||
if (!showRouteOverlay) return@LaunchedEffect
|
||
|
||
// v2.4.5 — Planlinie (Luftlinie zwischen Stops) wird NUR gezeichnet,
|
||
// wenn keine berechnete Route vorhanden ist. Sobald eine echte
|
||
// Routing-Polyline existiert, ist die Planlinie redundant und
|
||
// optisch störend (parallel-laufende dünne Linie auf der Route).
|
||
val hasComputedRoute = routeLine.size >= 2
|
||
if (!hasComputedRoute && routePlanline.size >= 2) {
|
||
val halo = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(routePlanline)
|
||
.color(0xFFFFFFFF.toInt())
|
||
.width(7f)
|
||
.alpha(0.7f)
|
||
)
|
||
val line = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(routePlanline)
|
||
.color(0xFFFF9800.toInt())
|
||
.width(4f)
|
||
.alpha(0.55f)
|
||
)
|
||
planlinePolylines += halo
|
||
planlinePolylines += line
|
||
}
|
||
|
||
// v2.4.6 — Gespeicherte Tourroute zeichnen, wenn keine aktuell berechnete
|
||
// Route vorhanden ist. Sobald `routeLine` aktiv ist, übernimmt diese,
|
||
// damit Live-Berechnung > gespeicherte Tourroute (sichtbare Priorität
|
||
// entspricht der Clip-Linien-Priorität).
|
||
if (routeLine.size < 2 && savedRouteLine.size >= 2) {
|
||
val halo = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(savedRouteLine)
|
||
.color(0xFFFFFFFF.toInt())
|
||
.width(8f)
|
||
.alpha(0.75f)
|
||
)
|
||
val line = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(savedRouteLine)
|
||
// Sichtbar unterscheidbar: tieferes Grün für „dauerhaft gespeichert".
|
||
.color(0xFF2E7D32.toInt())
|
||
.width(5f)
|
||
.alpha(0.9f)
|
||
)
|
||
routePolylines += halo
|
||
routePolylines += line
|
||
}
|
||
|
||
if (routeLine.size >= 2) {
|
||
val halo = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(routeLine)
|
||
.color(0xFFFFFFFF.toInt())
|
||
.width(9f)
|
||
.alpha(0.85f)
|
||
)
|
||
val line = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(routeLine)
|
||
.color(0xFF1976D2.toInt())
|
||
.width(6f)
|
||
.alpha(0.95f)
|
||
)
|
||
routePolylines += halo
|
||
routePolylines += line
|
||
}
|
||
|
||
val iconFactory = IconFactory.getInstance(context)
|
||
// Stop-Marker für Start/Via/Ziel
|
||
routePlan.start?.let { s ->
|
||
val bm = routeStopBitmap(RouteStopKind.START, context)
|
||
routeStopMarkers += ml.addMarker(
|
||
MarkerOptions()
|
||
.position(LatLng(s.latitude, s.longitude))
|
||
.title("Start: ${s.label}")
|
||
.icon(iconFactory.fromBitmap(bm))
|
||
)
|
||
}
|
||
routePlan.via.forEachIndexed { idx, v ->
|
||
val bm = routeStopBitmap(RouteStopKind.VIA, context, label = (idx + 1).toString())
|
||
routeStopMarkers += ml.addMarker(
|
||
MarkerOptions()
|
||
.position(LatLng(v.latitude, v.longitude))
|
||
.title("Via ${idx + 1}: ${v.label}")
|
||
.icon(iconFactory.fromBitmap(bm))
|
||
)
|
||
}
|
||
routePlan.destination?.let { d ->
|
||
val bm = routeStopBitmap(RouteStopKind.DESTINATION, context)
|
||
routeStopMarkers += ml.addMarker(
|
||
MarkerOptions()
|
||
.position(LatLng(d.latitude, d.longitude))
|
||
.title("Ziel: ${d.label}")
|
||
.icon(iconFactory.fromBitmap(bm))
|
||
)
|
||
}
|
||
}
|
||
|
||
// v2.5.3 — Manuelle Route als eigene Schicht zeichnen.
|
||
// Stille Routenpunkte (kleine, dunkle Kreise) + verbindende Linie.
|
||
// Diese Punkte sind KEINE Wegpunkte und werden niemals in der
|
||
// Wegpunktliste, Track-Liste oder Storyboard erscheinen.
|
||
LaunchedEffect(manualRoutePoints, manualRouteMode, styleReady,
|
||
selectedRoutePointIndex, primaryArgb) {
|
||
val ml = mapLibreMap ?: return@LaunchedEffect
|
||
if (!styleReady) return@LaunchedEffect
|
||
for (pl in manualRoutePolylines) runCatching { ml.removePolyline(pl) }
|
||
manualRoutePolylines.clear()
|
||
for (m in manualRouteMarkers) runCatching { ml.removeMarker(m) }
|
||
manualRouteMarkers.clear()
|
||
manualRouteMarkerIdToIndex.clear()
|
||
|
||
if (manualRoutePoints.size >= 2) {
|
||
val halo = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(manualRoutePoints)
|
||
.color(0xFFFFFFFF.toInt())
|
||
.width(8f)
|
||
.alpha(0.75f)
|
||
)
|
||
val line = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(manualRoutePoints)
|
||
// Klar unterscheidbar von OSRM-Routen (blau) und gespeicherten
|
||
// Tourrouten (grün): violett für "manuell gezeichnet".
|
||
.color(0xFF6A1B9A.toInt())
|
||
.width(5f)
|
||
.alpha(0.95f)
|
||
)
|
||
manualRoutePolylines += halo
|
||
manualRoutePolylines += line
|
||
}
|
||
|
||
// Punkt-Marker pro Routenpunkt – klein, ohne Audio-/Wegpunkt-Bezug.
|
||
if (manualRoutePoints.isNotEmpty()) {
|
||
val iconFactory = IconFactory.getInstance(context)
|
||
val sizePx = (context.resources.displayMetrics.density * 14).toInt()
|
||
manualRoutePoints.forEachIndexed { idx, p ->
|
||
val selected = selectedRoutePointIndex == idx
|
||
val bm = trackPointBitmap(sizePx, 0xFF6A1B9A.toInt(), selected)
|
||
val marker = ml.addMarker(
|
||
MarkerOptions()
|
||
.position(p)
|
||
.title("Routenpunkt ${idx + 1}")
|
||
.icon(iconFactory.fromBitmap(bm))
|
||
)
|
||
manualRouteMarkers += marker
|
||
manualRouteMarkerIdToIndex[marker.id] = idx
|
||
}
|
||
}
|
||
}
|
||
|
||
// Haupt-Overlay-Refresh: Wegpunkte, Tracks, Audiozonen, Audio-Längen-Linien,
|
||
// sowie der Search-Pin.
|
||
LaunchedEffect(
|
||
waypoints,
|
||
primaryArgb,
|
||
actionMenuWaypoint?.id,
|
||
visibleTrack,
|
||
visibleMarkedIndexes,
|
||
selectedTrackIndex,
|
||
searchPin,
|
||
layerState,
|
||
audioDurationsMs.toMap(),
|
||
routeLine,
|
||
routePlanline,
|
||
savedRouteLine,
|
||
manualRoutePoints,
|
||
styleReady
|
||
) {
|
||
val ml = mapLibreMap ?: return@LaunchedEffect
|
||
if (!styleReady) return@LaunchedEffect
|
||
drawExplorerOverlaysMapLibre(
|
||
ml = ml,
|
||
context = context,
|
||
waypoints = if (layerState.showMarkers) waypoints else emptyList(),
|
||
track = if (layerState.showTrack) visibleTrack else emptyList(),
|
||
markedIndexes = visibleMarkedIndexes,
|
||
selectedTrackIndex = selectedTrackIndex,
|
||
primaryArgb = primaryArgb,
|
||
trackArgb = tertiaryArgb,
|
||
showRadius = layerState.showRadius,
|
||
showAudioLength = layerState.showAudioLength,
|
||
showAudioLines = layerState.showAudioLines,
|
||
audioDurationsMs = audioDurationsMs.toMap(),
|
||
selectedId = actionMenuWaypoint?.id,
|
||
searchPin = searchPin,
|
||
// v2.4.6: Geometrie für Clip-Längenlinien.
|
||
// Reihenfolge der Priorität (laut Architektur-Abstimmung):
|
||
// 1) Aktuell berechnete Routenlinie (routeLine), wenn vorhanden.
|
||
// 2) Gespeicherte Tourroute (savedRouteLine), wenn vorhanden.
|
||
// 3) Sichtbarer Track/Draft (visibleTrack), wenn mind. 2 Punkte.
|
||
// 4) Explizite Planlinie (routePlanline) als letzte Notlösung.
|
||
// 5) sonst NULL → keine Clip-Linien (nur Radius/Audio-Badge).
|
||
// Damit dominiert eine frisch berechnete Route, dann die fest an
|
||
// der Tour gespeicherte Route, dann der reale Track, und nur ganz
|
||
// zum Schluss eine Planlinie (Luftlinie). Keine freien Linien.
|
||
clipLineGeometry = when {
|
||
routeLine.size >= 2 -> routeLine
|
||
savedRouteLine.size >= 2 -> savedRouteLine
|
||
// v2.5.3 — Manuell gezeichnete Route gilt als Tourverlauf für
|
||
// Clip-Längen entlang bekannter Geometrie. Audio-Waypoints
|
||
// werden weiterhin separat auf Basis ihres soundUri/Dauer
|
||
// gerendert — stille Routenpunkte erzeugen keine Clip-Linien.
|
||
manualRoutePoints.size >= 2 -> manualRoutePoints
|
||
visibleTrack.size >= 2 -> visibleTrack.map { LatLng(it.latitude, it.longitude) }
|
||
routePlanline.size >= 2 -> routePlanline
|
||
else -> null
|
||
},
|
||
waypointMarkers = waypointMarkers,
|
||
waypointMarkerIdToWaypoint = waypointMarkerIdToWaypoint,
|
||
waypointRadiusPolygons = waypointRadiusPolygons,
|
||
trackMarkers = trackMarkers,
|
||
trackMarkerIdToIndex = trackMarkerIdToIndex,
|
||
trackPolylines = trackPolylines,
|
||
audioLinePolylines = audioLinePolylines,
|
||
searchPinMarkerRef = { it -> searchPinMarker = it },
|
||
currentSearchPinMarker = searchPinMarker
|
||
)
|
||
}
|
||
|
||
// Standort-Updates: My-Marker, Genauigkeitskreis, ggf. Follow.
|
||
DisposableEffect(hasPermission) {
|
||
if (!hasPermission) return@DisposableEffect onDispose { }
|
||
val client = LocationServices.getFusedLocationProviderClient(context)
|
||
val req = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 2_000L)
|
||
.setMinUpdateIntervalMillis(1_000L)
|
||
.build()
|
||
val callback = object : LocationCallback() {
|
||
override fun onLocationResult(result: LocationResult) {
|
||
val loc = result.lastLocation ?: return
|
||
lastLat = loc.latitude
|
||
lastLng = loc.longitude
|
||
lastAccuracyM = if (loc.hasAccuracy()) loc.accuracy else null
|
||
val ml = mapLibreMap
|
||
if (ml != null && styleReady) {
|
||
val gp = LatLng(loc.latitude, loc.longitude)
|
||
myLocationMarker?.let { runCatching { ml.removeMarker(it) } }
|
||
myLocationMarker = ml.addMarker(
|
||
MarkerOptions()
|
||
.position(gp)
|
||
.title("Mein Standort")
|
||
.icon(
|
||
puckBitmap?.let { IconFactory.getInstance(context).fromBitmap(it) }
|
||
?: IconFactory.getInstance(context).defaultMarker()
|
||
)
|
||
)
|
||
accuracyPolygon?.let { runCatching { ml.removePolygon(it) } }
|
||
val radius = lastAccuracyM?.toDouble() ?: 0.0
|
||
accuracyPolygon = if (radius > 0.0) {
|
||
ml.addPolygon(
|
||
PolygonOptions()
|
||
.addAll(circleLatLng(loc.latitude, loc.longitude, radius, 60))
|
||
.fillColor((primaryArgb and 0x00FFFFFF) or 0x33000000)
|
||
.strokeColor(primaryArgb)
|
||
.alpha(0.4f)
|
||
)
|
||
} else null
|
||
if (followLocation) {
|
||
val current = ml.cameraPosition
|
||
ml.animateCamera(
|
||
CameraUpdateFactory.newCameraPosition(
|
||
CameraPosition.Builder(current)
|
||
.target(gp)
|
||
.build()
|
||
)
|
||
)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
runCatching {
|
||
client.requestLocationUpdates(req, callback, Looper.getMainLooper())
|
||
}
|
||
onDispose {
|
||
runCatching { client.removeLocationUpdates(callback) }
|
||
}
|
||
}
|
||
|
||
// ─── Dialogs ─────────────────────────────────────────────────────────────
|
||
|
||
actionMenuWaypoint?.let { wp ->
|
||
AlertDialog(
|
||
onDismissRequest = { actionMenuWaypoint = null },
|
||
title = {
|
||
Text(
|
||
text = wp.name.ifBlank { stringResource(R.string.map_waypoint_unnamed) },
|
||
style = MaterialTheme.typography.titleMedium
|
||
)
|
||
},
|
||
text = {
|
||
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||
Text(
|
||
"%.6f, %.6f · %dm".format(
|
||
java.util.Locale.US, wp.latitude, wp.longitude, wp.radiusMeters.toInt()
|
||
),
|
||
style = MaterialTheme.typography.bodySmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.65f)
|
||
)
|
||
val wpDuration = audioDurationsMs[wp.soundUri] ?: 0L
|
||
if (wpDuration > 0L) {
|
||
Text(
|
||
stringResource(
|
||
R.string.explorer_waypoint_audio_duration,
|
||
WaypointAudioDuration.formatShort(wpDuration)
|
||
),
|
||
style = MaterialTheme.typography.labelMedium,
|
||
color = MaterialTheme.colorScheme.primary
|
||
)
|
||
}
|
||
Button(
|
||
onClick = {
|
||
editDialogWaypoint = wp
|
||
editDialogPrefill = null
|
||
showEditDialog = true
|
||
actionMenuWaypoint = null
|
||
},
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.Edit, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_action_edit))
|
||
}
|
||
Button(
|
||
onClick = {
|
||
tapMode = TapModeMl.MoveWaypoint(wp.id)
|
||
actionMenuWaypoint = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.secondaryContainer,
|
||
contentColor = MaterialTheme.colorScheme.onSecondaryContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.OpenWith, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_action_move_tap))
|
||
}
|
||
val hasClip = wp.soundUri.isNotBlank()
|
||
val isThisPlaying = hasClip &&
|
||
singlePlayingWaypointId == wp.id && singlePlayingActive
|
||
Button(
|
||
onClick = {
|
||
if (hasClip) viewModel.manualPlaySingle(wp)
|
||
},
|
||
enabled = hasClip,
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = if (isThisPlaying)
|
||
MaterialTheme.colorScheme.error
|
||
else MaterialTheme.colorScheme.tertiaryContainer,
|
||
contentColor = if (isThisPlaying)
|
||
MaterialTheme.colorScheme.onError
|
||
else MaterialTheme.colorScheme.onTertiaryContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(
|
||
if (isThisPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
|
||
contentDescription = null,
|
||
modifier = Modifier.size(16.dp)
|
||
)
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(
|
||
if (!hasClip)
|
||
stringResource(R.string.explorer_action_no_clip)
|
||
else if (isThisPlaying)
|
||
stringResource(R.string.explorer_action_pause_clip)
|
||
else
|
||
stringResource(R.string.explorer_action_play_clip)
|
||
)
|
||
}
|
||
// v2.4.2 — Wegpunkt direkt in den Routenplaner übernehmen.
|
||
Row(horizontalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) {
|
||
TextButton(
|
||
onClick = {
|
||
routePlan = routePlan.copy(
|
||
start = RouteStop(
|
||
latitude = wp.latitude, longitude = wp.longitude,
|
||
label = wp.name.ifBlank { "Wegpunkt" },
|
||
source = RouteStopSource.WAYPOINT
|
||
)
|
||
)
|
||
actionMenuWaypoint = null
|
||
showRoutePlanner = true
|
||
},
|
||
modifier = Modifier.weight(1f)
|
||
) {
|
||
Text(stringResource(R.string.route_planner_set_as_start))
|
||
}
|
||
TextButton(
|
||
onClick = {
|
||
routePlan = routePlan.copy(
|
||
via = routePlan.via + RouteStop(
|
||
latitude = wp.latitude, longitude = wp.longitude,
|
||
label = wp.name.ifBlank { "Wegpunkt" },
|
||
source = RouteStopSource.WAYPOINT
|
||
)
|
||
)
|
||
actionMenuWaypoint = null
|
||
showRoutePlanner = true
|
||
},
|
||
modifier = Modifier.weight(1f)
|
||
) {
|
||
Text(stringResource(R.string.route_planner_set_as_via))
|
||
}
|
||
TextButton(
|
||
onClick = {
|
||
routePlan = routePlan.copy(
|
||
destination = RouteStop(
|
||
latitude = wp.latitude, longitude = wp.longitude,
|
||
label = wp.name.ifBlank { "Wegpunkt" },
|
||
source = RouteStopSource.WAYPOINT
|
||
)
|
||
)
|
||
actionMenuWaypoint = null
|
||
showRoutePlanner = true
|
||
},
|
||
modifier = Modifier.weight(1f)
|
||
) {
|
||
Text(stringResource(R.string.route_planner_set_as_destination))
|
||
}
|
||
}
|
||
Button(
|
||
onClick = {
|
||
deleteConfirm = wp
|
||
actionMenuWaypoint = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.errorContainer,
|
||
contentColor = MaterialTheme.colorScheme.onErrorContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.Delete, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.delete))
|
||
}
|
||
}
|
||
},
|
||
confirmButton = {
|
||
TextButton(onClick = { actionMenuWaypoint = null }) {
|
||
Text(stringResource(R.string.cancel))
|
||
}
|
||
}
|
||
)
|
||
}
|
||
|
||
// v2.5.3 — Einfacher Punkt-Dialog für Routenpunkte (Verschieben/Löschen).
|
||
if (showRoutePointDialog) {
|
||
val idx = selectedRoutePointIndex
|
||
val pt = idx?.let { manualRoutePoints.getOrNull(it) }
|
||
if (idx == null || pt == null) {
|
||
showRoutePointDialog = false
|
||
} else {
|
||
AlertDialog(
|
||
onDismissRequest = {
|
||
showRoutePointDialog = false
|
||
selectedRoutePointIndex = null
|
||
},
|
||
title = { Text(stringResource(R.string.explorer_route_point_dialog_title)) },
|
||
text = {
|
||
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||
Text(
|
||
"%.6f, %.6f".format(java.util.Locale.US, pt.latitude, pt.longitude),
|
||
style = MaterialTheme.typography.bodySmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.65f)
|
||
)
|
||
Button(
|
||
onClick = {
|
||
tapMode = TapModeMl.MoveRoutePoint(idx)
|
||
showRoutePointDialog = false
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.secondaryContainer,
|
||
contentColor = MaterialTheme.colorScheme.onSecondaryContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.OpenWith, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_route_point_move))
|
||
}
|
||
Button(
|
||
onClick = {
|
||
val ml = mapLibreMap
|
||
val center = ml?.cameraPosition?.target
|
||
if (center != null) {
|
||
val pts = manualRoutePoints.toMutableList()
|
||
if (idx in pts.indices) {
|
||
pts[idx] = LatLng(center.latitude, center.longitude)
|
||
manualRoutePoints = pts
|
||
}
|
||
}
|
||
showRoutePointDialog = false
|
||
selectedRoutePointIndex = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.tertiaryContainer,
|
||
contentColor = MaterialTheme.colorScheme.onTertiaryContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.PinDrop, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_action_move_to_center))
|
||
}
|
||
Button(
|
||
onClick = {
|
||
val pts = manualRoutePoints.toMutableList()
|
||
if (idx in pts.indices) {
|
||
pts.removeAt(idx)
|
||
manualRoutePoints = pts
|
||
}
|
||
showRoutePointDialog = false
|
||
selectedRoutePointIndex = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.error,
|
||
contentColor = MaterialTheme.colorScheme.onError
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.Delete, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_route_point_delete))
|
||
}
|
||
}
|
||
},
|
||
confirmButton = {
|
||
TextButton(onClick = {
|
||
showRoutePointDialog = false
|
||
selectedRoutePointIndex = null
|
||
}) { Text(stringResource(R.string.close)) }
|
||
}
|
||
)
|
||
}
|
||
}
|
||
|
||
deleteConfirm?.let { wp ->
|
||
AlertDialog(
|
||
onDismissRequest = { deleteConfirm = null },
|
||
title = { Text(stringResource(R.string.confirm_delete_waypoint_title)) },
|
||
text = {
|
||
Text(
|
||
stringResource(
|
||
R.string.confirm_delete_waypoint_msg,
|
||
wp.name.ifBlank { stringResource(R.string.map_waypoint_unnamed) }
|
||
)
|
||
)
|
||
},
|
||
confirmButton = {
|
||
Button(
|
||
onClick = {
|
||
viewModel.delete(wp.id)
|
||
deleteConfirm = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.error,
|
||
contentColor = MaterialTheme.colorScheme.onError
|
||
)
|
||
) { Text(stringResource(R.string.delete)) }
|
||
},
|
||
dismissButton = {
|
||
TextButton(onClick = { deleteConfirm = null }) {
|
||
Text(stringResource(R.string.cancel))
|
||
}
|
||
}
|
||
)
|
||
}
|
||
|
||
if (showEditDialog) {
|
||
WaypointEditDialog(
|
||
waypoint = editDialogWaypoint,
|
||
prefillLatLng = if (editDialogWaypoint == null) editDialogPrefill else null,
|
||
existingTours = tourList,
|
||
prefillTourName = selectedTour,
|
||
tourDefaults = tourDefaults,
|
||
onConfirm = { newWaypoint ->
|
||
viewModel.upsert(newWaypoint)
|
||
showEditDialog = false
|
||
editDialogWaypoint = null
|
||
editDialogPrefill = null
|
||
},
|
||
onDismiss = {
|
||
showEditDialog = false
|
||
editDialogWaypoint = null
|
||
editDialogPrefill = null
|
||
},
|
||
// v2.5.16 — Kopieren auch aus MapLibre-Bearbeiten-Flow möglich.
|
||
onCopyToOtherTour = editDialogWaypoint?.let { wp ->
|
||
{ targetTour -> viewModel.copyWaypointToTour(wp.id, targetTour) }
|
||
}
|
||
)
|
||
}
|
||
|
||
if (showRoutePlanner) {
|
||
val locationLatLon: Pair<Double, Double>? = lastLat?.let { lat ->
|
||
lastLng?.let { lon -> lat to lon }
|
||
}
|
||
val mapCenterLatLon: Pair<Double, Double>? = mapLibreMap?.cameraPosition?.target?.let {
|
||
it.latitude to it.longitude
|
||
}
|
||
RoutePlannerSheet(
|
||
plan = routePlan,
|
||
routeStatus = routeStatus,
|
||
hasRoute = routeLine.size >= 2,
|
||
hasPlanline = routePlanline.size >= 2,
|
||
isLoading = routeLoading,
|
||
routingEndpoint = mapStyleSettings.routingEndpoint,
|
||
showRouteOverlay = showRouteOverlay,
|
||
onShowRouteOverlayChange = { showRouteOverlay = it },
|
||
onPlanChange = { newPlan ->
|
||
routePlan = newPlan
|
||
// Bei Plan-Änderung verwerfen wir die alte echte Route — sonst
|
||
// bliebe die alte Linie sichtbar, obwohl die Stops sich geändert haben.
|
||
routeLine = emptyList()
|
||
if (routeStatus != null) routeStatus = null
|
||
},
|
||
onComputeRoute = {
|
||
// v2.4.4: Wenn kein Endpunkt gesetzt ist, geben wir keinen
|
||
// grauen Button mehr aus, sondern lassen den Nutzer auf
|
||
// 'Route berechnen' klicken und antworten mit einem klaren
|
||
// Status, der direkt auf den Demo-Quick-Setup verweist
|
||
// (siehe route_planner_status_endpoint_missing).
|
||
val endpoint = de.waypointaudio.util.OsrmRoutingClient
|
||
.normalizeBase(mapStyleSettings.routingEndpoint)
|
||
// v2.5.2 — gewähltes Profil für API-Aufruf, Status und Persistenz.
|
||
val profile = routePlan.profile
|
||
val profileLabel = routingPoiCtx.getString(profileLabelRes(profile))
|
||
if (endpoint.isBlank()) {
|
||
routeStatus = routingPoiCtx.getString(
|
||
R.string.route_planner_status_endpoint_missing_with_profile,
|
||
profileLabel
|
||
)
|
||
return@RoutePlannerSheet
|
||
}
|
||
val pts = routePlan.toOsrmPoints()
|
||
if (pts.size < 2) {
|
||
routeStatus = routingPoiCtx.getString(R.string.routing_compute_no_points)
|
||
return@RoutePlannerSheet
|
||
}
|
||
routeLoading = true
|
||
routeStatus = routingPoiCtx.getString(R.string.routing_compute_loading)
|
||
scope.launch {
|
||
runCatching {
|
||
de.waypointaudio.util.OsrmRoutingClient.route(
|
||
routingPoiCtx, endpoint, pts, profile.osrmKey
|
||
)
|
||
}.onSuccess { result ->
|
||
routeLine = result.polyline.map { (lat, lon) -> LatLng(lat, lon) }
|
||
// v2.4.6 — Metadaten für die persistente Tourroute merken.
|
||
lastComputedDistanceMeters = result.distanceMeters
|
||
lastComputedDurationSeconds = result.durationSeconds
|
||
lastComputedEndpoint = endpoint
|
||
routeStatus = routingPoiCtx.getString(
|
||
R.string.routing_compute_success,
|
||
de.waypointaudio.util.OsrmRoutingClient.formatDistance(result.distanceMeters),
|
||
de.waypointaudio.util.OsrmRoutingClient.formatDuration(result.durationSeconds)
|
||
)
|
||
}.onFailure { ex ->
|
||
routeLine = emptyList()
|
||
lastComputedDistanceMeters = null
|
||
lastComputedDurationSeconds = null
|
||
lastComputedEndpoint = ""
|
||
// v2.5.2: Fehlermeldung enthält das gewählte Profil,
|
||
// damit der Nutzer einordnen kann, ob z. B. das
|
||
// OSRM-Backend ein bestimmtes Profil nicht anbietet
|
||
// (typische Fehlerquelle bei eigenen Servern).
|
||
val detail = (ex.message ?: ex::class.java.simpleName).take(80)
|
||
routeStatus = routingPoiCtx.getString(
|
||
R.string.route_planner_status_error_with_profile,
|
||
profileLabel, detail
|
||
)
|
||
}
|
||
routeLoading = false
|
||
}
|
||
},
|
||
onUseDemoEndpoint = {
|
||
// v2.4.4: Quick-Setup für den OSRM-Demo-Server. Setzt einmalig
|
||
// den Endpunkt — der Nutzer kann ihn jederzeit unter „Endpunkt
|
||
// einrichten" durch einen eigenen self-hosted Server ersetzen.
|
||
scope.launch {
|
||
runCatching {
|
||
mapStyleStore.setRoutingEndpoint(
|
||
de.waypointaudio.util.OsrmRoutingClient.DEMO_ENDPOINT
|
||
)
|
||
}
|
||
routeStatus = routingPoiCtx.getString(R.string.route_planner_demo_endpoint_set)
|
||
}
|
||
},
|
||
onShowPlanline = {
|
||
routeLine = emptyList()
|
||
if (routePlanline.size >= 2) {
|
||
routeStatus = routingPoiCtx.getString(R.string.route_planner_planline_active)
|
||
val ml = mapLibreMap
|
||
if (ml != null) {
|
||
val mid = routePlanline[routePlanline.size / 2]
|
||
ml.animateCamera(CameraUpdateFactory.newLatLngZoom(mid, 13.0))
|
||
}
|
||
}
|
||
},
|
||
onClear = {
|
||
routePlan = RoutePlan()
|
||
routeLine = emptyList()
|
||
routeStatus = null
|
||
},
|
||
onConfigureEndpoint = {
|
||
showRoutePlanner = false
|
||
showRoutingInfo = true
|
||
},
|
||
onSaveAsTourDraft = { tourName ->
|
||
val orderedStops = routePlan.orderedStops()
|
||
if (orderedStops.isEmpty()) return@RoutePlannerSheet
|
||
// Wegpunkte aus den Stops anlegen und in neue Tour ablegen.
|
||
val target = tourName.ifBlank { "Routenentwurf" }
|
||
val newWaypoints = orderedStops.mapIndexed { i, stop ->
|
||
Waypoint(
|
||
name = "${stop.label.take(40)} #${i + 1}",
|
||
latitude = stop.latitude,
|
||
longitude = stop.longitude,
|
||
radiusMeters = 40f,
|
||
tourName = target,
|
||
isActive = true
|
||
)
|
||
}
|
||
for (wp in newWaypoints) viewModel.upsert(wp)
|
||
// v2.4.6 — Wenn aus dem Storyboard/Tour-Entwurf eine Tour mit
|
||
// Geometrie entsteht, optional auch eine Tourroute speichern.
|
||
// Verwendet die aktuell sichtbare Geometrie (Route oder
|
||
// Planlinie). Keine automatische Audioerzeugung.
|
||
val tourRoute = buildTourRouteFromState(
|
||
plan = routePlan,
|
||
routeLine = routeLine,
|
||
routePlanline = routePlanline,
|
||
distanceMeters = lastComputedDistanceMeters,
|
||
durationSeconds = lastComputedDurationSeconds,
|
||
endpoint = lastComputedEndpoint,
|
||
planlineSourceLabel = routingPoiCtx.getString(R.string.tour_route_source_planline)
|
||
)
|
||
if (tourRoute != null) {
|
||
viewModel.saveTourRouteFor(target, tourRoute)
|
||
}
|
||
routeStatus = routingPoiCtx.getString(
|
||
R.string.route_planner_save_as_tour_done, target
|
||
)
|
||
},
|
||
onAddStopsAsWaypoints = {
|
||
val orderedStops = routePlan.orderedStops()
|
||
if (orderedStops.isEmpty()) return@RoutePlannerSheet
|
||
val target = selectedTour
|
||
var count = 0
|
||
for ((i, stop) in orderedStops.withIndex()) {
|
||
viewModel.upsert(
|
||
Waypoint(
|
||
name = "${stop.label.take(40)} #${i + 1}",
|
||
latitude = stop.latitude,
|
||
longitude = stop.longitude,
|
||
radiusMeters = 40f,
|
||
tourName = target,
|
||
isActive = true
|
||
)
|
||
)
|
||
count++
|
||
}
|
||
routeStatus = routingPoiCtx.getString(R.string.route_planner_add_stops_done, count)
|
||
},
|
||
// v2.4.6 — Tourrouten-Aktionen
|
||
currentTourName = selectedTour,
|
||
savedTourRoute = activeTourRoute,
|
||
onSaveTourRoute = {
|
||
val route = buildTourRouteFromState(
|
||
plan = routePlan,
|
||
routeLine = routeLine,
|
||
routePlanline = routePlanline,
|
||
distanceMeters = lastComputedDistanceMeters,
|
||
durationSeconds = lastComputedDurationSeconds,
|
||
endpoint = lastComputedEndpoint,
|
||
planlineSourceLabel = routingPoiCtx.getString(R.string.tour_route_source_planline)
|
||
)
|
||
if (route != null) {
|
||
viewModel.saveTourRouteForCurrent(route)
|
||
routeStatus = routingPoiCtx.getString(R.string.tour_route_saved_msg, selectedTour)
|
||
}
|
||
},
|
||
onReplaceTourRoute = {
|
||
val route = buildTourRouteFromState(
|
||
plan = routePlan,
|
||
routeLine = routeLine,
|
||
routePlanline = routePlanline,
|
||
distanceMeters = lastComputedDistanceMeters,
|
||
durationSeconds = lastComputedDurationSeconds,
|
||
endpoint = lastComputedEndpoint,
|
||
planlineSourceLabel = routingPoiCtx.getString(R.string.tour_route_source_planline)
|
||
)
|
||
if (route != null) {
|
||
viewModel.saveTourRouteForCurrent(route)
|
||
routeStatus = routingPoiCtx.getString(R.string.tour_route_replaced_msg, selectedTour)
|
||
}
|
||
},
|
||
onDeleteTourRoute = {
|
||
viewModel.deleteTourRouteForCurrent()
|
||
routeStatus = routingPoiCtx.getString(R.string.tour_route_deleted_msg, selectedTour)
|
||
},
|
||
currentLocationLatLon = locationLatLon,
|
||
mapCenterLatLon = mapCenterLatLon,
|
||
availableWaypoints = waypoints,
|
||
onDismiss = { showRoutePlanner = false }
|
||
)
|
||
}
|
||
|
||
if (showRoutingInfo) {
|
||
RoutingPoiSheet(
|
||
centerLat = lastLat ?: mapLibreMap?.cameraPosition?.target?.latitude,
|
||
centerLon = lastLng ?: mapLibreMap?.cameraPosition?.target?.longitude,
|
||
routingEndpoint = mapStyleSettings.routingEndpoint,
|
||
onRoutingEndpointChange = { url ->
|
||
scope.launch { runCatching { mapStyleStore.setRoutingEndpoint(url) } }
|
||
},
|
||
onAddPoiAsWaypoint = { poi ->
|
||
val newWp = Waypoint(
|
||
id = java.util.UUID.randomUUID().toString(),
|
||
name = poi.displayName.take(60),
|
||
latitude = poi.latitude,
|
||
longitude = poi.longitude,
|
||
radiusMeters = 30f,
|
||
soundUri = "",
|
||
tourName = selectedTour,
|
||
isActive = true
|
||
)
|
||
viewModel.upsert(newWp)
|
||
},
|
||
onAddPoiToStoryboard = { poi ->
|
||
val newWp = Waypoint(
|
||
id = java.util.UUID.randomUUID().toString(),
|
||
name = poi.displayName.take(60),
|
||
latitude = poi.latitude,
|
||
longitude = poi.longitude,
|
||
radiusMeters = 30f,
|
||
soundUri = "",
|
||
tourName = selectedTour,
|
||
isActive = true
|
||
)
|
||
viewModel.upsert(newWp)
|
||
showStoryboardSheet = true
|
||
},
|
||
onComputeRoute = {
|
||
val endpoint = mapStyleSettings.routingEndpoint.trim()
|
||
if (endpoint.isBlank()) {
|
||
routeStatus = routingPoiCtx.getString(R.string.routing_endpoint_not_configured)
|
||
return@RoutingPoiSheet
|
||
}
|
||
val pts = waypoints.map { it.latitude to it.longitude }
|
||
if (pts.size < 2) {
|
||
routeStatus = routingPoiCtx.getString(R.string.routing_compute_no_points)
|
||
return@RoutingPoiSheet
|
||
}
|
||
routeLoading = true
|
||
routeStatus = routingPoiCtx.getString(R.string.routing_compute_loading)
|
||
scope.launch {
|
||
runCatching {
|
||
de.waypointaudio.util.OsrmRoutingClient.route(routingPoiCtx, endpoint, pts)
|
||
}.onSuccess { result ->
|
||
routeLine = result.polyline.map { (lat, lon) -> LatLng(lat, lon) }
|
||
routeStatus = routingPoiCtx.getString(
|
||
R.string.routing_compute_success,
|
||
de.waypointaudio.util.OsrmRoutingClient.formatDistance(result.distanceMeters),
|
||
de.waypointaudio.util.OsrmRoutingClient.formatDuration(result.durationSeconds)
|
||
)
|
||
}.onFailure {
|
||
routeLine = emptyList()
|
||
routeStatus = routingPoiCtx.getString(R.string.routing_compute_error)
|
||
}
|
||
routeLoading = false
|
||
}
|
||
},
|
||
routeStatus = routeStatus,
|
||
onDismiss = { showRoutingInfo = false }
|
||
)
|
||
}
|
||
|
||
if (showSearchDialog) {
|
||
PlaceSearchDialog(
|
||
onDismiss = { showSearchDialog = false },
|
||
onResultSelected = { result ->
|
||
val gp = LatLng(result.latitude, result.longitude)
|
||
searchPin = gp
|
||
mapLibreMap?.let { ml ->
|
||
ml.animateCamera(CameraUpdateFactory.newLatLngZoom(gp, 15.0))
|
||
}
|
||
followLocation = false
|
||
showSearchDialog = false
|
||
}
|
||
)
|
||
}
|
||
|
||
showDraftPointMenu?.let { sel ->
|
||
val idx = sel.index
|
||
val draft = activeDraft
|
||
val pt = if (draft != null) draft.points.getOrNull(idx) else visibleTrack.getOrNull(idx)
|
||
AlertDialog(
|
||
onDismissRequest = { showDraftPointMenu = null },
|
||
title = { Text(stringResource(R.string.explorer_track_point_title, idx + 1)) },
|
||
text = {
|
||
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||
if (pt != null) {
|
||
Text(
|
||
"%.6f, %.6f".format(java.util.Locale.US, pt.latitude, pt.longitude),
|
||
style = MaterialTheme.typography.bodySmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.65f)
|
||
)
|
||
}
|
||
if (draft != null) {
|
||
val isMarked = idx in draft.markedIndexes
|
||
Button(
|
||
onClick = {
|
||
val newMarked = if (isMarked) draft.markedIndexes - idx
|
||
else (draft.markedIndexes + idx).distinct().sorted()
|
||
viewModel.saveDraft(draft.copy(markedIndexes = newMarked))
|
||
showDraftPointMenu = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = if (isMarked) MaterialTheme.colorScheme.tertiary
|
||
else MaterialTheme.colorScheme.primary
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.Bookmarks, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(
|
||
if (isMarked) stringResource(R.string.draft_point_unmark)
|
||
else stringResource(R.string.draft_point_mark)
|
||
)
|
||
}
|
||
Button(
|
||
onClick = {
|
||
selectedTrackIndex = idx
|
||
tapMode = TapModeMl.MoveTrackPoint(idx)
|
||
showDraftPointMenu = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.secondaryContainer,
|
||
contentColor = MaterialTheme.colorScheme.onSecondaryContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.OpenWith, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_action_move_tap))
|
||
}
|
||
Button(
|
||
onClick = {
|
||
val ml = mapLibreMap
|
||
if (ml != null) {
|
||
val center = ml.cameraPosition.target
|
||
val pts = draft.points.toMutableList()
|
||
if (idx in pts.indices && center != null) {
|
||
pts[idx] = pts[idx].copy(
|
||
latitude = center.latitude,
|
||
longitude = center.longitude
|
||
)
|
||
viewModel.saveDraft(draft.copy(points = pts))
|
||
}
|
||
}
|
||
showDraftPointMenu = null
|
||
},
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.tertiaryContainer,
|
||
contentColor = MaterialTheme.colorScheme.onTertiaryContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.PinDrop, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_action_move_to_center))
|
||
}
|
||
Button(
|
||
onClick = {
|
||
val pts = draft.points.toMutableList()
|
||
if (idx in pts.indices) {
|
||
pts.removeAt(idx)
|
||
val newMarked = draft.markedIndexes
|
||
.filter { it != idx }
|
||
.map { if (it > idx) it - 1 else it }
|
||
viewModel.saveDraft(draft.copy(points = pts, markedIndexes = newMarked))
|
||
}
|
||
showDraftPointMenu = null
|
||
},
|
||
enabled = !isRecording,
|
||
colors = ButtonDefaults.buttonColors(
|
||
containerColor = MaterialTheme.colorScheme.errorContainer,
|
||
contentColor = MaterialTheme.colorScheme.onErrorContainer
|
||
),
|
||
modifier = Modifier.fillMaxWidth()
|
||
) {
|
||
Icon(Icons.Filled.Delete, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.delete))
|
||
}
|
||
} else {
|
||
Text(
|
||
stringResource(R.string.explorer_track_point_no_draft_hint),
|
||
style = MaterialTheme.typography.bodySmall
|
||
)
|
||
}
|
||
}
|
||
},
|
||
confirmButton = {
|
||
TextButton(onClick = { showDraftPointMenu = null }) {
|
||
Text(stringResource(R.string.cancel))
|
||
}
|
||
}
|
||
)
|
||
}
|
||
|
||
if (showDraftsSheet) {
|
||
val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
|
||
ModalBottomSheet(
|
||
onDismissRequest = { showDraftsSheet = false },
|
||
sheetState = sheetState
|
||
) {
|
||
DraftsPanelMl(
|
||
drafts = drafts,
|
||
activeDraftId = activeDraftId,
|
||
isRecording = isRecording,
|
||
onActivate = { id ->
|
||
activeDraftId = if (activeDraftId == id) null else id
|
||
val ml = mapLibreMap
|
||
val first = drafts.firstOrNull { it.id == id }?.points?.firstOrNull()
|
||
if (ml != null && first != null) {
|
||
ml.animateCamera(
|
||
CameraUpdateFactory.newLatLngZoom(
|
||
LatLng(first.latitude, first.longitude),
|
||
15.0
|
||
)
|
||
)
|
||
followLocation = false
|
||
}
|
||
},
|
||
onOpenFullEditor = { id -> onOpenDraft(id) },
|
||
onDelete = { id ->
|
||
viewModel.deleteDraft(id)
|
||
if (activeDraftId == id) activeDraftId = null
|
||
},
|
||
onImport = { id ->
|
||
val d = drafts.firstOrNull { it.id == id } ?: return@DraftsPanelMl
|
||
viewModel.importDraftAsWaypoints(d, selectedTour)
|
||
},
|
||
onClose = { showDraftsSheet = false }
|
||
)
|
||
}
|
||
}
|
||
|
||
if (showStoryboardSheet) {
|
||
val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
|
||
ModalBottomSheet(
|
||
onDismissRequest = { showStoryboardSheet = false },
|
||
sheetState = sheetState
|
||
) {
|
||
StoryboardPanelMl(
|
||
tourWaypoints = waypoints,
|
||
currentTour = selectedTour,
|
||
onSaveAsTour = { targetTour, orderedIds ->
|
||
viewModel.applyStoryboardOrder(targetTour, orderedIds)
|
||
showStoryboardSheet = false
|
||
},
|
||
onClose = { showStoryboardSheet = false }
|
||
)
|
||
}
|
||
}
|
||
|
||
// ─── Scaffold ────────────────────────────────────────────────────────────
|
||
|
||
Scaffold(
|
||
topBar = {
|
||
// v2.5.6 — Explorer TopBar im v2.5.x-Stil:
|
||
// Dezente Surface-Fläche statt knalligem Primary-Teal, primary nur
|
||
// als Akzent in Icons/Aktionen. Bessere Harmonie mit HomeScreen und
|
||
// den neuen Tour-/Audio-Cards.
|
||
TopAppBar(
|
||
title = {
|
||
if (currentMode != null && onModeChange != null) {
|
||
MapModeSegmentedHeader(
|
||
current = currentMode,
|
||
onChange = onModeChange,
|
||
subtitle = selectedTour,
|
||
contentColor = MaterialTheme.colorScheme.onSurface
|
||
)
|
||
} else {
|
||
Column {
|
||
Row(verticalAlignment = Alignment.CenterVertically) {
|
||
Icon(
|
||
Icons.Filled.Explore,
|
||
contentDescription = null,
|
||
modifier = Modifier.size(18.dp),
|
||
tint = MaterialTheme.colorScheme.primary
|
||
)
|
||
Spacer(Modifier.width(6.dp))
|
||
Text(stringResource(R.string.explorer_title))
|
||
}
|
||
Text(
|
||
text = selectedTour,
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.65f)
|
||
)
|
||
}
|
||
}
|
||
},
|
||
navigationIcon = {
|
||
IconButton(onClick = onNavigateBack) {
|
||
Icon(
|
||
Icons.AutoMirrored.Filled.ArrowBack,
|
||
contentDescription = stringResource(R.string.back)
|
||
)
|
||
}
|
||
},
|
||
actions = {
|
||
IconButton(onClick = { showSearchDialog = true }) {
|
||
Icon(
|
||
Icons.Filled.Search,
|
||
contentDescription = stringResource(R.string.search_place_action)
|
||
)
|
||
}
|
||
IconButton(onClick = { followLocation = !followLocation }) {
|
||
Icon(
|
||
if (followLocation) Icons.Filled.GpsFixed else Icons.Filled.GpsOff,
|
||
contentDescription = if (followLocation)
|
||
stringResource(R.string.explorer_follow_on)
|
||
else
|
||
stringResource(R.string.explorer_follow_off),
|
||
tint = if (followLocation)
|
||
MaterialTheme.colorScheme.tertiary
|
||
else
|
||
MaterialTheme.colorScheme.onSurfaceVariant
|
||
)
|
||
}
|
||
IconButton(onClick = {
|
||
tapMode = if (tapMode is TapModeMl.PlaceNew) TapModeMl.None else TapModeMl.PlaceNew
|
||
}) {
|
||
Icon(
|
||
Icons.Filled.TouchApp,
|
||
contentDescription = stringResource(R.string.explorer_action_tap_place),
|
||
tint = if (tapMode is TapModeMl.PlaceNew)
|
||
MaterialTheme.colorScheme.tertiary
|
||
else
|
||
MaterialTheme.colorScheme.onSurfaceVariant
|
||
)
|
||
}
|
||
},
|
||
colors = TopAppBarDefaults.topAppBarColors(
|
||
containerColor = MaterialTheme.colorScheme.surface,
|
||
titleContentColor = MaterialTheme.colorScheme.onSurface,
|
||
navigationIconContentColor = MaterialTheme.colorScheme.onSurface,
|
||
actionIconContentColor = MaterialTheme.colorScheme.primary
|
||
)
|
||
)
|
||
},
|
||
floatingActionButton = {
|
||
// v2.5.6 — FABs harmonisiert: ruhige, glasige Surfaces statt
|
||
// knalliges Primary-Teal; Tonale Erhöhung sorgt für sichtbaren
|
||
// Kontrast gegenüber der Karte ohne grelle Akzente.
|
||
// v2.5.40 — Toolbar-Fix: Alle FABs in einer Column mit
|
||
// genügend Abstand; kein Überlappen mit MapLayerFab (TopEnd).
|
||
// Der Compass-Button ist neu (Bearing auf 0 zurücksetzen).
|
||
val neutralFabContainer = MaterialTheme.colorScheme.surfaceColorAtElevation(6.dp)
|
||
val neutralFabContent = MaterialTheme.colorScheme.primary
|
||
Column(
|
||
horizontalAlignment = Alignment.End,
|
||
verticalArrangement = Arrangement.spacedBy(10.dp),
|
||
modifier = Modifier.padding(bottom = 8.dp)
|
||
) {
|
||
// v2.5.40 — Kompass/Nordausrichten
|
||
SmallFloatingActionButton(
|
||
onClick = {
|
||
val ml = mapLibreMap ?: return@SmallFloatingActionButton
|
||
val pos = ml.cameraPosition
|
||
ml.animateCamera(
|
||
CameraUpdateFactory.newCameraPosition(
|
||
CameraPosition.Builder(pos).bearing(0.0).build()
|
||
)
|
||
)
|
||
},
|
||
containerColor = neutralFabContainer,
|
||
contentColor = neutralFabContent
|
||
) {
|
||
Icon(
|
||
Icons.Filled.Navigation,
|
||
contentDescription = "Nach Norden ausrichten"
|
||
)
|
||
}
|
||
SmallFloatingActionButton(
|
||
onClick = { showDraftsSheet = true },
|
||
containerColor = neutralFabContainer,
|
||
contentColor = neutralFabContent
|
||
) {
|
||
Icon(Icons.Filled.Timeline, contentDescription = stringResource(R.string.explorer_drafts_open))
|
||
}
|
||
SmallFloatingActionButton(
|
||
onClick = { showStoryboardSheet = true },
|
||
containerColor = neutralFabContainer,
|
||
contentColor = neutralFabContent
|
||
) {
|
||
Icon(Icons.Filled.MovieFilter, contentDescription = stringResource(R.string.explorer_storyboard_open))
|
||
}
|
||
SmallFloatingActionButton(
|
||
onClick = { showRoutePlanner = true },
|
||
containerColor = neutralFabContainer,
|
||
contentColor = neutralFabContent
|
||
) {
|
||
Icon(Icons.Filled.AltRoute, contentDescription = stringResource(R.string.route_planner_open))
|
||
}
|
||
// v2.5.3 — FAB für „Route zeichnen". Toggle: an = Tap setzt
|
||
// stille Routenpunkte, aus = normale Karten-Tap-Logik.
|
||
SmallFloatingActionButton(
|
||
onClick = {
|
||
manualRouteMode = !manualRouteMode
|
||
tapMode = if (manualRouteMode) TapModeMl.DrawRoutePoint
|
||
else TapModeMl.None
|
||
},
|
||
containerColor = if (manualRouteMode)
|
||
MaterialTheme.colorScheme.tertiaryContainer
|
||
else
|
||
neutralFabContainer,
|
||
contentColor = if (manualRouteMode)
|
||
MaterialTheme.colorScheme.onTertiaryContainer
|
||
else
|
||
neutralFabContent
|
||
) {
|
||
Icon(
|
||
Icons.Filled.Edit,
|
||
contentDescription = stringResource(R.string.explorer_mode_draw_route)
|
||
)
|
||
}
|
||
if (isRecording) {
|
||
ExtendedFloatingActionButton(
|
||
onClick = { viewModel.stopTrackRecording() },
|
||
containerColor = MaterialTheme.colorScheme.errorContainer,
|
||
contentColor = MaterialTheme.colorScheme.onErrorContainer,
|
||
icon = { Icon(Icons.Filled.Stop, contentDescription = stringResource(R.string.map_track_stop)) },
|
||
text = { Text(stringResource(R.string.map_track_recording)) }
|
||
)
|
||
} else {
|
||
SmallFloatingActionButton(
|
||
onClick = { viewModel.startTrackRecording() },
|
||
containerColor = MaterialTheme.colorScheme.tertiaryContainer,
|
||
contentColor = MaterialTheme.colorScheme.onTertiaryContainer
|
||
) {
|
||
Icon(
|
||
Icons.Filled.FiberManualRecord,
|
||
contentDescription = stringResource(R.string.map_track_start)
|
||
)
|
||
}
|
||
}
|
||
FloatingActionButton(
|
||
onClick = {
|
||
val ml = mapLibreMap
|
||
val center = ml?.cameraPosition?.target
|
||
val pre = if (center != null) Pair(center.latitude, center.longitude)
|
||
else if (lastLat != null && lastLng != null) Pair(lastLat!!, lastLng!!)
|
||
else null
|
||
editDialogWaypoint = null
|
||
editDialogPrefill = pre
|
||
showEditDialog = true
|
||
},
|
||
containerColor = MaterialTheme.colorScheme.primaryContainer,
|
||
contentColor = MaterialTheme.colorScheme.onPrimaryContainer
|
||
) {
|
||
Icon(
|
||
Icons.Filled.AddLocation,
|
||
contentDescription = stringResource(R.string.explorer_add_waypoint)
|
||
)
|
||
}
|
||
SmallFloatingActionButton(
|
||
onClick = {
|
||
val ml = mapLibreMap ?: return@SmallFloatingActionButton
|
||
val lat = lastLat
|
||
val lng = lastLng
|
||
if (lat != null && lng != null) {
|
||
ml.animateCamera(CameraUpdateFactory.newLatLngZoom(LatLng(lat, lng), 17.0))
|
||
followLocation = true
|
||
} else if (waypoints.isNotEmpty()) {
|
||
val first = waypoints.first()
|
||
ml.animateCamera(
|
||
CameraUpdateFactory.newLatLngZoom(
|
||
LatLng(first.latitude, first.longitude), 15.0
|
||
)
|
||
)
|
||
}
|
||
},
|
||
containerColor = neutralFabContainer,
|
||
contentColor = neutralFabContent
|
||
) {
|
||
Icon(
|
||
Icons.Filled.MyLocation,
|
||
contentDescription = stringResource(R.string.explorer_my_location)
|
||
)
|
||
}
|
||
}
|
||
}
|
||
) { inner ->
|
||
Box(
|
||
modifier = Modifier
|
||
.fillMaxSize()
|
||
.padding(inner)
|
||
) {
|
||
AndroidView(
|
||
modifier = Modifier.fillMaxSize(),
|
||
factory = { ctx ->
|
||
val initialCenter = if (waypoints.isNotEmpty()) {
|
||
LatLng(waypoints.first().latitude, waypoints.first().longitude)
|
||
} else {
|
||
LatLng(51.1657, 10.4515)
|
||
}
|
||
MapView(ctx).also { mv ->
|
||
mv.onCreate(null)
|
||
mv.getMapAsync { ml ->
|
||
mapLibreMap = ml
|
||
ml.cameraPosition = CameraPosition.Builder()
|
||
.target(initialCenter)
|
||
.zoom(13.0)
|
||
.build()
|
||
ml.uiSettings.isLogoEnabled = false
|
||
ml.uiSettings.isAttributionEnabled = false
|
||
ml.uiSettings.setCompassEnabled(true)
|
||
// v2.5.37 — Initialer Stil beim Map-Aufbau.
|
||
// Vektor-Stile via OpenFreeMap-URI laden.
|
||
val initialStyleBuilder = when (layerState.baseStyle) {
|
||
MapBaseStyle.DARK -> Style.Builder().fromUri("https://tiles.openfreemap.org/styles/dark")
|
||
MapBaseStyle.OUTDOOR, MapBaseStyle.TOPO -> Style.Builder().fromUri("https://tiles.openfreemap.org/styles/liberty")
|
||
MapBaseStyle.CITY_3D, MapBaseStyle.TERRAIN_3D, MapBaseStyle.PERSPECTIVE -> Style.Builder().fromUri("https://tiles.openfreemap.org/styles/positron")
|
||
MapBaseStyle.CLASSIC, MapBaseStyle.SATELLITE -> Style.Builder().fromJson(buildClassicOsmStyleJson())
|
||
else -> Style.Builder().fromUri("https://tiles.openfreemap.org/styles/positron")
|
||
}
|
||
ml.setStyle(initialStyleBuilder) { loadedStyle ->
|
||
// 3D-Extrusion für CITY_3D beim initialen Laden.
|
||
if (layerState.baseStyle == MapBaseStyle.CITY_3D ||
|
||
layerState.baseStyle == MapBaseStyle.TERRAIN_3D ||
|
||
layerState.baseStyle == MapBaseStyle.PERSPECTIVE) {
|
||
try { addBuildingExtrusionIfAvailable(loadedStyle) } catch (_: Exception) {}
|
||
val pos2 = ml.cameraPosition
|
||
ml.cameraPosition = CameraPosition.Builder(pos2)
|
||
.tilt(mapStyleSettings.perspectiveTilt.toDouble().coerceIn(0.0, 60.0))
|
||
.build()
|
||
}
|
||
styleReady = true
|
||
}
|
||
// Klick-Handler für Wegpunkt-/Track-Marker.
|
||
ml.setOnMarkerClickListener { m ->
|
||
val wp = waypointMarkerIdToWaypoint[m.id]
|
||
if (wp != null) {
|
||
actionMenuWaypoint = wp
|
||
return@setOnMarkerClickListener true
|
||
}
|
||
val ti = trackMarkerIdToIndex[m.id]
|
||
if (ti != null) {
|
||
// v2.5.33 — Phantom-Track-Fix: Nur öffnen, wenn ein
|
||
// gültiger aktiver Draft oder eine laufende Aufzeichnung
|
||
// existiert. Ohne gültigen Kontext (verwaiste Marker) wird
|
||
// der Tap still ignoriert, statt einen irreführenden
|
||
// Bearbeitungsdialog mit 'Aktiviere zuerst einen Draft'
|
||
// zu zeigen.
|
||
if (activeDraft != null || isRecording) {
|
||
showDraftPointMenu = DraftPointSelectionMl(ti)
|
||
}
|
||
return@setOnMarkerClickListener true
|
||
}
|
||
// v2.5.3 — Klick auf einen Routenpunkt der manuellen Route
|
||
// öffnet einen einfachen Punkt-Dialog (Verschieben/Löschen).
|
||
val ri = manualRouteMarkerIdToIndex[m.id]
|
||
if (ri != null) {
|
||
selectedRoutePointIndex = ri
|
||
showRoutePointDialog = true
|
||
return@setOnMarkerClickListener true
|
||
}
|
||
// v2.5.40 — Klick auf Explorer-POI-Marker
|
||
val epoi = explorerPoiMarkerIdToResult[m.id]
|
||
if (epoi != null) {
|
||
selectedExplorerPoi = epoi
|
||
return@setOnMarkerClickListener true
|
||
}
|
||
false
|
||
}
|
||
ml.addOnMapClickListener { p ->
|
||
when (val m = tapMode) {
|
||
is TapModeMl.PlaceNew -> {
|
||
editDialogWaypoint = null
|
||
editDialogPrefill = Pair(p.latitude, p.longitude)
|
||
showEditDialog = true
|
||
tapMode = TapModeMl.None
|
||
true
|
||
}
|
||
is TapModeMl.MoveWaypoint -> {
|
||
val target = allWaypoints.firstOrNull { it.id == m.id }
|
||
if (target != null) {
|
||
viewModel.upsert(
|
||
target.copy(latitude = p.latitude, longitude = p.longitude)
|
||
)
|
||
}
|
||
tapMode = TapModeMl.None
|
||
true
|
||
}
|
||
is TapModeMl.MoveTrackPoint -> {
|
||
val draft = activeDraft
|
||
if (draft != null) {
|
||
val pts = draft.points.toMutableList()
|
||
if (m.index in pts.indices) {
|
||
pts[m.index] = pts[m.index].copy(
|
||
latitude = p.latitude,
|
||
longitude = p.longitude
|
||
)
|
||
viewModel.saveDraft(draft.copy(points = pts))
|
||
}
|
||
}
|
||
tapMode = TapModeMl.None
|
||
selectedTrackIndex = null
|
||
true
|
||
}
|
||
is TapModeMl.DrawRoutePoint -> {
|
||
// v2.5.3 — Stiller Routenpunkt: hängt nur an
|
||
// die Polyline an. Kein Audio, kein Wegpunkt,
|
||
// keine Clip-Länge.
|
||
manualRoutePoints = manualRoutePoints + LatLng(
|
||
p.latitude, p.longitude
|
||
)
|
||
// Im Modus bleiben, damit weitere Punkte gesetzt
|
||
// werden können — Verlassen via Cancel-Chip oder
|
||
// Mode-Toggle.
|
||
true
|
||
}
|
||
is TapModeMl.MoveRoutePoint -> {
|
||
val pts = manualRoutePoints.toMutableList()
|
||
if (m.index in pts.indices) {
|
||
pts[m.index] = LatLng(p.latitude, p.longitude)
|
||
manualRoutePoints = pts
|
||
}
|
||
tapMode = TapModeMl.None
|
||
selectedRoutePointIndex = null
|
||
true
|
||
}
|
||
TapModeMl.None -> false
|
||
}
|
||
}
|
||
ml.addOnMapLongClickListener { p ->
|
||
// v2.5.3 — Im manuellen Routemodus dient LongPress
|
||
// ebenfalls dem Setzen eines Routenpunkts und nicht
|
||
// dem Anlegen eines Audio-Wegpunkts.
|
||
if (manualRouteMode || tapMode is TapModeMl.DrawRoutePoint) {
|
||
manualRoutePoints = manualRoutePoints + LatLng(
|
||
p.latitude, p.longitude
|
||
)
|
||
return@addOnMapLongClickListener true
|
||
}
|
||
editDialogWaypoint = null
|
||
editDialogPrefill = Pair(p.latitude, p.longitude)
|
||
showEditDialog = true
|
||
true
|
||
}
|
||
// Folow-disable bei manueller Bewegung:
|
||
ml.addOnMoveListener(object : org.maplibre.android.maps.MapLibreMap.OnMoveListener {
|
||
override fun onMoveBegin(detector: org.maplibre.android.gestures.MoveGestureDetector) {
|
||
if (followLocation) {
|
||
val lat = lastLat; val lng = lastLng
|
||
if (lat != null && lng != null) {
|
||
val tgt = ml.cameraPosition.target
|
||
if (tgt != null) {
|
||
val dLat = kotlin.math.abs(tgt.latitude - lat)
|
||
val dLng = kotlin.math.abs(tgt.longitude - lng)
|
||
if (dLat > 0.00040 || dLng > 0.00040) {
|
||
followLocation = false
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
override fun onMove(detector: org.maplibre.android.gestures.MoveGestureDetector) {}
|
||
override fun onMoveEnd(detector: org.maplibre.android.gestures.MoveGestureDetector) {}
|
||
})
|
||
// v2.5.41 — Zoom-Tracking für zoom-abhängige POI-Label-Anzeige
|
||
// v2.5.45 — Auto-POI-Load: debounced nach Kamera-Idle
|
||
ml.addOnCameraIdleListener {
|
||
currentMapZoom = ml.cameraPosition.zoom
|
||
// Auto-Load nur wenn aktiviert, POI-Layer an, Zoom genügend
|
||
if (autoPoiLoadEnabled && !explorerPoiLoading) {
|
||
val cp = ml.cameraPosition
|
||
val zoom = cp.zoom
|
||
val cLat = cp.target?.latitude ?: return@addOnCameraIdleListener
|
||
val cLon = cp.target?.longitude ?: return@addOnCameraIdleListener
|
||
val activeCats = buildSet<de.waypointaudio.data.PoiCategory> {
|
||
if (layerState.poiLayers.showSights) add(de.waypointaudio.data.PoiCategory.SIGHTS)
|
||
if (layerState.poiLayers.showGastronomy) add(de.waypointaudio.data.PoiCategory.GASTRONOMY)
|
||
if (layerState.poiLayers.showMobility) add(de.waypointaudio.data.PoiCategory.MOBILITY)
|
||
if (layerState.poiLayers.showInfrastructure) add(de.waypointaudio.data.PoiCategory.INFRASTRUCTURE)
|
||
}
|
||
if (de.waypointaudio.util.ExplorerPoiClient.shouldAutoLoad(
|
||
zoom, cLat, cLon,
|
||
lastAutoLoadLat, lastAutoLoadLon, lastAutoLoadZoom,
|
||
lastAutoLoadCats, activeCats
|
||
)
|
||
) {
|
||
// v2.5.46: Debounce erhöht auf 2.5 s (vorher 1.5 s)
|
||
poiAutoLoadJob?.cancel()
|
||
poiAutoLoadJob = scope.launch {
|
||
delay(2500L)
|
||
if (explorerPoiLoading) return@launch
|
||
val bounds = ml.projection.visibleRegion.latLngBounds
|
||
val bbox = de.waypointaudio.util.LatLngBbox(
|
||
south = bounds.southWest.latitude,
|
||
west = bounds.southWest.longitude,
|
||
north = bounds.northEast.latitude,
|
||
east = bounds.northEast.longitude
|
||
)
|
||
explorerPoiLoading = true
|
||
autoPoiStatus = null
|
||
try {
|
||
val results = de.waypointaudio.util.ExplorerPoiClient.loadPois(
|
||
context = context,
|
||
bbox = bbox,
|
||
categories = activeCats,
|
||
onRadiusClamped = {}
|
||
)
|
||
explorerPoiResults = results
|
||
lastAutoLoadLat = cLat
|
||
lastAutoLoadLon = cLon
|
||
lastAutoLoadZoom = zoom
|
||
lastAutoLoadCats = activeCats
|
||
val total = results.values.sumOf { it.size }
|
||
autoPoiStatus = if (total == 0) null else "POIs: $total"
|
||
} catch (e: Exception) {
|
||
// Alten Bestand behalten, nur dezente Fehlermeldung
|
||
autoPoiStatus = null
|
||
explorerPoiSnackbar = "POI-Aktualisierung fehlgeschlagen."
|
||
} finally {
|
||
explorerPoiLoading = false
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
mv.onStart()
|
||
mv.onResume()
|
||
mapView = mv
|
||
}
|
||
},
|
||
update = { /* state already wired via mapLibreMap */ }
|
||
)
|
||
|
||
Surface(
|
||
shape = RoundedCornerShape(20.dp),
|
||
color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.92f),
|
||
shadowElevation = 4.dp,
|
||
modifier = Modifier
|
||
.align(Alignment.TopCenter)
|
||
.padding(top = 8.dp, start = 12.dp, end = 12.dp)
|
||
) {
|
||
Row(
|
||
modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
|
||
verticalAlignment = Alignment.CenterVertically,
|
||
horizontalArrangement = Arrangement.spacedBy(8.dp)
|
||
) {
|
||
val tapHint: String? = when (tapMode) {
|
||
is TapModeMl.PlaceNew -> stringResource(R.string.explorer_tap_place_active)
|
||
is TapModeMl.MoveWaypoint -> stringResource(R.string.explorer_tap_move_active)
|
||
is TapModeMl.MoveTrackPoint -> stringResource(R.string.explorer_tap_move_track_active)
|
||
is TapModeMl.DrawRoutePoint ->
|
||
stringResource(R.string.explorer_mode_draw_route_active)
|
||
is TapModeMl.MoveRoutePoint ->
|
||
stringResource(R.string.explorer_route_point_move_active)
|
||
TapModeMl.None -> null
|
||
}
|
||
if (tapHint != null) {
|
||
Icon(
|
||
Icons.Filled.TouchApp,
|
||
contentDescription = null,
|
||
modifier = Modifier.size(16.dp),
|
||
tint = MaterialTheme.colorScheme.tertiary
|
||
)
|
||
Text(
|
||
tapHint,
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||
)
|
||
} else {
|
||
val statusIcon = when {
|
||
isRecording -> Icons.Filled.FiberManualRecord
|
||
activeDraft != null -> Icons.Filled.Timeline
|
||
else -> Icons.Filled.Place
|
||
}
|
||
val statusText = when {
|
||
isRecording -> stringResource(
|
||
R.string.explorer_status_recording_compact, currentTrack.size
|
||
)
|
||
activeDraft != null -> stringResource(
|
||
R.string.explorer_status_draft_compact,
|
||
activeDraft.markedCount, activeDraft.pointCount
|
||
)
|
||
else -> stringResource(
|
||
R.string.explorer_status_compact, waypoints.size
|
||
)
|
||
}
|
||
val statusTint = when {
|
||
isRecording -> MaterialTheme.colorScheme.error
|
||
else -> MaterialTheme.colorScheme.primary
|
||
}
|
||
Icon(
|
||
statusIcon,
|
||
contentDescription = null,
|
||
modifier = Modifier.size(16.dp),
|
||
tint = statusTint
|
||
)
|
||
Text(
|
||
statusText,
|
||
style = MaterialTheme.typography.labelMedium,
|
||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||
)
|
||
val acc = lastAccuracyM
|
||
if (acc != null) {
|
||
Text(
|
||
"· ${stringResource(R.string.explorer_accuracy_meters, acc.toInt())}",
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.75f)
|
||
)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
AnimatedVisibility(
|
||
visible = tapMode !is TapModeMl.None,
|
||
modifier = Modifier
|
||
.align(Alignment.BottomCenter)
|
||
.padding(bottom = 40.dp),
|
||
enter = fadeIn() + slideInVertically(initialOffsetY = { it }),
|
||
exit = fadeOut() + slideOutVertically(targetOffsetY = { it })
|
||
) {
|
||
FilterChip(
|
||
selected = true,
|
||
onClick = {
|
||
// v2.5.3 — Cancel verlässt auch den manualRouteMode,
|
||
// damit der violette FAB visuell wieder deaktiviert ist.
|
||
if (tapMode is TapModeMl.DrawRoutePoint) manualRouteMode = false
|
||
tapMode = TapModeMl.None
|
||
},
|
||
label = {
|
||
Text(stringResource(R.string.explorer_cancel_tap))
|
||
}
|
||
)
|
||
}
|
||
|
||
MapLayerFab(
|
||
state = layerState,
|
||
onStateChange = { layerState = it },
|
||
customSatelliteUrl = mapStyleSettings.customSatelliteUrl,
|
||
onCustomSatelliteUrlChange = { url ->
|
||
scope.launch {
|
||
runCatching { mapStyleStore.setCustomSatelliteUrl(url) }
|
||
}
|
||
},
|
||
customTopoUrl = mapStyleSettings.customTopoUrl,
|
||
onCustomTopoUrlChange = { url ->
|
||
scope.launch {
|
||
runCatching { mapStyleStore.setCustomTopoUrl(url) }
|
||
}
|
||
},
|
||
customTerrainDemUrl = mapStyleSettings.customTerrainDemUrl,
|
||
onCustomTerrainDemUrlChange = { url ->
|
||
scope.launch {
|
||
runCatching { mapStyleStore.setCustomTerrainDemUrl(url) }
|
||
}
|
||
},
|
||
perspectiveTilt = mapStyleSettings.perspectiveTilt,
|
||
onPerspectiveTiltChange = { tilt ->
|
||
scope.launch {
|
||
runCatching { mapStyleStore.setPerspectiveTilt(tilt) }
|
||
}
|
||
},
|
||
onShowRoutingInfo = { showRoutingInfo = true },
|
||
onShowRoutePlanner = { showRoutePlanner = true },
|
||
// v2.5.45 — Auto-Load-Toggle
|
||
poiAutoLoadEnabled = autoPoiLoadEnabled,
|
||
onPoiAutoLoadChange = { enabled ->
|
||
autoPoiLoadEnabled = enabled
|
||
if (!enabled) poiAutoLoadJob?.cancel()
|
||
},
|
||
modifier = Modifier
|
||
.align(Alignment.TopEnd)
|
||
.padding(top = 8.dp, end = 8.dp)
|
||
)
|
||
|
||
// Renderer-Badge: zeigt deutlich, dass MapLibre als aktiver Renderer läuft.
|
||
Surface(
|
||
shape = RoundedCornerShape(8.dp),
|
||
color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.92f),
|
||
shadowElevation = 2.dp,
|
||
modifier = Modifier
|
||
.align(Alignment.BottomEnd)
|
||
.padding(end = 6.dp, bottom = 6.dp)
|
||
) {
|
||
Text(
|
||
text = stringResource(R.string.explorer_renderer_maplibre_badge),
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onPrimaryContainer,
|
||
modifier = Modifier.padding(horizontal = 8.dp, vertical = 3.dp)
|
||
)
|
||
}
|
||
|
||
// v2.5.38 — Kompaktes Attribution-Badge, ersetzt altes OsmAttributionBadge.
|
||
// Pflichtangabe ist stets sichtbar, aber schöner und nicht überlagernd.
|
||
MapCompactAttributionBadge(
|
||
modifier = Modifier
|
||
.align(Alignment.BottomStart)
|
||
.padding(start = 6.dp, bottom = 6.dp)
|
||
)
|
||
|
||
// v2.5.41 — POI-Legende: einklappbare Kategorie-Übersicht
|
||
// Nur anzeigen wenn mindestens ein POI-Layer aktiv ist
|
||
val anyPoiLayerActive = layerState.poiLayers.let {
|
||
it.showSights || it.showGastronomy || it.showMobility || it.showInfrastructure
|
||
}
|
||
if (anyPoiLayerActive) {
|
||
ExplorerPoiLegend(
|
||
poiLayers = layerState.poiLayers,
|
||
expanded = poiLegendExpanded,
|
||
onToggle = { poiLegendExpanded = !poiLegendExpanded },
|
||
modifier = Modifier
|
||
.align(Alignment.BottomStart)
|
||
.padding(start = 6.dp, bottom = 30.dp)
|
||
)
|
||
}
|
||
|
||
// v2.5.45 — Explorer-POI-Bar (Auto-Load-Status + manueller Fallback)
|
||
// Kompaktes Pill-Design: links Status/Ladeindikator, rechts manueller Reload-Button.
|
||
// Nur sichtbar wenn mindestens ein POI-Layer aktiv ist.
|
||
val anyPoiLayerActiveForBar = layerState.poiLayers.let {
|
||
it.showSights || it.showGastronomy || it.showMobility || it.showInfrastructure
|
||
}
|
||
if (anyPoiLayerActiveForBar) {
|
||
Surface(
|
||
shape = RoundedCornerShape(20.dp),
|
||
color = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.92f),
|
||
shadowElevation = 3.dp,
|
||
modifier = Modifier
|
||
.align(Alignment.BottomCenter)
|
||
.padding(bottom = 32.dp)
|
||
) {
|
||
Row(
|
||
modifier = Modifier.padding(horizontal = 10.dp, vertical = 5.dp),
|
||
verticalAlignment = Alignment.CenterVertically,
|
||
horizontalArrangement = Arrangement.spacedBy(6.dp)
|
||
) {
|
||
// Status-Icon/Spinner
|
||
if (explorerPoiLoading) {
|
||
CircularProgressIndicator(
|
||
modifier = Modifier.size(13.dp),
|
||
strokeWidth = 1.8.dp,
|
||
color = MaterialTheme.colorScheme.onSecondaryContainer
|
||
)
|
||
} else {
|
||
Icon(
|
||
if (autoPoiLoadEnabled) Icons.Filled.Explore else Icons.Filled.Explore,
|
||
contentDescription = null,
|
||
modifier = Modifier.size(13.dp),
|
||
tint = MaterialTheme.colorScheme.onSecondaryContainer.copy(
|
||
alpha = if (autoPoiLoadEnabled) 1f else 0.55f
|
||
)
|
||
)
|
||
}
|
||
// v2.5.46 — Status-Text: nur bei echtem Laden "wird geladen",
|
||
// sonst ruhiger Status-Text
|
||
val statusText = when {
|
||
explorerPoiLoading -> "POIs laden…"
|
||
autoPoiStatus != null -> autoPoiStatus!!
|
||
autoPoiLoadEnabled && currentMapZoom < de.waypointaudio.util.ExplorerPoiClient.AUTO_LOAD_MIN_ZOOM
|
||
-> "Hereinzoomen für Auto-Load"
|
||
autoPoiLoadEnabled -> "Auto-Laden aktiv"
|
||
else -> "POIs: manuell"
|
||
}
|
||
Text(
|
||
text = statusText,
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSecondaryContainer
|
||
)
|
||
// Trennstrich
|
||
Text(
|
||
"·",
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSecondaryContainer.copy(alpha = 0.5f)
|
||
)
|
||
// Manueller Neu-Laden Button
|
||
Text(
|
||
text = "↻",
|
||
style = MaterialTheme.typography.labelMedium,
|
||
fontWeight = androidx.compose.ui.text.font.FontWeight.Bold,
|
||
color = if (explorerPoiLoading)
|
||
MaterialTheme.colorScheme.onSecondaryContainer.copy(alpha = 0.4f)
|
||
else
|
||
MaterialTheme.colorScheme.onSecondaryContainer,
|
||
modifier = Modifier.clickable(enabled = !explorerPoiLoading) {
|
||
val ml = mapLibreMap ?: return@clickable
|
||
val bounds = ml.projection.visibleRegion.latLngBounds
|
||
val bbox = LatLngBbox(
|
||
south = bounds.southWest.latitude,
|
||
west = bounds.southWest.longitude,
|
||
north = bounds.northEast.latitude,
|
||
east = bounds.northEast.longitude
|
||
)
|
||
val cats = buildSet<PoiCategory> {
|
||
if (layerState.poiLayers.showSights) add(PoiCategory.SIGHTS)
|
||
if (layerState.poiLayers.showGastronomy) add(PoiCategory.GASTRONOMY)
|
||
if (layerState.poiLayers.showMobility) add(PoiCategory.MOBILITY)
|
||
if (layerState.poiLayers.showInfrastructure) add(PoiCategory.INFRASTRUCTURE)
|
||
}
|
||
// Manueller Reload: Cache leeren, Cursor zurücksetzen
|
||
de.waypointaudio.util.ExplorerPoiClient.clearCache()
|
||
lastAutoLoadCats = null
|
||
explorerPoiLoading = true
|
||
autoPoiStatus = null
|
||
scope.launch {
|
||
try {
|
||
val results = ExplorerPoiClient.loadPois(
|
||
context = context,
|
||
bbox = bbox,
|
||
categories = cats,
|
||
onRadiusClamped = {
|
||
explorerPoiSnackbar = "Kartenausschnitt zu groß – Abfrage auf max. 5 km begrenzt."
|
||
}
|
||
)
|
||
val total = results.values.sumOf { it.size }
|
||
explorerPoiResults = results
|
||
val cp = ml.cameraPosition
|
||
lastAutoLoadLat = cp.target?.latitude
|
||
lastAutoLoadLon = cp.target?.longitude
|
||
lastAutoLoadZoom = cp.zoom
|
||
lastAutoLoadCats = cats
|
||
autoPoiStatus = if (total > 0) "$total" else null
|
||
explorerPoiSnackbar = if (total == 0)
|
||
"Keine POIs in diesem Bereich."
|
||
else
|
||
ExplorerPoiClient.summarize(results)
|
||
} catch (e: Exception) {
|
||
explorerPoiSnackbar = "POI-Laden fehlgeschlagen: ${e.message?.take(60) ?: "Netzwerkfehler"}"
|
||
} finally {
|
||
explorerPoiLoading = false
|
||
}
|
||
}
|
||
}
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
// v2.5.40 — Snackbar-Host für Explorer-POI-Meldungen
|
||
SnackbarHost(
|
||
hostState = snackbarHostState,
|
||
modifier = Modifier
|
||
.align(Alignment.BottomCenter)
|
||
.padding(bottom = 80.dp)
|
||
)
|
||
}
|
||
}
|
||
|
||
// v2.5.40 — Explorer-POI-Detail-Sheet
|
||
selectedExplorerPoi?.let { poi ->
|
||
val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
|
||
ModalBottomSheet(
|
||
onDismissRequest = { selectedExplorerPoi = null },
|
||
sheetState = sheetState
|
||
) {
|
||
Column(
|
||
modifier = Modifier
|
||
.fillMaxWidth()
|
||
.heightIn(max = 500.dp)
|
||
.verticalScroll(rememberScrollState())
|
||
.padding(horizontal = 20.dp)
|
||
.padding(bottom = 24.dp),
|
||
verticalArrangement = Arrangement.spacedBy(8.dp)
|
||
) {
|
||
// Titel
|
||
Row(verticalAlignment = Alignment.CenterVertically) {
|
||
Icon(
|
||
Icons.Filled.Place,
|
||
contentDescription = null,
|
||
modifier = Modifier.size(22.dp),
|
||
tint = MaterialTheme.colorScheme.primary
|
||
)
|
||
Spacer(Modifier.width(8.dp))
|
||
Text(poi.displayName, style = MaterialTheme.typography.titleMedium)
|
||
}
|
||
// Kategorie + Entfernung
|
||
val distText = if (lastLat != null && lastLng != null) {
|
||
val d = ExplorerPoiClient.haversineM(lastLat!!, lastLng!!, poi.latitude, poi.longitude)
|
||
if (d < 1000) "%.0f m entfernt".format(d)
|
||
else "%.1f km entfernt".format(d / 1000.0)
|
||
} else null
|
||
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||
// v2.5.45 — Subtype-Label (konkreter) statt nur Kategorie
|
||
Surface(
|
||
shape = RoundedCornerShape(8.dp),
|
||
color = MaterialTheme.colorScheme.secondaryContainer
|
||
) {
|
||
Text(
|
||
poi.subtype.displayLabel, // z.B. "Burg/Schloss" statt "Sehenswürdigkeit"
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSecondaryContainer,
|
||
modifier = Modifier.padding(horizontal = 8.dp, vertical = 3.dp)
|
||
)
|
||
}
|
||
if (distText != null) {
|
||
Surface(
|
||
shape = RoundedCornerShape(8.dp),
|
||
color = MaterialTheme.colorScheme.surfaceVariant
|
||
) {
|
||
Text(
|
||
distText,
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||
modifier = Modifier.padding(horizontal = 8.dp, vertical = 3.dp)
|
||
)
|
||
}
|
||
}
|
||
}
|
||
// Koordinaten
|
||
Text(
|
||
"%.5f, %.5f".format(poi.latitude, poi.longitude),
|
||
style = MaterialTheme.typography.bodySmall,
|
||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||
)
|
||
// OSM-Tags (kompakt, max. 6)
|
||
if (poi.rawTags.isNotEmpty()) {
|
||
Spacer(Modifier.height(2.dp))
|
||
Text(
|
||
"OSM-Tags",
|
||
style = MaterialTheme.typography.labelMedium,
|
||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||
)
|
||
poi.rawTags.entries.take(6).forEach { (k, v) ->
|
||
Text(
|
||
"$k = $v",
|
||
style = MaterialTheme.typography.bodySmall
|
||
)
|
||
}
|
||
}
|
||
// Attribution
|
||
Text(
|
||
"POI-Daten: OpenStreetMap/Overpass (ODbL)",
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.65f)
|
||
)
|
||
Spacer(Modifier.height(4.dp))
|
||
// Aktionen
|
||
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||
TextButton(onClick = {
|
||
// Als Wegpunkt anlegen
|
||
val newWp = Waypoint(
|
||
latitude = poi.latitude,
|
||
longitude = poi.longitude,
|
||
name = poi.displayName,
|
||
tourName = selectedTour,
|
||
)
|
||
viewModel.upsert(newWp)
|
||
selectedExplorerPoi = null
|
||
explorerPoiSnackbar = "\"${poi.displayName}\" als Wegpunkt angelegt."
|
||
}) {
|
||
Icon(Icons.Filled.AddLocation, contentDescription = null, modifier = Modifier.size(16.dp))
|
||
Spacer(Modifier.width(4.dp))
|
||
Text("Als Wegpunkt")
|
||
}
|
||
TextButton(onClick = { selectedExplorerPoi = null }) {
|
||
Text("Schließen")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
DisposableEffect(Unit) {
|
||
onDispose {
|
||
runCatching {
|
||
mapView?.onPause()
|
||
mapView?.onStop()
|
||
mapView?.onDestroy()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private data class DraftPointSelectionMl(val index: Int)
|
||
|
||
private sealed interface TapModeMl {
|
||
data object None : TapModeMl
|
||
data object PlaceNew : TapModeMl
|
||
data class MoveWaypoint(val id: String) : TapModeMl
|
||
data class MoveTrackPoint(val index: Int) : TapModeMl
|
||
/** v2.5.3 — Manueller Routemodus: Tippen setzt einen stillen Routenpunkt. */
|
||
data object DrawRoutePoint : TapModeMl
|
||
/** v2.5.3 — Verschieben eines Routenpunkts an Index [index] der Polyline. */
|
||
data class MoveRoutePoint(val index: Int) : TapModeMl
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// Overlay-Renderer (MapLibre Annotation API)
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
private fun clearAllAnnotationsCaches(
|
||
waypointMarkers: MutableList<Marker>,
|
||
waypointMarkerIdToWaypoint: MutableMap<Long, Waypoint>,
|
||
waypointRadiusPolygons: MutableList<Polygon>,
|
||
trackMarkers: MutableList<Marker>,
|
||
trackMarkerIdToIndex: MutableMap<Long, Int>,
|
||
trackPolylines: MutableList<Polyline>,
|
||
routePolylines: MutableList<Polyline>,
|
||
audioLinePolylines: MutableList<Polyline>,
|
||
manualRoutePolylines: MutableList<Polyline>? = null,
|
||
manualRouteMarkers: MutableList<Marker>? = null,
|
||
manualRouteMarkerIdToIndex: MutableMap<Long, Int>? = null,
|
||
) {
|
||
waypointMarkers.clear()
|
||
waypointMarkerIdToWaypoint.clear()
|
||
waypointRadiusPolygons.clear()
|
||
trackMarkers.clear()
|
||
trackMarkerIdToIndex.clear()
|
||
trackPolylines.clear()
|
||
routePolylines.clear()
|
||
audioLinePolylines.clear()
|
||
manualRoutePolylines?.clear()
|
||
manualRouteMarkers?.clear()
|
||
manualRouteMarkerIdToIndex?.clear()
|
||
}
|
||
|
||
@Suppress("LongParameterList")
|
||
private fun drawExplorerOverlaysMapLibre(
|
||
ml: MapLibreMap,
|
||
context: android.content.Context,
|
||
waypoints: List<Waypoint>,
|
||
track: List<GpsTrackPoint>,
|
||
markedIndexes: List<Int>,
|
||
selectedTrackIndex: Int?,
|
||
primaryArgb: Int,
|
||
trackArgb: Int,
|
||
showRadius: Boolean,
|
||
showAudioLength: Boolean,
|
||
showAudioLines: Boolean,
|
||
audioDurationsMs: Map<String, Long>,
|
||
selectedId: String?,
|
||
searchPin: LatLng?,
|
||
clipLineGeometry: List<LatLng>?,
|
||
waypointMarkers: MutableList<Marker>,
|
||
waypointMarkerIdToWaypoint: MutableMap<Long, Waypoint>,
|
||
waypointRadiusPolygons: MutableList<Polygon>,
|
||
trackMarkers: MutableList<Marker>,
|
||
trackMarkerIdToIndex: MutableMap<Long, Int>,
|
||
trackPolylines: MutableList<Polyline>,
|
||
audioLinePolylines: MutableList<Polyline>,
|
||
searchPinMarkerRef: (Marker?) -> Unit,
|
||
currentSearchPinMarker: Marker?,
|
||
) {
|
||
// Vorhandene eigene Annotations entfernen.
|
||
for (m in waypointMarkers) runCatching { ml.removeMarker(m) }
|
||
waypointMarkers.clear()
|
||
waypointMarkerIdToWaypoint.clear()
|
||
for (p in waypointRadiusPolygons) runCatching { ml.removePolygon(p) }
|
||
waypointRadiusPolygons.clear()
|
||
for (m in trackMarkers) runCatching { ml.removeMarker(m) }
|
||
trackMarkers.clear()
|
||
trackMarkerIdToIndex.clear()
|
||
for (l in trackPolylines) runCatching { ml.removePolyline(l) }
|
||
trackPolylines.clear()
|
||
for (l in audioLinePolylines) runCatching { ml.removePolyline(l) }
|
||
audioLinePolylines.clear()
|
||
currentSearchPinMarker?.let { runCatching { ml.removeMarker(it) } }
|
||
searchPinMarkerRef(null)
|
||
|
||
val density = context.resources.displayMetrics.density
|
||
val iconFactory = IconFactory.getInstance(context)
|
||
|
||
// Track-Polyline (Halo + Linie).
|
||
if (track.size >= 2) {
|
||
val pts = track.map { LatLng(it.latitude, it.longitude) }
|
||
val halo = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(pts)
|
||
.color(0xFFFFFFFF.toInt())
|
||
.width(10f)
|
||
.alpha(0.85f)
|
||
)
|
||
val line = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(pts)
|
||
.color(trackArgb)
|
||
.width(6f)
|
||
.alpha(1.0f)
|
||
)
|
||
trackPolylines += halo
|
||
trackPolylines += line
|
||
}
|
||
|
||
if (track.isNotEmpty()) {
|
||
val markedSet = markedIndexes.toSet()
|
||
track.forEachIndexed { idx, p ->
|
||
val gp = LatLng(p.latitude, p.longitude)
|
||
val isMarked = idx in markedSet
|
||
val isSelected = idx == selectedTrackIndex
|
||
val sizePx = when {
|
||
isSelected -> 80
|
||
isMarked -> 64
|
||
else -> 44
|
||
}
|
||
val color = when {
|
||
isSelected -> 0xFFFF5252.toInt()
|
||
isMarked -> 0xFFFFAB00.toInt()
|
||
else -> trackArgb
|
||
}
|
||
val bm = trackPointBitmap(sizePx, color, isSelected)
|
||
val marker = ml.addMarker(
|
||
MarkerOptions()
|
||
.position(gp)
|
||
.icon(iconFactory.fromBitmap(bm))
|
||
)
|
||
trackMarkers += marker
|
||
trackMarkerIdToIndex[marker.id] = idx
|
||
}
|
||
}
|
||
|
||
// v2.4.5 — Clip-Längenlinien NUR entlang bekannter Geometrie (Track/Route),
|
||
// sonst gar nicht. Pro Waypoint wird ein Abschnitt der Länge proportional
|
||
// zur Audiodauer auf der Geometrie gezeichnet.
|
||
//
|
||
// Änderung gegenüber v2.4.4: Der Waypoint markiert nicht mehr die MITTE,
|
||
// sondern den ANFANG des Clip-Abschnitts. Der Abschnitt erstreckt sich
|
||
// von der Projektionsposition des Waypoints in Richtung Routenende
|
||
// (nach vorne entlang der Route/Track-Richtung). Damit "wirkt" der
|
||
// Waypoint visuell als Trigger-Start des Clips, nicht als dessen Mittelpunkt.
|
||
//
|
||
// Sonderfall: Wenn der Waypoint nahe dem Ende der Geometrie liegt und
|
||
// nicht mehr genug Vorwärtsweg verbleibt, wird der Abschnitt nach hinten
|
||
// verlängert, damit er sichtbar bleibt — eine Fantasielinie über das
|
||
// Geometrieende hinaus zeichnen wir bewusst nicht.
|
||
if (showAudioLines && waypoints.isNotEmpty() && clipLineGeometry != null && clipLineGeometry.size >= 2) {
|
||
val cumulative = cumulativeMeters(clipLineGeometry)
|
||
val totalLen = cumulative.last()
|
||
for (wp in waypoints) {
|
||
val durationMs = audioDurationsMs[wp.soundUri] ?: 0L
|
||
if (durationMs <= 0L) continue
|
||
val sec = durationMs / 1000.0
|
||
val segLen = (sec * 5.0).coerceIn(15.0, 250.0).coerceAtMost(totalLen)
|
||
// anchor auf der Geometrie: nächster Punkt zu (wp.lat, wp.lng)
|
||
val anchorM = projectOntoGeometry(clipLineGeometry, cumulative, wp.latitude, wp.longitude)
|
||
// v2.4.5: Start AB Waypoint nach vorne entlang der Geometrie.
|
||
var startM = anchorM
|
||
var endM = startM + segLen
|
||
if (endM > totalLen) {
|
||
// Nahe dem Geometrieende: Abschnitt zurückziehen, damit er
|
||
// ganz auf der Geometrie liegt (keine Linie ins Nichts).
|
||
endM = totalLen
|
||
startM = (endM - segLen).coerceAtLeast(0.0)
|
||
}
|
||
val segPoints = sliceGeometry(clipLineGeometry, cumulative, startM, endM)
|
||
if (segPoints.size < 2) continue
|
||
val bucket = WaypointAudioDuration.classify(durationMs)
|
||
val color = when (bucket) {
|
||
de.waypointaudio.util.AudioLengthBucket.SHORT -> 0xFF66BB6A.toInt()
|
||
de.waypointaudio.util.AudioLengthBucket.MEDIUM -> 0xFFFFA726.toInt()
|
||
de.waypointaudio.util.AudioLengthBucket.LONG -> 0xFFE53935.toInt()
|
||
else -> primaryArgb
|
||
}
|
||
val w = when (bucket) {
|
||
de.waypointaudio.util.AudioLengthBucket.LONG -> 7f
|
||
de.waypointaudio.util.AudioLengthBucket.MEDIUM -> 5f
|
||
else -> 4f
|
||
}
|
||
val halo = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(segPoints)
|
||
.color(0xFFFFFFFF.toInt())
|
||
.width(w + 3f)
|
||
.alpha(0.85f)
|
||
)
|
||
val line = ml.addPolyline(
|
||
PolylineOptions()
|
||
.addAll(segPoints)
|
||
.color(color)
|
||
.width(w)
|
||
.alpha(0.95f)
|
||
)
|
||
audioLinePolylines += halo
|
||
audioLinePolylines += line
|
||
}
|
||
}
|
||
|
||
for (wp in waypoints) {
|
||
val gp = LatLng(wp.latitude, wp.longitude)
|
||
if (showRadius && wp.radiusMeters > 0) {
|
||
val circle = ml.addPolygon(
|
||
PolygonOptions()
|
||
.addAll(circleLatLng(wp.latitude, wp.longitude, wp.radiusMeters.toDouble(), 48))
|
||
.fillColor((primaryArgb and 0x00FFFFFF) or 0x40000000)
|
||
.strokeColor(primaryArgb)
|
||
.alpha(0.5f)
|
||
)
|
||
waypointRadiusPolygons += circle
|
||
}
|
||
|
||
val isSelected = wp.id == selectedId
|
||
val durationMs = if (showAudioLength) {
|
||
audioDurationsMs[wp.soundUri] ?: 0L
|
||
} else 0L
|
||
val bm = if (durationMs > 0L) {
|
||
waypointDotWithRing(primaryArgb, density, isSelected, durationMs)
|
||
} else {
|
||
waypointDotPlain(primaryArgb, density, isSelected)
|
||
}
|
||
val marker = ml.addMarker(
|
||
MarkerOptions()
|
||
.position(gp)
|
||
.title(wp.name.ifBlank { "Wegpunkt" })
|
||
.icon(iconFactory.fromBitmap(bm))
|
||
)
|
||
waypointMarkers += marker
|
||
waypointMarkerIdToWaypoint[marker.id] = wp
|
||
}
|
||
|
||
if (searchPin != null) {
|
||
val pinBm = makeSearchPinBitmapShared(96)
|
||
val pinMarker = ml.addMarker(
|
||
MarkerOptions()
|
||
.position(searchPin)
|
||
.icon(iconFactory.fromBitmap(pinBm))
|
||
)
|
||
searchPinMarkerRef(pinMarker)
|
||
}
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// Bitmap-Helfer (lokal, damit unabhängig vom osmdroid-Renderer)
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
private fun explorerMlLocationPuckBitmap(context: android.content.Context): Bitmap? {
|
||
return runCatching {
|
||
val drawable = ContextCompat.getDrawable(context, R.drawable.ic_my_location_puck)
|
||
?: return@runCatching null
|
||
val size = (48 * context.resources.displayMetrics.density).toInt()
|
||
val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
|
||
val canvas = Canvas(bitmap)
|
||
drawable.setBounds(0, 0, canvas.width, canvas.height)
|
||
drawable.draw(canvas)
|
||
bitmap
|
||
}.getOrNull()
|
||
}
|
||
|
||
private fun trackPointBitmap(sizePx: Int, argb: Int, selected: Boolean): Bitmap {
|
||
val size = sizePx.coerceAtLeast(16)
|
||
val bm = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
|
||
val canvas = Canvas(bm)
|
||
val cx = size / 2f; val cy = size / 2f
|
||
val outerR = size / 2f - 2f
|
||
val halo = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.FILL
|
||
color = 0xFFFFFFFF.toInt()
|
||
alpha = 220
|
||
}
|
||
canvas.drawCircle(cx, cy, outerR, halo)
|
||
val fill = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.FILL
|
||
color = argb
|
||
}
|
||
canvas.drawCircle(cx, cy, outerR - size * 0.18f, fill)
|
||
if (selected) {
|
||
val ring = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.STROKE
|
||
color = 0xFF000000.toInt()
|
||
strokeWidth = (size * 0.08f).coerceAtLeast(3f)
|
||
}
|
||
canvas.drawCircle(cx, cy, outerR - size * 0.20f, ring)
|
||
}
|
||
return bm
|
||
}
|
||
|
||
/**
|
||
* v2.4.6 — Baut aus dem aktuellen Routenplaner-Zustand eine [TourRoute].
|
||
*
|
||
* Bevorzugt die aktuell berechnete OSRM-Routenlinie; fällt auf die Planlinie
|
||
* zurück, wenn keine berechnete Route vorhanden ist. Gibt `null` zurück,
|
||
* wenn überhaupt keine nutzbare Geometrie existiert — die UI verhindert
|
||
* dann das Speichern.
|
||
*/
|
||
private fun buildTourRouteFromState(
|
||
plan: RoutePlan,
|
||
routeLine: List<LatLng>,
|
||
routePlanline: List<LatLng>,
|
||
distanceMeters: Double?,
|
||
durationSeconds: Double?,
|
||
endpoint: String,
|
||
planlineSourceLabel: String,
|
||
): de.waypointaudio.data.TourRoute? {
|
||
val useComputed = routeLine.size >= 2
|
||
val poly = when {
|
||
useComputed -> routeLine
|
||
routePlanline.size >= 2 -> routePlanline
|
||
else -> return null
|
||
}
|
||
val routePoints = poly.map {
|
||
de.waypointaudio.data.TourRoutePoint(lat = it.latitude, lon = it.longitude)
|
||
}
|
||
fun toStop(rs: RouteStop?): de.waypointaudio.data.TourRouteStop? =
|
||
rs?.let {
|
||
de.waypointaudio.data.TourRouteStop(
|
||
latitude = it.latitude,
|
||
longitude = it.longitude,
|
||
label = it.label,
|
||
sourceHint = it.source.name
|
||
)
|
||
}
|
||
val viaStops = plan.via.map {
|
||
de.waypointaudio.data.TourRouteStop(
|
||
latitude = it.latitude,
|
||
longitude = it.longitude,
|
||
label = it.label,
|
||
sourceHint = it.source.name
|
||
)
|
||
}
|
||
return de.waypointaudio.data.TourRoute(
|
||
start = toStop(plan.start),
|
||
destination = toStop(plan.destination),
|
||
via = viaStops,
|
||
polyline = routePoints,
|
||
// v2.5.2 — Profil aus dem aktuellen Plan übernehmen, damit gespeicherte
|
||
// Tourrouten später wissen, ob sie Auto/Fahrrad/Fußgänger waren.
|
||
profile = plan.profile.osrmKey,
|
||
source = if (useComputed) de.waypointaudio.data.RouteSourceKind.OSRM
|
||
else de.waypointaudio.data.RouteSourceKind.PLANLINE,
|
||
endpoint = if (useComputed) endpoint else planlineSourceLabel,
|
||
distanceMeters = if (useComputed) distanceMeters else null,
|
||
durationSeconds = if (useComputed) durationSeconds else null
|
||
)
|
||
}
|
||
|
||
/**
|
||
* v2.5.2 — Liefert die String-Ressource für das angegebene Routingprofil.
|
||
* Wird sowohl für UI-Labels als auch für Fehlermeldungen benötigt.
|
||
*/
|
||
@androidx.annotation.StringRes
|
||
private fun profileLabelRes(profile: RoutingProfile): Int = when (profile) {
|
||
RoutingProfile.DRIVING -> R.string.route_planner_profile_driving
|
||
RoutingProfile.CYCLING -> R.string.route_planner_profile_cycling
|
||
RoutingProfile.WALKING -> R.string.route_planner_profile_walking
|
||
}
|
||
|
||
/** Kategorie eines Routen-Stopps — bestimmt Farbe/Form auf der Karte. */
|
||
private enum class RouteStopKind { START, VIA, DESTINATION }
|
||
|
||
/**
|
||
* v2.4.2 — Erzeugt einen unterscheidbaren Marker für Start/Via/Ziel der Route.
|
||
*
|
||
* Start : grüne Pin-Form mit Innenring
|
||
* Via : orange Pin mit Nummern-Label (Indizes 1..n)
|
||
* Ziel : roter Pin mit „Z“-Glyph
|
||
*
|
||
* Alle Marker sind kontrastreich und auf hell/dunkel/topo/satellit gut sichtbar.
|
||
*/
|
||
private fun routeStopBitmap(
|
||
kind: RouteStopKind,
|
||
context: android.content.Context,
|
||
label: String? = null,
|
||
): Bitmap {
|
||
val density = context.resources.displayMetrics.density
|
||
val size = (44f * density).toInt().coerceAtLeast(36)
|
||
val bm = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
|
||
val canvas = Canvas(bm)
|
||
val cx = size / 2f
|
||
val cy = size / 2f
|
||
val r = size * 0.36f
|
||
val color = when (kind) {
|
||
RouteStopKind.START -> 0xFF2E7D32.toInt()
|
||
RouteStopKind.VIA -> 0xFFFB8C00.toInt()
|
||
RouteStopKind.DESTINATION -> 0xFFC62828.toInt()
|
||
}
|
||
// Halo (weiß)
|
||
val halo = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.FILL
|
||
this.color = 0xFFFFFFFF.toInt()
|
||
}
|
||
canvas.drawCircle(cx, cy, r + 4f * density, halo)
|
||
val fill = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.FILL
|
||
this.color = color
|
||
}
|
||
canvas.drawCircle(cx, cy, r, fill)
|
||
val ring = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.STROKE
|
||
strokeWidth = 2f * density
|
||
this.color = 0xFF202020.toInt()
|
||
}
|
||
canvas.drawCircle(cx, cy, r, ring)
|
||
// Glyph
|
||
val glyph = when (kind) {
|
||
RouteStopKind.START -> "S"
|
||
RouteStopKind.VIA -> label ?: "•"
|
||
RouteStopKind.DESTINATION -> "Z"
|
||
}
|
||
val text = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
this.color = 0xFFFFFFFF.toInt()
|
||
textSize = r * 1.05f
|
||
textAlign = Paint.Align.CENTER
|
||
isFakeBoldText = true
|
||
}
|
||
val baseline = cy - (text.descent() + text.ascent()) / 2f
|
||
canvas.drawText(glyph, cx, baseline, text)
|
||
return bm
|
||
}
|
||
|
||
private fun waypointDotPlain(
|
||
fillArgb: Int,
|
||
density: Float,
|
||
isSelected: Boolean
|
||
): Bitmap {
|
||
val touchDp = if (isSelected) 48f else 38f
|
||
val sizePx = (touchDp * density).toInt().coerceAtLeast(32)
|
||
val bmp = Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.ARGB_8888)
|
||
val canvas = Canvas(bmp)
|
||
val cx = sizePx / 2f
|
||
val cy = sizePx / 2f
|
||
val visibleRadius = (if (isSelected) 14f else 10f) * density
|
||
val halo = (if (isSelected) 4f else 3f) * density
|
||
|
||
val paint = Paint(Paint.ANTI_ALIAS_FLAG)
|
||
paint.style = Paint.Style.FILL
|
||
paint.color = 0xFFFFFFFF.toInt()
|
||
canvas.drawCircle(cx, cy, visibleRadius + halo, paint)
|
||
paint.color = fillArgb
|
||
canvas.drawCircle(cx, cy, visibleRadius, paint)
|
||
paint.style = Paint.Style.STROKE
|
||
paint.strokeWidth = (if (isSelected) 2.5f else 1.5f) * density
|
||
paint.color = 0xFF202020.toInt()
|
||
canvas.drawCircle(cx, cy, visibleRadius, paint)
|
||
return bmp
|
||
}
|
||
|
||
private fun waypointDotWithRing(
|
||
fillArgb: Int,
|
||
density: Float,
|
||
isSelected: Boolean,
|
||
durationMs: Long
|
||
): Bitmap {
|
||
val touchDp = if (isSelected) 60f else 50f
|
||
val sizePx = (touchDp * density).toInt().coerceAtLeast(48)
|
||
val bmp = Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.ARGB_8888)
|
||
val canvas = Canvas(bmp)
|
||
val cx = sizePx / 2f
|
||
val cy = sizePx / 2f
|
||
val visibleRadius = (if (isSelected) 14f else 10f) * density
|
||
val halo = (if (isSelected) 4f else 3f) * density
|
||
val ringInner = visibleRadius + halo + 2f * density
|
||
val ringOuter = ringInner + 4f * density
|
||
val ringMid = (ringInner + ringOuter) / 2f
|
||
val ringStroke = (ringOuter - ringInner)
|
||
|
||
val track = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.STROKE
|
||
strokeWidth = ringStroke
|
||
color = 0x33000000.toInt()
|
||
}
|
||
canvas.drawCircle(cx, cy, ringMid, track)
|
||
|
||
val bucket = WaypointAudioDuration.classify(durationMs)
|
||
val bucketColor = when (bucket) {
|
||
de.waypointaudio.util.AudioLengthBucket.SHORT -> 0xFF66BB6A.toInt()
|
||
de.waypointaudio.util.AudioLengthBucket.MEDIUM -> 0xFFFFA726.toInt()
|
||
de.waypointaudio.util.AudioLengthBucket.LONG -> 0xFFE53935.toInt()
|
||
else -> fillArgb
|
||
}
|
||
val fraction = WaypointAudioDuration.normalizedFraction(durationMs).coerceIn(0f, 1f)
|
||
val sweep = 360f * fraction
|
||
if (sweep > 0.5f) {
|
||
val progress = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||
style = Paint.Style.STROKE
|
||
strokeCap = Paint.Cap.ROUND
|
||
strokeWidth = ringStroke
|
||
color = bucketColor
|
||
}
|
||
val rectF = android.graphics.RectF(cx - ringMid, cy - ringMid, cx + ringMid, cy + ringMid)
|
||
canvas.drawArc(rectF, -90f, sweep, false, progress)
|
||
}
|
||
|
||
val paint = Paint(Paint.ANTI_ALIAS_FLAG)
|
||
paint.style = Paint.Style.FILL
|
||
paint.color = 0xFFFFFFFF.toInt()
|
||
canvas.drawCircle(cx, cy, visibleRadius + halo, paint)
|
||
paint.color = fillArgb
|
||
canvas.drawCircle(cx, cy, visibleRadius, paint)
|
||
paint.style = Paint.Style.STROKE
|
||
paint.strokeWidth = (if (isSelected) 2.5f else 1.5f) * density
|
||
paint.color = 0xFF202020.toInt()
|
||
canvas.drawCircle(cx, cy, visibleRadius, paint)
|
||
|
||
return bmp
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// Geo-Helfer
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
private fun circleLatLng(
|
||
latDeg: Double,
|
||
lonDeg: Double,
|
||
radiusMeters: Double,
|
||
steps: Int
|
||
): List<LatLng> {
|
||
val out = mutableListOf<LatLng>()
|
||
val earthRadius = 6_371_000.0
|
||
val lat0 = Math.toRadians(latDeg)
|
||
val lon0 = Math.toRadians(lonDeg)
|
||
val d = radiusMeters / earthRadius
|
||
for (i in 0 until steps) {
|
||
val bearing = Math.toRadians(i * 360.0 / steps)
|
||
val lat1 = Math.asin(
|
||
Math.sin(lat0) * Math.cos(d) + Math.cos(lat0) * Math.sin(d) * Math.cos(bearing)
|
||
)
|
||
val lon1 = lon0 + Math.atan2(
|
||
Math.sin(bearing) * Math.sin(d) * Math.cos(lat0),
|
||
Math.cos(d) - Math.sin(lat0) * Math.sin(lat1)
|
||
)
|
||
out += LatLng(Math.toDegrees(lat1), Math.toDegrees(lon1))
|
||
}
|
||
out += out.first()
|
||
return out
|
||
}
|
||
|
||
private fun haversineMeters(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
|
||
val r = 6_371_000.0
|
||
val phi1 = Math.toRadians(lat1)
|
||
val phi2 = Math.toRadians(lat2)
|
||
val dPhi = Math.toRadians(lat2 - lat1)
|
||
val dLam = Math.toRadians(lon2 - lon1)
|
||
val a = Math.sin(dPhi / 2) * Math.sin(dPhi / 2) +
|
||
Math.cos(phi1) * Math.cos(phi2) *
|
||
Math.sin(dLam / 2) * Math.sin(dLam / 2)
|
||
val c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
|
||
return r * c
|
||
}
|
||
|
||
private fun cumulativeMeters(line: List<LatLng>): DoubleArray {
|
||
val out = DoubleArray(line.size)
|
||
var acc = 0.0
|
||
out[0] = 0.0
|
||
for (i in 1 until line.size) {
|
||
acc += haversineMeters(
|
||
line[i - 1].latitude, line[i - 1].longitude,
|
||
line[i].latitude, line[i].longitude
|
||
)
|
||
out[i] = acc
|
||
}
|
||
return out
|
||
}
|
||
|
||
private fun projectOntoGeometry(
|
||
line: List<LatLng>,
|
||
cumulative: DoubleArray,
|
||
lat: Double,
|
||
lon: Double
|
||
): Double {
|
||
// Wir verwenden die Position des nächstgelegenen Linienknotens als Anker.
|
||
// Das ist robust und ohne 2D-Projektion in Metern hinreichend genau.
|
||
var bestI = 0
|
||
var bestDist = Double.MAX_VALUE
|
||
for (i in line.indices) {
|
||
val d = haversineMeters(lat, lon, line[i].latitude, line[i].longitude)
|
||
if (d < bestDist) {
|
||
bestDist = d
|
||
bestI = i
|
||
}
|
||
}
|
||
return cumulative[bestI]
|
||
}
|
||
|
||
private fun sliceGeometry(
|
||
line: List<LatLng>,
|
||
cumulative: DoubleArray,
|
||
startM: Double,
|
||
endM: Double
|
||
): List<LatLng> {
|
||
if (line.size < 2) return emptyList()
|
||
val totalLen = cumulative.last()
|
||
val s = startM.coerceIn(0.0, totalLen)
|
||
val e = endM.coerceIn(0.0, totalLen)
|
||
if (e <= s) return emptyList()
|
||
val out = mutableListOf<LatLng>()
|
||
out += interpolateOnLine(line, cumulative, s)
|
||
for (i in line.indices) {
|
||
if (cumulative[i] > s && cumulative[i] < e) {
|
||
out += line[i]
|
||
}
|
||
}
|
||
out += interpolateOnLine(line, cumulative, e)
|
||
return out
|
||
}
|
||
|
||
private fun interpolateOnLine(
|
||
line: List<LatLng>,
|
||
cumulative: DoubleArray,
|
||
distanceM: Double
|
||
): LatLng {
|
||
if (line.size == 1) return line[0]
|
||
if (distanceM <= 0.0) return line.first()
|
||
if (distanceM >= cumulative.last()) return line.last()
|
||
var i = 1
|
||
while (i < cumulative.size && cumulative[i] < distanceM) i++
|
||
val a = line[i - 1]
|
||
val b = line[i]
|
||
val da = cumulative[i - 1]
|
||
val db = cumulative[i]
|
||
val t = if (db > da) (distanceM - da) / (db - da) else 0.0
|
||
return LatLng(
|
||
a.latitude + (b.latitude - a.latitude) * t,
|
||
a.longitude + (b.longitude - a.longitude) * t
|
||
)
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// Style-Builder (v2.5.37)
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* v2.5.37 — Klassischer OSM-Raster-Style als JSON.
|
||
*
|
||
* Wird nur noch für MapBaseStyle.CLASSIC verwendet (Fallback).
|
||
* Alle anderen Stile werden über OpenFreeMap-Style-URLs geladen
|
||
* (Style.Builder().fromUri(url)).
|
||
*
|
||
* Attribution: © OpenStreetMap-Mitwirkende (ODbL).
|
||
*/
|
||
private fun buildClassicOsmStyleJson(): String {
|
||
val osmTile = "https://tile.openstreetmap.org/{z}/{x}/{y}.png"
|
||
val osmAttr = "© OpenStreetMap-Mitwirkende (ODbL)"
|
||
return """
|
||
{
|
||
"version": 8,
|
||
"name": "GPS2Audio Classic OSM v2.5.37",
|
||
"sources": {
|
||
"explorer-tiles": {
|
||
"type": "raster",
|
||
"tiles": ["$osmTile"],
|
||
"tileSize": 256,
|
||
"minzoom": 0,
|
||
"maxzoom": 19,
|
||
"attribution": "$osmAttr"
|
||
}
|
||
},
|
||
"layers": [
|
||
{
|
||
"id": "background",
|
||
"type": "background",
|
||
"paint": { "background-color": "#F5F3EE" }
|
||
},
|
||
{
|
||
"id": "explorer-tiles-layer",
|
||
"type": "raster",
|
||
"source": "explorer-tiles",
|
||
"minzoom": 0,
|
||
"maxzoom": 22,
|
||
"paint": {
|
||
"raster-brightness-min": 0.0,
|
||
"raster-brightness-max": 1.0,
|
||
"raster-saturation": 0.0,
|
||
"raster-contrast": 0.0
|
||
}
|
||
}
|
||
]
|
||
}
|
||
""".trimIndent()
|
||
}
|
||
|
||
/**
|
||
* v2.5.37 — Fügt Gebäude-Extrusion (fill-extrusion) zum geladenen MapLibre-Style hinzu,
|
||
* falls eine building-kompatible Source vorhanden ist.
|
||
*
|
||
* Strategie: Sucht nach einem vorhandenen Layer mit Typ "fill" und Source-Layer "building"
|
||
* im geladenen Style. Wenn vorhanden, wird ein fill-extrusion-Layer auf derselben Source
|
||
* hinzugefügt. Bei fehlendem Layer oder Source: kein Crash, einfacher 2D-Fallback.
|
||
*
|
||
* OpenFreeMap Positron enthält building-Daten in der OpenMapTiles-Schema-Source.
|
||
*
|
||
* Die Extrusion-Höhe wird aus dem "height"-Attribut des building-Features bezogen
|
||
* (Fallback: 10m). Dach-Abstand aus "min_height" (Fallback: 0m).
|
||
*/
|
||
private fun addBuildingExtrusionIfAvailable(style: Style) {
|
||
// Prüfe ob bereits ein extrusion-Layer vorhanden ist (z.B. nach Doppelaufruf).
|
||
val existingExtrusionId = "gps2audio-building-extrusion"
|
||
if (style.getLayer(existingExtrusionId) != null) return
|
||
|
||
// Im OpenMapTiles-Schema (verwendet von OpenFreeMap Positron) heißt die
|
||
// Vektor-Source "openmaptiles" und der Source-Layer für Gebäude "building".
|
||
val buildingSourceLayer = "building"
|
||
|
||
// Suche VOR dem ersten Label/Symbol-Layer einzufügen,
|
||
// damit Text über Gebäuden sichtbar bleibt.
|
||
val layers = style.layers
|
||
val firstSymbolLayerId = layers
|
||
.firstOrNull { it is org.maplibre.android.style.layers.SymbolLayer }
|
||
?.id
|
||
|
||
try {
|
||
// Versuche, den Layer über die MapLibre-JSON-API hinzuzufügen.
|
||
// Wir nutzen addLayerBelow falls ein Symbol-Layer existiert.
|
||
if (firstSymbolLayerId != null) {
|
||
style.addLayerBelow(
|
||
org.maplibre.android.style.layers.FillExtrusionLayer(existingExtrusionId, "openmaptiles")
|
||
.apply {
|
||
sourceLayer = buildingSourceLayer
|
||
minZoom = 14f
|
||
setProperties(
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionColor(
|
||
org.maplibre.android.style.expressions.Expression.interpolate(
|
||
org.maplibre.android.style.expressions.Expression.linear(),
|
||
org.maplibre.android.style.expressions.Expression.get("render_height"),
|
||
org.maplibre.android.style.expressions.Expression.stop(0f, org.maplibre.android.style.expressions.Expression.color(android.graphics.Color.parseColor("#EAEEF2"))),
|
||
org.maplibre.android.style.expressions.Expression.stop(200f, org.maplibre.android.style.expressions.Expression.color(android.graphics.Color.parseColor("#C8D4E0")))
|
||
)
|
||
),
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionHeight(
|
||
org.maplibre.android.style.expressions.Expression.interpolate(
|
||
org.maplibre.android.style.expressions.Expression.linear(),
|
||
org.maplibre.android.style.expressions.Expression.zoom(),
|
||
org.maplibre.android.style.expressions.Expression.stop(14f, 0f),
|
||
org.maplibre.android.style.expressions.Expression.stop(16f,
|
||
org.maplibre.android.style.expressions.Expression.get("render_height"))
|
||
)
|
||
),
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionBase(
|
||
org.maplibre.android.style.expressions.Expression.interpolate(
|
||
org.maplibre.android.style.expressions.Expression.linear(),
|
||
org.maplibre.android.style.expressions.Expression.zoom(),
|
||
org.maplibre.android.style.expressions.Expression.stop(14f, 0f),
|
||
org.maplibre.android.style.expressions.Expression.stop(16f,
|
||
org.maplibre.android.style.expressions.Expression.get("render_min_height"))
|
||
)
|
||
),
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionOpacity(0.82f)
|
||
)
|
||
},
|
||
firstSymbolLayerId
|
||
)
|
||
} else {
|
||
style.addLayer(
|
||
org.maplibre.android.style.layers.FillExtrusionLayer(existingExtrusionId, "openmaptiles")
|
||
.apply {
|
||
sourceLayer = buildingSourceLayer
|
||
minZoom = 14f
|
||
setProperties(
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionColor(
|
||
android.graphics.Color.parseColor("#EAEEF2")
|
||
),
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionHeight(
|
||
org.maplibre.android.style.expressions.Expression.get("render_height")
|
||
),
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionBase(
|
||
org.maplibre.android.style.expressions.Expression.get("render_min_height")
|
||
),
|
||
org.maplibre.android.style.layers.PropertyFactory.fillExtrusionOpacity(0.82f)
|
||
)
|
||
}
|
||
)
|
||
}
|
||
} catch (_: Exception) {
|
||
// 2D-Fallback: Extrusion konnte nicht eingetragen werden (fehlende Source, falscher Schema).
|
||
// Karte bleibt in 2D-Ansicht — kein Crash.
|
||
}
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// Drafts/Storyboard Panels — Delegation an die bewährten Implementierungen
|
||
// in ExplorerScreen.kt (dort als `internal fun` exponiert), um Duplizierung
|
||
// und Compose-Scope-Probleme zu vermeiden.
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
@Composable
|
||
private fun DraftsPanelMl(
|
||
drafts: List<TrackDraft>,
|
||
activeDraftId: String?,
|
||
isRecording: Boolean,
|
||
onActivate: (String) -> Unit,
|
||
onOpenFullEditor: (String) -> Unit,
|
||
onDelete: (String) -> Unit,
|
||
onImport: (String) -> Unit,
|
||
onClose: () -> Unit
|
||
) {
|
||
DraftsPanel(
|
||
drafts = drafts,
|
||
activeDraftId = activeDraftId,
|
||
isRecording = isRecording,
|
||
onActivate = onActivate,
|
||
onOpenFullEditor = onOpenFullEditor,
|
||
onDelete = onDelete,
|
||
onImport = onImport,
|
||
onClose = onClose
|
||
)
|
||
}
|
||
|
||
@Composable
|
||
private fun StoryboardPanelMl(
|
||
tourWaypoints: List<Waypoint>,
|
||
currentTour: String,
|
||
onSaveAsTour: (targetTour: String, orderedIds: List<String>) -> Unit,
|
||
onClose: () -> Unit
|
||
) {
|
||
StoryboardPanel(
|
||
tourWaypoints = tourWaypoints,
|
||
currentTour = currentTour,
|
||
onSaveAsTour = onSaveAsTour,
|
||
onClose = onClose
|
||
)
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// v2.5.38 — POI-Layer-Sichtbarkeit
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Schaltet Symbol-Layer des geladenen MapLibre-Styles nach POI-Kategorie
|
||
* sichtbar/unsichtbar.
|
||
*
|
||
* Strategie: Heuristische Layer-ID-Präfixe auf Basis des OpenMapTiles-Schemas,
|
||
* das OpenFreeMap Positron, Dark und Liberty verwenden. Wenn ein Layer-ID nicht
|
||
* existiert, passiert nichts (kein Crash).
|
||
*
|
||
* Einschränkungen (dokumentiert):
|
||
* - Layer-IDs sind style-abhängig und können sich bei OpenFreeMap-Updates ändern.
|
||
* - Die Heuristik deckt die häufigsten Symbol-Layer ab, nicht jeden Einzelfall.
|
||
* - Im CLASSIC-Raster-Modus nicht anwendbar (kein Vektor-Layer).
|
||
*
|
||
* OpenMapTiles-Schema Layer-ID-Muster (häufig):
|
||
* - Sehenswürdigkeiten: "poi-*", "tourism-*", "historic-*", "attraction-*"
|
||
* - Infrastruktur: "amenity-*", "health-*", "emergency-*", "post-*"
|
||
* - Gastronomie: "food-*", "catering-*", "restaurant-*"
|
||
* - Mobilität: "transit-*", "transport-*", "railway-*", "bus-*", "parking-*"
|
||
*/
|
||
private fun applyPoiLayerVisibility(
|
||
style: org.maplibre.android.maps.Style,
|
||
poi: de.waypointaudio.data.PoiLayerSettings
|
||
) {
|
||
val allLayers = runCatching { style.layers }.getOrNull() ?: return
|
||
|
||
// Kategorien-Zuordnung: Layer-ID-Präfixe/Substring-Heuristik
|
||
val sightsPrefixes = listOf(
|
||
"poi", "tourism", "historic", "attraction", "landmark",
|
||
"sightseeing", "monument", "museum", "zoo", "aquarium",
|
||
"castle", "church", "chapel", "mosque", "temple", "shrine"
|
||
)
|
||
val infrastructurePrefixes = listOf(
|
||
"health", "hospital", "pharmacy", "clinic", "doctor",
|
||
"emergency", "police", "fire", "post", "bank", "atm",
|
||
"fuel", "amenity-fuel", "amenity-bank", "amenity-atm",
|
||
"amenity-hospital", "amenity-pharmacy", "amenity-post"
|
||
)
|
||
val gastronomyPrefixes = listOf(
|
||
"food", "catering", "restaurant", "cafe", "fast-food",
|
||
"fast_food", "bar", "pub", "biergarten", "ice-cream",
|
||
"ice_cream", "bakery", "amenity-restaurant", "amenity-cafe",
|
||
"amenity-bar", "amenity-pub", "amenity-fast"
|
||
)
|
||
val mobilityPrefixes = listOf(
|
||
"transit", "transport", "railway", "bus", "subway",
|
||
"tram", "ferry", "taxi", "bicycle", "parking",
|
||
"car-sharing", "car_sharing", "rental", "station",
|
||
"stop", "aeroway", "airport", "helipad"
|
||
)
|
||
|
||
for (layer in allLayers) {
|
||
// Nur Symbol-Layer (POI-Icons/Labels) verarbeiten.
|
||
if (layer !is org.maplibre.android.style.layers.SymbolLayer) continue
|
||
val id = layer.id.lowercase()
|
||
|
||
val isSights = sightsPrefixes.any { id.contains(it) }
|
||
val isInfra = infrastructurePrefixes.any { id.contains(it) }
|
||
val isGastro = gastronomyPrefixes.any { id.contains(it) }
|
||
val isMobility = mobilityPrefixes.any { id.contains(it) }
|
||
|
||
// Nur Layer anpassen die einer POI-Kategorie zugeordnet sind.
|
||
// Nicht-POI-Symbol-Layer (Labels, Straßennamen etc.) werden nicht angefasst.
|
||
if (!isSights && !isInfra && !isGastro && !isMobility) continue
|
||
|
||
val visible = when {
|
||
isSights -> poi.showSights
|
||
isInfra -> poi.showInfrastructure
|
||
isGastro -> poi.showGastronomy
|
||
isMobility -> poi.showMobility
|
||
else -> true
|
||
}
|
||
runCatching {
|
||
layer.setProperties(
|
||
org.maplibre.android.style.layers.PropertyFactory.visibility(
|
||
if (visible) org.maplibre.android.style.layers.Property.VISIBLE
|
||
else org.maplibre.android.style.layers.Property.NONE
|
||
)
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// v2.5.38 — Kompaktes Attribution-Badge (Pflichtangabe, schöner als v2.5.37)
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Kompaktes, anklickbares Attribution-Badge unten links auf der Karte.
|
||
*
|
||
* Zeigt "© OpenStreetMap · ODbL" — klickt auf openstreetmap.org/copyright.
|
||
* Pflichtangabe darf nicht von Buttons überdeckt werden.
|
||
* Design: semi-transparent, harmoniert mit dem Karten-Design.
|
||
*/
|
||
@Composable
|
||
fun MapCompactAttributionBadge(modifier: Modifier = Modifier) {
|
||
val uriHandler = androidx.compose.ui.platform.LocalUriHandler.current
|
||
androidx.compose.material3.Surface(
|
||
shape = androidx.compose.foundation.shape.RoundedCornerShape(6.dp),
|
||
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.80f),
|
||
modifier = modifier
|
||
.clickable {
|
||
runCatching {
|
||
uriHandler.openUri("https://www.openstreetmap.org/copyright")
|
||
}
|
||
}
|
||
) {
|
||
androidx.compose.foundation.layout.Row(
|
||
verticalAlignment = Alignment.CenterVertically,
|
||
modifier = Modifier.padding(horizontal = 6.dp, vertical = 3.dp)
|
||
) {
|
||
Text(
|
||
text = "© OpenStreetMap · ODbL",
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.85f),
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// v2.5.42 — Explorer-POI-Icon-Builder: klar unterscheidbare Kategorie-Marker
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Erstellt ein klar unterscheidbares Bitmap-Icon für jeden POI-Typ.
|
||
*
|
||
* v2.5.42 — Fix für "alle blaue Punkte":
|
||
* 1. Jede Kategorie hat EIGENE Farbe + EIGENE Form/Symbol-Kombo.
|
||
* 2. Bitmaps haben kategorie-spezifische Sentinel-Pixel an definierter
|
||
* Position, damit MapLibre IconFactory keinen Icon-Cache-Hit erzeugt
|
||
* (gleiche Bitmap-Größe → gleicher Hash-Bucket ohne Sentinel).
|
||
* 3. Kein Default-Blau: fillColor kommt ausschließlich aus dem
|
||
* Kategorie-Mapping, kein Fallback auf die System-Primärfarbe.
|
||
*
|
||
* Kategorie-Schema:
|
||
* SIGHTS — Türkis (#00BCD4) + Rauten-Shape + Stern-Symbol
|
||
* GASTRONOMY — Orange (#FF7043) + Kreis + Tassen-Symbol (C)
|
||
* MOBILITY — Indigo (#3F51B5) + Abgerundetes Quadrat + Bus-Symbol (B)
|
||
* INFRASTRUCTURE — Koralle (#E53935) + Kreis + Plus-Symbol (+)
|
||
*/
|
||
/**
|
||
* v2.5.45 — Subtype-Overload: rückwärtskompatibel (Default: GENERIC je Kategorie)
|
||
*/
|
||
private fun buildExplorerPoiIcon(
|
||
category: de.waypointaudio.data.PoiCategory,
|
||
subtype: de.waypointaudio.util.PoiSubtype = when (category) {
|
||
de.waypointaudio.data.PoiCategory.SIGHTS -> de.waypointaudio.util.PoiSubtype.GENERIC_SIGHTS
|
||
de.waypointaudio.data.PoiCategory.GASTRONOMY -> de.waypointaudio.util.PoiSubtype.GENERIC_GASTRONOMY
|
||
de.waypointaudio.data.PoiCategory.MOBILITY -> de.waypointaudio.util.PoiSubtype.GENERIC_MOBILITY
|
||
de.waypointaudio.data.PoiCategory.INFRASTRUCTURE-> de.waypointaudio.util.PoiSubtype.GENERIC_INFRASTRUCTURE
|
||
}
|
||
): Bitmap {
|
||
// v2.5.43 — Echte Canvas-Piktogramme statt Buchstaben/Zeichen
|
||
// v2.5.45 — Subtype-Piktogramme für Sights/Gastro/Mobil/Infra
|
||
// v2.5.46 — Größe von 56 auf 68 px erhöht (bessere Lesbarkeit auf Smartphone-Screens)
|
||
val sizePx = 68
|
||
|
||
// Kategorie-Farben — dezent, App-Teal-Stil passend
|
||
val fillColor = when (category) {
|
||
de.waypointaudio.data.PoiCategory.SIGHTS -> 0xFF00897B.toInt() // Teal-Grün (Sehenswürdigkeit)
|
||
de.waypointaudio.data.PoiCategory.GASTRONOMY -> 0xFFBF6600.toInt() // Amber-Braun (Gastronomie)
|
||
de.waypointaudio.data.PoiCategory.MOBILITY -> 0xFF1565C0.toInt() // Dunkelblau (Mobilität)
|
||
de.waypointaudio.data.PoiCategory.INFRASTRUCTURE-> 0xFF558B2F.toInt() // Dunkelgrün (Infrastruktur/Info)
|
||
}
|
||
|
||
// v2.5.45 — Sentinel-Wert berücksichtigt Kategorie + Subtype-Ordinal,
|
||
// um MapLibre-Icon-Cache-Kollisionen zwischen verschiedenen Subtypen derselben Kategorie zu verhindern.
|
||
val categoryBase = when (category) {
|
||
de.waypointaudio.data.PoiCategory.SIGHTS -> 0
|
||
de.waypointaudio.data.PoiCategory.GASTRONOMY -> 32
|
||
de.waypointaudio.data.PoiCategory.MOBILITY -> 64
|
||
de.waypointaudio.data.PoiCategory.INFRASTRUCTURE-> 96
|
||
}
|
||
val sentinelAlpha = ((categoryBase + subtype.ordinal) % 200 + 55).coerceIn(1, 254)
|
||
|
||
val bmp = android.graphics.Bitmap.createBitmap(sizePx, sizePx, android.graphics.Bitmap.Config.ARGB_8888)
|
||
val canvas = android.graphics.Canvas(bmp)
|
||
val paint = android.graphics.Paint(android.graphics.Paint.ANTI_ALIAS_FLAG)
|
||
|
||
val cx = sizePx / 2f
|
||
val cy = sizePx / 2f
|
||
|
||
// ── Hintergrundform je Kategorie ─────────────────────────────────────────
|
||
when (category) {
|
||
de.waypointaudio.data.PoiCategory.SIGHTS -> {
|
||
// Fünfzackiger Stern als Marker-Hintergrund
|
||
val outerR = sizePx / 2f - 3f
|
||
val innerR = outerR * 0.48f
|
||
val path = android.graphics.Path()
|
||
for (i in 0 until 10) {
|
||
val angle = Math.toRadians((-90.0 + i * 36.0))
|
||
val r = if (i % 2 == 0) outerR else innerR
|
||
val x = cx + (r * Math.cos(angle)).toFloat()
|
||
val y = cy + (r * Math.sin(angle)).toFloat()
|
||
if (i == 0) path.moveTo(x, y) else path.lineTo(x, y)
|
||
}
|
||
path.close()
|
||
// Schatten
|
||
paint.color = 0x30000000.toInt()
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.save(); canvas.translate(1.5f, 1.5f); canvas.drawPath(path, paint); canvas.restore()
|
||
// Füllung
|
||
paint.color = fillColor
|
||
canvas.drawPath(path, paint)
|
||
// Weißer Rand
|
||
paint.color = 0xFFFFFFFF.toInt()
|
||
paint.style = android.graphics.Paint.Style.STROKE
|
||
paint.strokeWidth = 2.5f
|
||
canvas.drawPath(path, paint)
|
||
}
|
||
de.waypointaudio.data.PoiCategory.GASTRONOMY -> {
|
||
// Kreis als Badge-Hintergrund
|
||
val r = sizePx / 2f - 4f
|
||
paint.color = 0x30000000.toInt()
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawCircle(cx + 1.5f, cy + 1.5f, r, paint)
|
||
paint.color = fillColor
|
||
canvas.drawCircle(cx, cy, r, paint)
|
||
paint.color = 0xFFFFFFFF.toInt()
|
||
paint.style = android.graphics.Paint.Style.STROKE
|
||
paint.strokeWidth = 2.5f
|
||
canvas.drawCircle(cx, cy, r, paint)
|
||
}
|
||
de.waypointaudio.data.PoiCategory.MOBILITY -> {
|
||
// Abgerundetes Rechteck
|
||
val margin = 5f
|
||
val rect = android.graphics.RectF(margin, margin + 2f, sizePx - margin, sizePx - margin - 2f)
|
||
val corner = 10f
|
||
paint.color = 0x30000000.toInt()
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
val sRect = android.graphics.RectF(margin + 1.5f, margin + 3.5f, sizePx - margin + 1.5f, sizePx - margin - 0.5f)
|
||
canvas.drawRoundRect(sRect, corner, corner, paint)
|
||
paint.color = fillColor
|
||
canvas.drawRoundRect(rect, corner, corner, paint)
|
||
paint.color = 0xFFFFFFFF.toInt()
|
||
paint.style = android.graphics.Paint.Style.STROKE
|
||
paint.strokeWidth = 2.5f
|
||
canvas.drawRoundRect(rect, corner, corner, paint)
|
||
}
|
||
de.waypointaudio.data.PoiCategory.INFRASTRUCTURE -> {
|
||
// Kreis mit dickem Rand
|
||
val r = sizePx / 2f - 4f
|
||
paint.color = 0x30000000.toInt()
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawCircle(cx + 1.5f, cy + 1.5f, r, paint)
|
||
paint.color = fillColor
|
||
canvas.drawCircle(cx, cy, r, paint)
|
||
paint.color = 0xFFFFFFFF.toInt()
|
||
paint.style = android.graphics.Paint.Style.STROKE
|
||
paint.strokeWidth = 3.5f
|
||
canvas.drawCircle(cx, cy, r, paint)
|
||
}
|
||
}
|
||
|
||
|
||
// ── Weißes Piktogramm per Canvas (v2.5.45: Subtype-Varianten) ──────────────────
|
||
// v2.5.46: Strichstärke auf 2.8 erhöht (Icon-Größe 68 px statt 56 px)
|
||
paint.color = 0xFFFFFFFF.toInt()
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
paint.strokeWidth = 2.8f
|
||
|
||
when (subtype) {
|
||
// ─── SIGHTS Subtypes ────────────────────────────────────────────────────────
|
||
de.waypointaudio.util.PoiSubtype.CASTLE -> {
|
||
// Turm/Burg: Zinnenkranz + Tor
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
val tw = 8f; val th = 14f
|
||
val tl = cx - tw/2f; val tt = cy - th/2f - 1f
|
||
canvas.drawRect(tl, tt + 4f, tl + tw, tt + th, paint)
|
||
for (zi in 0..2) {
|
||
val zx = tl + zi * (tw/2f) - 0.5f
|
||
canvas.drawRect(zx, tt, zx + 2.5f, tt + 4f, paint)
|
||
}
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 1.8f
|
||
val tgW = 4f
|
||
canvas.drawArc(android.graphics.RectF(cx - tgW, tt + th - tgW*1.5f - 2f, cx + tgW, tt + th - 2f), 180f, -180f, false, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.CHURCH -> {
|
||
// Kreuz
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawRect(cx - 2f, cy - 12f, cx + 2f, cy + 10f, paint)
|
||
canvas.drawRect(cx - 7f, cy - 6f, cx + 7f, cy - 2f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.MONASTERY -> {
|
||
// Kleines Kreuz + Bogen
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawRect(cx - 1.8f, cy - 10f, cx + 1.8f, cy + 8f, paint)
|
||
canvas.drawRect(cx - 6f, cy - 5f, cx + 6f, cy - 2f, paint)
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 1.8f
|
||
canvas.drawArc(android.graphics.RectF(cx - 7f, cy - 1f, cx + 7f, cy + 10f), 0f, 180f, false, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.MUSEUM -> {
|
||
// Giebelhaus
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.0f
|
||
val roofP = android.graphics.Path().apply {
|
||
moveTo(cx, cy - 12f); lineTo(cx - 10f, cy - 4f); lineTo(cx + 10f, cy - 4f); close()
|
||
}
|
||
canvas.drawPath(roofP, paint)
|
||
canvas.drawLine(cx - 10f, cy + 8f, cx + 10f, cy + 8f, paint)
|
||
paint.strokeWidth = 1.8f
|
||
for (si in 0..2) { val sx = cx - 7f + si * 7f; canvas.drawLine(sx, cy - 4f, sx, cy + 8f, paint) }
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.VIEWPOINT -> {
|
||
// Fernglas
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.2f
|
||
canvas.drawCircle(cx - 5f, cy + 2f, 5f, paint)
|
||
canvas.drawCircle(cx + 5f, cy + 2f, 5f, paint)
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawRect(cx - 2f, cy - 8f, cx + 2f, cy - 3f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.MONUMENT, de.waypointaudio.util.PoiSubtype.HISTORIC_OTHER -> {
|
||
// Säule
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawRect(cx - 2.5f, cy - 9f, cx + 2.5f, cy + 7f, paint)
|
||
canvas.drawRect(cx - 5f, cy - 11f, cx + 5f, cy - 8f, paint)
|
||
canvas.drawRect(cx - 6f, cy + 6f, cx + 6f, cy + 9f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.RUIN -> {
|
||
// Gebrochene Mauer
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
val rb = cy + 8f
|
||
canvas.drawRect(cx - 10f, cy - 2f, cx - 4f, rb, paint)
|
||
canvas.drawRect(cx - 10f, cy - 8f, cx - 7f, cy - 2f, paint)
|
||
canvas.drawRect(cx + 2f, cy, cx + 10f, rb, paint)
|
||
canvas.drawRect(cx + 5f, cy - 5f, cx + 9f, cy, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.GALLERY -> {
|
||
// Bilderrahmen
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.2f
|
||
canvas.drawRoundRect(android.graphics.RectF(cx - 9f, cy - 9f, cx + 9f, cy + 9f), 2f, 2f, paint)
|
||
paint.strokeWidth = 1.5f
|
||
canvas.drawRect(cx - 5f, cy - 5f, cx + 5f, cy + 5f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.THEATRE -> {
|
||
// Zwei Drama-Bogen
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.0f
|
||
canvas.drawArc(android.graphics.RectF(cx - 10f, cy - 8f, cx - 1f, cy + 4f), 0f, 270f, false, paint)
|
||
canvas.drawArc(android.graphics.RectF(cx + 1f, cy - 8f, cx + 10f, cy + 4f), 270f, 270f, false, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.ZOO -> {
|
||
// Pfoten-Symbol
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawCircle(cx, cy + 4f, 6f, paint)
|
||
canvas.drawCircle(cx - 6f, cy - 3f, 3f, paint)
|
||
canvas.drawCircle(cx, cy - 7f, 3f, paint)
|
||
canvas.drawCircle(cx + 6f, cy - 3f, 3f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.GENERIC_SIGHTS, de.waypointaudio.util.PoiSubtype.ATTRACTION -> {
|
||
// Monument-Nadel (wie v2.5.44)
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
val stTop = cy - 10f; val stBot = cy + 4f
|
||
canvas.drawRect(cx - 1.75f, stTop, cx + 1.75f, stBot, paint)
|
||
val roofPath = android.graphics.Path().apply {
|
||
moveTo(cx, stTop - 5f); lineTo(cx - 5f, stTop); lineTo(cx + 5f, stTop); close()
|
||
}
|
||
canvas.drawPath(roofPath, paint)
|
||
canvas.drawRect(cx - 6f, stBot, cx + 6f, stBot + 2.5f, paint)
|
||
}
|
||
// ─── GASTRONOMY Subtypes ────────────────────────────────────────────────────
|
||
de.waypointaudio.util.PoiSubtype.RESTAURANT -> {
|
||
// Messer + Gabel
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.0f
|
||
canvas.drawLine(cx - 5f, cy + 9f, cx - 5f, cy - 10f, paint)
|
||
paint.strokeWidth = 1.5f
|
||
canvas.drawLine(cx - 7f, cy - 10f, cx - 7f, cy - 4f, paint)
|
||
canvas.drawLine(cx - 3f, cy - 10f, cx - 3f, cy - 4f, paint)
|
||
paint.strokeWidth = 2.0f
|
||
canvas.drawLine(cx + 5f, cy + 9f, cx + 5f, cy - 4f, paint)
|
||
val knifePath = android.graphics.Path().apply {
|
||
moveTo(cx + 5f, cy - 4f); lineTo(cx + 8f, cy - 10f); lineTo(cx + 5f, cy - 10f); close()
|
||
}
|
||
paint.style = android.graphics.Paint.Style.FILL; canvas.drawPath(knifePath, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.CAFE -> {
|
||
// Tasse mit Dampf
|
||
val cupLeft = cx - 9f; val cupRight = cx + 9f; val cupTop = cy - 3f; val cupBot = cy + 9f
|
||
val cupPath = android.graphics.Path().apply {
|
||
moveTo(cupLeft + 2f, cupTop); lineTo(cupLeft, cupBot); lineTo(cupRight, cupBot); lineTo(cupRight - 2f, cupTop); close()
|
||
}
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.3f
|
||
canvas.drawPath(cupPath, paint)
|
||
paint.strokeWidth = 2f; canvas.drawLine(cupLeft - 2f, cupBot + 2f, cupRight + 2f, cupBot + 2f, paint)
|
||
canvas.drawArc(android.graphics.RectF(cupRight - 1f, cupTop + 4f, cupRight + 6f, cupBot - 2f), -90f, 180f, false, paint)
|
||
paint.strokeWidth = 1.8f
|
||
val steamPath = android.graphics.Path().apply {
|
||
moveTo(cx - 3f, cupTop - 3f); quadTo(cx - 1f, cupTop - 7f, cx + 1f, cupTop - 3f)
|
||
}; canvas.drawPath(steamPath, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.BAR -> {
|
||
// Bierglas
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.0f
|
||
val glassPath = android.graphics.Path().apply {
|
||
moveTo(cx - 7f, cy - 9f); lineTo(cx - 9f, cy + 9f); lineTo(cx + 9f, cy + 9f); lineTo(cx + 7f, cy - 9f); close()
|
||
}
|
||
canvas.drawPath(glassPath, paint)
|
||
canvas.drawArc(android.graphics.RectF(cx + 7f, cy - 5f, cx + 13f, cy + 5f), -90f, 180f, false, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.FAST_FOOD -> {
|
||
// Burger-Silhouette
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawArc(android.graphics.RectF(cx - 9f, cy - 10f, cx + 9f, cy + 2f), 180f, 180f, true, paint)
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.8f
|
||
canvas.drawLine(cx - 9f, cy + 2f, cx + 9f, cy + 2f, paint)
|
||
canvas.drawLine(cx - 9f, cy + 6f, cx + 9f, cy + 6f, paint)
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawArc(android.graphics.RectF(cx - 9f, cy + 4f, cx + 9f, cy + 12f), 0f, 180f, true, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.GENERIC_GASTRONOMY -> {
|
||
// Tasse (Fallback, wie v2.5.44)
|
||
val cupLeft = cx - 9f; val cupRight = cx + 9f; val cupTop = cy - 3f; val cupBot = cy + 9f
|
||
val cupPath = android.graphics.Path().apply {
|
||
moveTo(cupLeft + 2f, cupTop); lineTo(cupLeft, cupBot); lineTo(cupRight, cupBot); lineTo(cupRight - 2f, cupTop); close()
|
||
}
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.3f
|
||
canvas.drawPath(cupPath, paint)
|
||
paint.strokeWidth = 2f; canvas.drawLine(cupLeft - 2f, cupBot + 2f, cupRight + 2f, cupBot + 2f, paint)
|
||
canvas.drawArc(android.graphics.RectF(cupRight - 1f, cupTop + 4f, cupRight + 6f, cupBot - 2f), -90f, 180f, false, paint)
|
||
}
|
||
// ─── MOBILITY Subtypes ──────────────────────────────────────────────────────
|
||
de.waypointaudio.util.PoiSubtype.PARKING -> {
|
||
// "P"-Piktogramm
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 3f
|
||
canvas.drawLine(cx - 5f, cy - 10f, cx - 5f, cy + 10f, paint)
|
||
canvas.drawArc(android.graphics.RectF(cx - 5f, cy - 10f, cx + 8f, cy + 0f), -90f, 180f, false, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.BUS_STOP -> {
|
||
// Bus-Silhouette (wie v2.5.44)
|
||
val busLeft = cx - 10f; val busRight = cx + 10f; val busTop = cy - 8f; val busBot = cy + 6f
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.2f
|
||
canvas.drawRoundRect(android.graphics.RectF(busLeft, busTop, busRight, busBot), 3f, 3f, paint)
|
||
canvas.drawLine(busLeft + 2f, busTop + 2f, busLeft + 2f, busTop + 7f, paint)
|
||
paint.strokeWidth = 1.5f
|
||
canvas.drawRoundRect(android.graphics.RectF(busLeft + 4f, busTop + 2f, busLeft + 9f, busTop + 6f), 1f, 1f, paint)
|
||
canvas.drawRoundRect(android.graphics.RectF(busLeft + 11f, busTop + 2f, busLeft + 16f, busTop + 6f), 1f, 1f, paint)
|
||
paint.strokeWidth = 2f
|
||
canvas.drawCircle(busLeft + 5f, busBot + 1f, 3f, paint)
|
||
canvas.drawCircle(busRight - 5f, busBot + 1f, 3f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.TRAIN_STATION -> {
|
||
// Zug (vereinfacht)
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.0f
|
||
canvas.drawRoundRect(android.graphics.RectF(cx - 12f, cy - 7f, cx + 12f, cy + 5f), 3f, 3f, paint)
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawRect(cx - 6f, cy - 11f, cx - 3f, cy - 7f, paint)
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 1.8f
|
||
canvas.drawCircle(cx - 7f, cy + 7f, 3f, paint)
|
||
canvas.drawCircle(cx + 2f, cy + 7f, 3f, paint)
|
||
canvas.drawCircle(cx + 9f, cy + 7f, 3f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.TRAM_STOP -> {
|
||
// Straßenbahn
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.0f
|
||
canvas.drawRoundRect(android.graphics.RectF(cx - 10f, cy - 7f, cx + 10f, cy + 5f), 3f, 3f, paint)
|
||
canvas.drawLine(cx - 10f, cy - 9f, cx + 10f, cy - 9f, paint)
|
||
paint.strokeWidth = 1.5f; canvas.drawLine(cx, cy - 9f, cx, cy - 7f, paint)
|
||
canvas.drawCircle(cx - 5f, cy + 7f, 2.5f, paint)
|
||
canvas.drawCircle(cx + 5f, cy + 7f, 2.5f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.FUEL -> {
|
||
// Zapfsäule
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.0f
|
||
canvas.drawRect(cx - 6f, cy - 5f, cx + 6f, cy + 9f, paint)
|
||
canvas.drawLine(cx - 6f, cy - 5f, cx - 10f, cy - 9f, paint)
|
||
canvas.drawLine(cx - 10f, cy - 9f, cx - 10f, cy - 3f, paint)
|
||
paint.strokeWidth = 1.5f; canvas.drawRect(cx - 4f, cy - 3f, cx + 4f, cy + 3f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.GENERIC_MOBILITY -> {
|
||
// Bus (Fallback, wie v2.5.44)
|
||
val busLeft = cx - 10f; val busRight = cx + 10f; val busTop = cy - 8f; val busBot = cy + 6f
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 2.2f
|
||
canvas.drawRoundRect(android.graphics.RectF(busLeft, busTop, busRight, busBot), 3f, 3f, paint)
|
||
canvas.drawLine(busLeft + 2f, busTop + 2f, busLeft + 2f, busTop + 7f, paint)
|
||
paint.strokeWidth = 1.5f
|
||
canvas.drawRoundRect(android.graphics.RectF(busLeft + 4f, busTop + 2f, busLeft + 9f, busTop + 6f), 1f, 1f, paint)
|
||
canvas.drawRoundRect(android.graphics.RectF(busLeft + 11f, busTop + 2f, busLeft + 16f, busTop + 6f), 1f, 1f, paint)
|
||
paint.strokeWidth = 2f
|
||
canvas.drawCircle(busLeft + 5f, busBot + 1f, 3f, paint)
|
||
canvas.drawCircle(busRight - 5f, busBot + 1f, 3f, paint)
|
||
}
|
||
// ─── INFRASTRUCTURE Subtypes ────────────────────────────────────────────────
|
||
de.waypointaudio.util.PoiSubtype.PHARMACY -> {
|
||
// Apotheken-Kreuz
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawRect(cx - 3f, cy - 11f, cx + 3f, cy + 11f, paint)
|
||
canvas.drawRect(cx - 11f, cy - 3f, cx + 11f, cy + 3f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.HOSPITAL -> {
|
||
// H-Symbol
|
||
paint.style = android.graphics.Paint.Style.STROKE; paint.strokeWidth = 3f
|
||
canvas.drawLine(cx - 7f, cy - 10f, cx - 7f, cy + 10f, paint)
|
||
canvas.drawLine(cx + 7f, cy - 10f, cx + 7f, cy + 10f, paint)
|
||
canvas.drawLine(cx - 7f, cy, cx + 7f, cy, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.TOILETS -> {
|
||
// WC-Piktogramm (Person-Silhouette)
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawCircle(cx - 6f, cy - 9f, 3f, paint)
|
||
val dressPath = android.graphics.Path().apply {
|
||
moveTo(cx - 10f, cy + 8f); lineTo(cx - 6f, cy - 6f); lineTo(cx - 2f, cy + 8f); close()
|
||
}; canvas.drawPath(dressPath, paint)
|
||
canvas.drawCircle(cx + 6f, cy - 9f, 3f, paint)
|
||
canvas.drawRect(cx + 4f, cy - 6f, cx + 8f, cy + 8f, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.DRINKING_WATER -> {
|
||
// Wassertropfen
|
||
val dropPath = android.graphics.Path().apply {
|
||
moveTo(cx, cy + 10f)
|
||
cubicTo(cx - 10f, cy + 2f, cx - 10f, cy - 6f, cx, cy - 12f)
|
||
cubicTo(cx + 10f, cy - 6f, cx + 10f, cy + 2f, cx, cy + 10f)
|
||
}
|
||
paint.style = android.graphics.Paint.Style.FILL; canvas.drawPath(dropPath, paint)
|
||
}
|
||
de.waypointaudio.util.PoiSubtype.GENERIC_INFRASTRUCTURE -> {
|
||
// Info-i (wie v2.5.44)
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
canvas.drawCircle(cx, cy - 8f, 3.5f, paint)
|
||
val stW2 = 4.5f
|
||
canvas.drawRoundRect(android.graphics.RectF(cx - stW2/2f, cy - 2f, cx + stW2/2f, cy + 9f), 2f, 2f, paint)
|
||
canvas.drawRoundRect(android.graphics.RectF(cx - 7f, cy + 8f, cx + 7f, cy + 10f), 2f, 2f, paint)
|
||
}
|
||
}
|
||
|
||
// Sentinel-Pixel: kategorie-spezifischer Alpha-Wert verhindert MapLibre-Cache-Kollision
|
||
bmp.setPixel(0, 0, (sentinelAlpha shl 24) or 0x000000)
|
||
|
||
return bmp
|
||
}
|
||
|
||
private fun buildExplorerPoiIconWithLabel(
|
||
category: de.waypointaudio.data.PoiCategory,
|
||
subtype: de.waypointaudio.util.PoiSubtype = de.waypointaudio.util.PoiSubtype.GENERIC_SIGHTS,
|
||
name: String
|
||
): Bitmap {
|
||
val iconSize = 68 // v2.5.46: gleiche Größe wie buildExplorerPoiIcon (erhöht auf 68 px)
|
||
val labelMaxChars = 14
|
||
val displayName = if (name.length > labelMaxChars) name.take(labelMaxChars - 1) + "…" else name
|
||
|
||
val labelPaint = android.graphics.Paint(android.graphics.Paint.ANTI_ALIAS_FLAG).apply {
|
||
textSize = 20f
|
||
textAlign = android.graphics.Paint.Align.CENTER
|
||
typeface = android.graphics.Typeface.create(android.graphics.Typeface.DEFAULT, android.graphics.Typeface.BOLD)
|
||
isFakeBoldText = true
|
||
}
|
||
val textWidth = labelPaint.measureText(displayName).toInt()
|
||
val pillW = (textWidth + 14).coerceAtLeast(iconSize)
|
||
val pillH = 26
|
||
val pillMargin = 2
|
||
val totalH = iconSize + pillMargin + pillH
|
||
val totalW = maxOf(iconSize, pillW) + 4
|
||
|
||
val bmp = android.graphics.Bitmap.createBitmap(totalW, totalH, android.graphics.Bitmap.Config.ARGB_8888)
|
||
val canvas = android.graphics.Canvas(bmp)
|
||
val paint = android.graphics.Paint(android.graphics.Paint.ANTI_ALIAS_FLAG)
|
||
|
||
// Zeichne Kategorie-Icon zentriert oben
|
||
val iconBmp = buildExplorerPoiIcon(category, subtype)
|
||
val iconLeft = (totalW - iconSize) / 2f
|
||
canvas.drawBitmap(iconBmp, iconLeft, 0f, null)
|
||
iconBmp.recycle()
|
||
|
||
// Label-Pill darunter — gleiche Farbe wie Kategorie, leicht transparent
|
||
val pillColor = when (category) {
|
||
de.waypointaudio.data.PoiCategory.SIGHTS -> 0xCC00897B.toInt() // Teal-Grün passend zu Piktogramm
|
||
de.waypointaudio.data.PoiCategory.GASTRONOMY -> 0xCCBF6600.toInt() // Amber-Braun passend zu Piktogramm
|
||
de.waypointaudio.data.PoiCategory.MOBILITY -> 0xCC1565C0.toInt() // Dunkelblau passend zu Piktogramm
|
||
de.waypointaudio.data.PoiCategory.INFRASTRUCTURE-> 0xCC558B2F.toInt() // Dunkelgrün passend zu Piktogramm
|
||
}
|
||
val pillTop = iconSize + pillMargin.toFloat()
|
||
val pillLeft = (totalW - pillW) / 2f
|
||
val pillRight = pillLeft + pillW
|
||
val pillBottom = pillTop + pillH
|
||
|
||
paint.color = pillColor
|
||
paint.style = android.graphics.Paint.Style.FILL
|
||
val pillRect = android.graphics.RectF(pillLeft, pillTop, pillRight, pillBottom)
|
||
canvas.drawRoundRect(pillRect, 7f, 7f, paint)
|
||
|
||
// Label-Text
|
||
labelPaint.color = 0xFFFFFFFF.toInt()
|
||
val textBounds = android.graphics.Rect()
|
||
labelPaint.getTextBounds(displayName, 0, displayName.length, textBounds)
|
||
val textX = totalW / 2f
|
||
val textY = pillTop + pillH / 2f + textBounds.height() / 2f - textBounds.bottom
|
||
canvas.drawText(displayName, textX, textY, labelPaint)
|
||
|
||
return bmp
|
||
}
|
||
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
// v2.5.41 — POI-Legende (einklappbar, kompakt, über Attribution)
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Kompakte, einklappbare POI-Kategorie-Legende.
|
||
* Zeigt farbige Kreise mit Kategorie-Symbol und Kurzlabel.
|
||
* Toggle-Klick klappt die Legende auf/zu.
|
||
* Positionierung: bottom-start, über der Attribution (nicht überlagern).
|
||
*/
|
||
@Composable
|
||
private fun ExplorerPoiLegend(
|
||
poiLayers: de.waypointaudio.data.PoiLayerSettings,
|
||
expanded: Boolean,
|
||
onToggle: () -> Unit,
|
||
modifier: androidx.compose.ui.Modifier = androidx.compose.ui.Modifier
|
||
) {
|
||
// v2.5.43 — Legende mit PoiCategory-Referenz für Canvas-Piktogramme
|
||
data class LegendEntry(val category: de.waypointaudio.data.PoiCategory, val color: Long, val label: String, val visible: Boolean)
|
||
|
||
val entries = listOf(
|
||
LegendEntry(de.waypointaudio.data.PoiCategory.SIGHTS, 0xFF00897B, "Sehensw.", poiLayers.showSights),
|
||
LegendEntry(de.waypointaudio.data.PoiCategory.GASTRONOMY, 0xFFBF6600, "Gastro", poiLayers.showGastronomy),
|
||
LegendEntry(de.waypointaudio.data.PoiCategory.MOBILITY, 0xFF1565C0, "Mobilit.", poiLayers.showMobility),
|
||
LegendEntry(de.waypointaudio.data.PoiCategory.INFRASTRUCTURE, 0xFF558B2F, "Infra", poiLayers.showInfrastructure),
|
||
).filter { it.visible }
|
||
|
||
if (entries.isEmpty()) return
|
||
|
||
androidx.compose.material3.Surface(
|
||
shape = androidx.compose.foundation.shape.RoundedCornerShape(10.dp),
|
||
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.90f),
|
||
shadowElevation = 2.dp,
|
||
modifier = modifier.clickable { onToggle() }
|
||
) {
|
||
if (!expanded) {
|
||
// Kompakt: nur Farbpunkte nebeneinander
|
||
Row(
|
||
modifier = Modifier.padding(horizontal = 6.dp, vertical = 4.dp),
|
||
horizontalArrangement = Arrangement.spacedBy(4.dp),
|
||
verticalAlignment = Alignment.CenterVertically
|
||
) {
|
||
Text(
|
||
"POI",
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
|
||
)
|
||
entries.forEach { entry ->
|
||
androidx.compose.foundation.Canvas(modifier = Modifier.size(10.dp)) {
|
||
drawCircle(androidx.compose.ui.graphics.Color(entry.color))
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
// Ausgeklappt: Einträge mit Symbol + Label
|
||
Column(
|
||
modifier = Modifier.padding(horizontal = 8.dp, vertical = 6.dp),
|
||
verticalArrangement = Arrangement.spacedBy(3.dp)
|
||
) {
|
||
entries.forEach { entry ->
|
||
Row(
|
||
verticalAlignment = Alignment.CenterVertically,
|
||
horizontalArrangement = Arrangement.spacedBy(5.dp)
|
||
) {
|
||
// v2.5.43 — Farbiger Kategorie-Kreis (konsistent mit Mini-Punkt in Kompakt-Ansicht)
|
||
androidx.compose.foundation.Canvas(modifier = Modifier.size(14.dp)) {
|
||
drawCircle(color = androidx.compose.ui.graphics.Color(entry.color))
|
||
}
|
||
Text(
|
||
entry.label,
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.85f)
|
||
)
|
||
}
|
||
}
|
||
Text(
|
||
"Symbole zeigen Untertypen",
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.55f),
|
||
modifier = Modifier.padding(top = 1.dp)
|
||
)
|
||
Text(
|
||
"antippen zum Einklappen",
|
||
style = MaterialTheme.typography.labelSmall,
|
||
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.35f),
|
||
modifier = Modifier.padding(top = 0.dp)
|
||
)
|
||
}
|
||
}
|
||
}
|
||
}
|