diff options
Diffstat (limited to 'android-app/app/src/main/kotlin/org')
15 files changed, 318 insertions, 58 deletions
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt b/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt index d9dba73..f9d4dbd 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt @@ -22,7 +22,10 @@ import com.google.android.material.bottomsheet.BottomSheetBehavior import com.google.android.material.floatingactionbutton.FloatingActionButton import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.flow.filterNotNull import kotlinx.coroutines.flow.firstOrNull import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -45,9 +48,11 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { private var instrumentHandler: InstrumentHandler? = null private var mapHandler: MapHandler? = null private var anchorWatchHandler: AnchorWatchHandler? = null - + private val loadedStyleFlow = MutableStateFlow<Style?>(null) + private lateinit var bottomSheetBehavior: BottomSheetBehavior<View> private lateinit var fragmentContainer: FrameLayout + private lateinit var fabRecordTrack: FloatingActionButton private val safetyFragment = SafetyFragment().apply { setSafetyListener(this@MainActivity) } private val viewModel: MainViewModel by viewModels() @@ -55,6 +60,7 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { override fun onResume() { super.onResume() + mapView?.onResume() if (pendingServiceStart) { pendingServiceStart = false startServices() @@ -80,6 +86,19 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { findViewById<FloatingActionButton>(R.id.fab_mob).setOnClickListener { onActivateMob() } + + fabRecordTrack = findViewById(R.id.fab_record_track) + fabRecordTrack.setOnClickListener { + if (viewModel.isRecording.value) viewModel.stopTrack() else viewModel.startTrack() + } + // Observe immediately — pure UI state, not gated on GPS permission + lifecycleScope.launch { + viewModel.isRecording.collect { recording -> + val icon = if (recording) R.drawable.ic_close else R.drawable.ic_track_record + fabRecordTrack.setImageResource(icon) + fabRecordTrack.contentDescription = if (recording) "Stop Recording" else "Record Track" + } + } } private fun setupBottomSheet() { @@ -131,17 +150,13 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { private fun hideOverlays() { fragmentContainer.visibility = View.GONE - // Clear backstack if needed } override fun onActivateMob() { lifecycleScope.launch { LocationService.locationFlow.firstOrNull()?.let { gpsData -> val mediaPlayer = MediaPlayer.create(this@MainActivity, R.raw.mob_alarm) - // In a real redesign, we'd show a specialized MOB fragment - // For now, keep existing handler logic but maybe toggle visibility mobHandler?.activateMob(gpsData.latitude, gpsData.longitude, mediaPlayer) - // Ensure MOB UI is visible - we might need to add it back to activity_main if removed } } } @@ -151,7 +166,6 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { } private fun setupHandlers() { - // ... (Keep existing handler initialization, just update view IDs as needed) instrumentHandler = InstrumentHandler( valueAws = findViewById(R.id.value_aws), valueTws = findViewById(R.id.value_tws), @@ -226,10 +240,11 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { }, 256)) .withLayer(RasterLayer("openseamap-layer", "openseamap-source")) - maplibreMap.setStyle(style) { loadedStyle -> + maplibreMap.setStyle(style) { style -> + loadedStyleFlow.value = style val anchorBitmap = rasterizeDrawable(R.drawable.ic_anchor) val arrowBitmap = rasterizeDrawable(R.drawable.ic_tidal_arrow) - mapHandler?.setupLayers(loadedStyle, anchorBitmap, arrowBitmap) + mapHandler?.setupLayers(style, anchorBitmap, arrowBitmap) } } } @@ -238,6 +253,8 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { lifecycleScope.launch { LocationService.locationFlow.collect { gpsData -> mapHandler?.centerOnLocation(gpsData.latitude, gpsData.longitude) + val sogKnots = gpsData.speedOverGround * 1.94384 + viewModel.addGpsPoint(gpsData.latitude, gpsData.longitude, sogKnots, gpsData.courseOverGround.toDouble()) } } lifecycleScope.launch { @@ -245,6 +262,11 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { safetyFragment.updateAnchorStatus(if (state.isActive) "Active: ${state.watchCircleRadiusMeters}m" else "Inactive") } } + lifecycleScope.launch { + loadedStyleFlow.filterNotNull() + .combine(viewModel.trackPoints) { style, points -> style to points } + .collect { (style, points) -> mapHandler?.updateTrackLayer(style, points) } + } } private fun startInstrumentSimulation(polarTable: PolarTable) { @@ -288,7 +310,6 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { } override fun onStart() { super.onStart(); mapView?.onStart() } - override fun onResume() { super.onResume(); mapView?.onResume() } override fun onPause() { super.onPause(); mapView?.onPause() } override fun onStop() { super.onStop(); mapView?.onStop() } override fun onDestroy() { super.onDestroy(); mapView?.onDestroy() } diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/BoatPolars.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/BoatPolars.kt new file mode 100644 index 0000000..0286ea8 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/BoatPolars.kt @@ -0,0 +1,69 @@ +package org.terst.nav.data.model + +import kotlin.math.pow +import kotlin.math.sqrt + +/** + * Boat polar speed table: maps (TWA, TWS) → BSP (boat speed through water, knots). + * + * Interpolation is bilinear — linear on TWA within a given TWS, then linear on TWS. + * Port-tack mirror: TWA > 180° is folded to 360° - TWA before lookup. + */ +data class BoatPolars( + /** Outer key: TWS in knots. Inner key: TWA in degrees [0, 180]. Value: BSP in knots. */ + val table: Map<Double, Map<Double, Double>> +) { + /** + * Returns boat speed (knots) for the given True Wind Angle and True Wind Speed. + * TWA outside [0, 360] is clamped; port/starboard symmetry is applied (>180° mirrored). + */ + fun bsp(twaDeg: Double, twsKt: Double): Double { + val twa = if (twaDeg > 180.0) 360.0 - twaDeg else twaDeg.coerceIn(0.0, 180.0) + + val twsKeys = table.keys.sorted() + if (twsKeys.isEmpty()) return 0.0 + + val twsClamped = twsKt.coerceIn(twsKeys.first(), twsKeys.last()) + val twsLow = twsKeys.lastOrNull { it <= twsClamped } ?: twsKeys.first() + val twsHigh = twsKeys.firstOrNull { it >= twsClamped } ?: twsKeys.last() + + val bspLow = bspAtTws(twa, table[twsLow] ?: return 0.0) + val bspHigh = bspAtTws(twa, table[twsHigh] ?: return 0.0) + + return if (twsHigh == twsLow) bspLow + else { + val t = (twsClamped - twsLow) / (twsHigh - twsLow) + bspLow + t * (bspHigh - bspLow) + } + } + + private fun bspAtTws(twaDeg: Double, twaMap: Map<Double, Double>): Double { + val twaKeys = twaMap.keys.sorted() + if (twaKeys.isEmpty()) return 0.0 + + val twaClamped = twaDeg.coerceIn(twaKeys.first(), twaKeys.last()) + val twaLow = twaKeys.lastOrNull { it <= twaClamped } ?: twaKeys.first() + val twaHigh = twaKeys.firstOrNull { it >= twaClamped } ?: twaKeys.last() + + val bspLow = twaMap[twaLow] ?: 0.0 + val bspHigh = twaMap[twaHigh] ?: 0.0 + + return if (twaHigh == twaLow) bspLow + else { + val t = (twaClamped - twaLow) / (twaHigh - twaLow) + bspLow + t * (bspHigh - bspLow) + } + } + + companion object { + /** Default polar for a typical 35-foot cruising sloop. */ + val DEFAULT: BoatPolars = BoatPolars( + mapOf( + 5.0 to mapOf(45.0 to 3.5, 60.0 to 4.2, 90.0 to 4.8, 120.0 to 5.0, 150.0 to 4.5, 180.0 to 4.0), + 10.0 to mapOf(45.0 to 5.5, 60.0 to 6.5, 90.0 to 7.0, 120.0 to 7.2, 150.0 to 6.8, 180.0 to 6.0), + 15.0 to mapOf(45.0 to 6.5, 60.0 to 7.5, 90.0 to 8.0, 120.0 to 8.5, 150.0 to 8.0, 180.0 to 7.0), + 20.0 to mapOf(45.0 to 7.0, 60.0 to 8.0, 90.0 to 8.5, 120.0 to 9.0, 150.0 to 8.5, 180.0 to 7.5) + ) + ) + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt index 9d284b5..715c1db 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt @@ -2,39 +2,8 @@ package org.terst.nav.data.model import java.time.Instant -/** - * Metadata record for a locally-stored GRIB2 file. - * - * @param region The geographic region this file covers. - * @param modelRunTime When the NWP model run that produced this file started (UTC). - * @param forecastHours Number of forecast hours included in this file. - * @param downloadedAt Wall-clock time when the file was saved locally. - * @param filePath Absolute path to the GRIB2 file on the device filesystem. - * @param sizeBytes File size in bytes. - */ -data class GribFile( - val region: GribRegion, - val modelRunTime: Instant, - val forecastHours: Int, - val downloadedAt: Instant, - val filePath: String, - val sizeBytes: Long -) { - /** - * The wall-clock time at which this GRIB file's forecast data expires. - * Per design doc §6.3: valid until model run + forecast hours. - */ +data class GribFile(val region: GribRegion, val modelRunTime: Instant, val forecastHours: Int, val downloadedAt: Instant, val filePath: String, val sizeBytes: Long) { fun validUntil(): Instant = modelRunTime.plusSeconds(forecastHours.toLong() * 3600) - - /** - * Returns true if the data has expired relative to [now]. - * Per design doc §6.3: stale after model run + forecast hour. - */ fun isStale(now: Instant = Instant.now()): Boolean = now.isAfter(validUntil()) - - /** - * Age of the download in seconds. - */ - fun ageSeconds(now: Instant = Instant.now()): Long = - now.epochSecond - downloadedAt.epochSecond + fun ageSeconds(now: Instant = Instant.now()): Long = now.epochSecond - downloadedAt.epochSecond } diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribParameter.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribParameter.kt new file mode 100644 index 0000000..a322ea9 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribParameter.kt @@ -0,0 +1,24 @@ +package org.terst.nav.data.model + +/** GRIB meteorological/oceanographic parameters that can be requested for download. */ +enum class GribParameter { + WIND_SPEED, + WIND_DIRECTION, + SURFACE_PRESSURE, + TEMPERATURE_2M, + PRECIPITATION, + WAVE_HEIGHT, + WAVE_DIRECTION; + + companion object { + /** + * Minimal parameter set for satellite (Iridium) links: wind speed, wind direction, + * and surface pressure only. Per §9.1: skip temperature/clouds to minimise bandwidth. + */ + val SATELLITE_MINIMAL: Set<GribParameter> = setOf( + WIND_SPEED, + WIND_DIRECTION, + SURFACE_PRESSURE + ) + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt index 5e32d6c..f960bc3 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt @@ -1,20 +1,6 @@ package org.terst.nav.data.model -/** - * Geographic bounding box used to identify a GRIB download region. - * @param name Human-readable region name (e.g. "North Atlantic", "English Channel") - */ -data class GribRegion( - val name: String, - val latMin: Double, - val latMax: Double, - val lonMin: Double, - val lonMax: Double -) { - /** True if [lat]/[lon] falls within this region's bounding box. */ - fun contains(lat: Double, lon: Double): Boolean = - lat in latMin..latMax && lon in lonMin..lonMax - - /** Area in square degrees (rough proxy for download size estimate). */ +data class GribRegion(val name: String, val latMin: Double, val latMax: Double, val lonMin: Double, val lonMax: Double) { + fun contains(lat: Double, lon: Double): Boolean = lat in latMin..latMax && lon in lonMin..lonMax fun areaDegrees(): Double = (latMax - latMin) * (lonMax - lonMin) } diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/LogbookEntry.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/LogbookEntry.kt new file mode 100644 index 0000000..f41e917 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/LogbookEntry.kt @@ -0,0 +1,19 @@ +package org.terst.nav.data.model + +/** + * A single entry in the electronic trip logbook. + * Matches the log format from Section 4.8 of COMPONENT_DESIGN.md. + */ +data class LogbookEntry( + val timestampMs: Long, + val lat: Double, + val lon: Double, + val sogKnots: Double, + val cogDegrees: Double, + val windKnots: Double? = null, + val windDirectionDeg: Double? = null, + val baroHpa: Double? = null, + val depthMeters: Double? = null, + val event: String? = null, + val notes: String? = null +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/SatelliteDownloadRequest.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/SatelliteDownloadRequest.kt new file mode 100644 index 0000000..d14c9da --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/SatelliteDownloadRequest.kt @@ -0,0 +1,27 @@ +package org.terst.nav.data.model + +/** + * A bandwidth-optimised GRIB download request for satellite (Iridium) links. + * + * Per §9.1: crop to needed region and request only essential parameters + * (wind, pressure) to fit within the ~2.4 Kbps Iridium budget. + * + * @param region Geographic area to download (cropped to route corridor + 200 nm buffer). + * @param parameters GRIB parameters to include. Use [GribParameter.SATELLITE_MINIMAL] + * for satellite links. + * @param forecastHours Number of forecast hours to request (e.g. 24, 48, 120). + * @param resolutionDeg Grid spacing in degrees. Coarser grids produce smaller files; + * 1.0° is typical for satellite; 0.25° for WiFi/cellular. + */ +data class SatelliteDownloadRequest( + val region: GribRegion, + val parameters: Set<GribParameter>, + val forecastHours: Int, + val resolutionDeg: Double = 1.0 +) { + init { + require(forecastHours > 0) { "forecastHours must be positive" } + require(resolutionDeg > 0.0) { "resolutionDeg must be positive" } + require(parameters.isNotEmpty()) { "parameters must not be empty" } + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideConstituent.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideConstituent.kt new file mode 100644 index 0000000..deb73d6 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideConstituent.kt @@ -0,0 +1,9 @@ +package com.example.androidapp.data.model + +/** A single harmonic tidal constituent used in harmonic tide prediction. */ +data class TideConstituent( + val name: String, // e.g. "M2", "S2", "K1" + val speedDegPerHour: Double, // angular speed in degrees per hour + val amplitudeMeters: Double, // amplitude in metres + val phaseDeg: Double // phase lag (kappa) in degrees +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/TidePrediction.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TidePrediction.kt new file mode 100644 index 0000000..51eea44 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TidePrediction.kt @@ -0,0 +1,7 @@ +package com.example.androidapp.data.model + +/** A predicted tide height at a specific point in time. */ +data class TidePrediction( + val timestampMs: Long, // Unix epoch milliseconds + val heightMeters: Double // predicted water height above chart datum in metres +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideStation.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideStation.kt new file mode 100644 index 0000000..c9f96a6 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideStation.kt @@ -0,0 +1,11 @@ +package com.example.androidapp.data.model + +/** A tide station with harmonic constituents for offline tide prediction. */ +data class TideStation( + val id: String, + val name: String, + val lat: Double, + val lon: Double, + val datumOffsetMeters: Double, // mean water level above chart datum (Z0) + val constituents: List<TideConstituent> +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/WindForecast.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/WindForecast.kt new file mode 100644 index 0000000..f009da8 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/WindForecast.kt @@ -0,0 +1,18 @@ +package org.terst.nav.data.model + +/** + * Wind conditions at a specific location and time. + * + * @param lat Latitude (decimal degrees). + * @param lon Longitude (decimal degrees). + * @param timestampMs UNIX time in milliseconds. + * @param twsKt True Wind Speed in knots. + * @param twdDeg True Wind Direction in degrees (the direction FROM which the wind blows, 0–360). + */ +data class WindForecast( + val lat: Double, + val lon: Double, + val timestampMs: Long, + val twsKt: Double, + val twdDeg: Double +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/track/TrackPoint.kt b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackPoint.kt new file mode 100644 index 0000000..d803c8c --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackPoint.kt @@ -0,0 +1,12 @@ +package org.terst.nav.track + +data class TrackPoint( + val lat: Double, + val lon: Double, + val sogKnots: Double, + val cogDeg: Double, + val windSpeedKnots: Double, + val windAngleDeg: Double, + val isTrueWind: Boolean, + val timestampMs: Long +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/track/TrackRepository.kt b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackRepository.kt new file mode 100644 index 0000000..7953822 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackRepository.kt @@ -0,0 +1,26 @@ +package org.terst.nav.track + +class TrackRepository { + + var isRecording: Boolean = false + private set + + private val points = mutableListOf<TrackPoint>() + + fun startTrack() { + points.clear() + isRecording = true + } + + fun stopTrack() { + isRecording = false + } + + fun addPoint(point: TrackPoint): Boolean { + if (!isRecording) return false + points.add(point) + return true + } + + fun getPoints(): List<TrackPoint> = points.toList() +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt index 8e84e1e..0efff52 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt @@ -6,6 +6,8 @@ import org.terst.nav.ais.AisHubSource import org.terst.nav.ais.AisRepository import org.terst.nav.ais.AisVessel import org.terst.nav.data.api.AisHubApiService +import org.terst.nav.track.TrackPoint +import org.terst.nav.track.TrackRepository import org.terst.nav.data.model.ForecastItem import org.terst.nav.data.model.WindArrow import org.terst.nav.data.repository.WeatherRepository @@ -43,6 +45,37 @@ class MainViewModel( private val aisRepository = AisRepository() + private val trackRepository = TrackRepository() + + private val _isRecording = MutableStateFlow(false) + val isRecording: StateFlow<Boolean> = _isRecording.asStateFlow() + + private val _trackPoints = MutableStateFlow<List<TrackPoint>>(emptyList()) + val trackPoints: StateFlow<List<TrackPoint>> = _trackPoints.asStateFlow() + + fun startTrack() { + trackRepository.startTrack() + _trackPoints.value = emptyList() + _isRecording.value = true + } + + fun stopTrack() { + trackRepository.stopTrack() + _isRecording.value = false + } + + fun addGpsPoint(lat: Double, lon: Double, sogKnots: Double, cogDeg: Double) { + val point = TrackPoint( + lat = lat, lon = lon, + sogKnots = sogKnots, cogDeg = cogDeg, + windSpeedKnots = 0.0, windAngleDeg = 0.0, isTrueWind = false, + timestampMs = System.currentTimeMillis() + ) + if (trackRepository.addPoint(point)) { + _trackPoints.value = trackRepository.getPoints() + } + } + private val aisHubApi: AisHubApiService by lazy { Retrofit.Builder() .baseUrl("https://data.aishub.net") diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt index 91569cf..cbc2e90 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt @@ -7,6 +7,7 @@ import org.maplibre.android.geometry.LatLng import org.maplibre.android.maps.MapLibreMap import org.maplibre.android.maps.Style import org.maplibre.android.style.layers.CircleLayer +import org.maplibre.android.style.layers.LineLayer import org.maplibre.android.style.layers.PropertyFactory import org.maplibre.android.style.layers.RasterLayer import org.maplibre.android.style.layers.SymbolLayer @@ -15,10 +16,12 @@ import org.maplibre.android.style.sources.RasterSource import org.maplibre.android.style.sources.TileSet import org.maplibre.geojson.Feature import org.maplibre.geojson.FeatureCollection +import org.maplibre.geojson.LineString import org.maplibre.geojson.Point import org.maplibre.geojson.Polygon import org.terst.nav.AnchorWatchState import org.terst.nav.TidalCurrentState +import org.terst.nav.track.TrackPoint import kotlin.math.cos import kotlin.math.sin @@ -37,9 +40,13 @@ class MapHandler(private val maplibreMap: MapLibreMap) { private val TIDAL_CURRENT_LAYER_ID = "tidal-current-layer" private val TIDAL_ARROW_ICON_ID = "tidal-arrow-icon" + private val TRACK_SOURCE_ID = "track-source" + private val TRACK_LAYER_ID = "track-line" + private var anchorPointSource: GeoJsonSource? = null private var anchorCircleSource: GeoJsonSource? = null private var tidalCurrentSource: GeoJsonSource? = null + private var trackSource: GeoJsonSource? = null /** * Initializes map layers for anchor watch and tidal currents. @@ -127,6 +134,28 @@ class MapHandler(private val maplibreMap: MapLibreMap) { } } + /** + * Updates the GPS track polyline on the map. Lazily initialises the layer on first call. + */ + fun updateTrackLayer(style: Style, points: List<TrackPoint>) { + if (trackSource == null) { + trackSource = GeoJsonSource(TRACK_SOURCE_ID) + style.addSource(trackSource!!) + style.addLayer(LineLayer(TRACK_LAYER_ID, TRACK_SOURCE_ID).apply { + setProperties( + PropertyFactory.lineColor("#E53935"), + PropertyFactory.lineWidth(3f) + ) + }) + } + if (points.size >= 2) { + val coords = points.map { Point.fromLngLat(it.lon, it.lat) } + trackSource?.setGeoJson(Feature.fromGeometry(LineString.fromLngLats(coords))) + } else { + trackSource?.setGeoJson(FeatureCollection.fromFeatures(emptyList())) + } + } + private fun createCirclePolygon(lat: Double, lon: Double, radiusMeters: Double): Polygon { val points = mutableListOf<Point>() val degreesBetweenPoints = 8 |