From c943c22954132b21f3067b526b3c13f3300113dd Mon Sep 17 00:00:00 2001 From: Claudomator Agent Date: Sun, 15 Mar 2026 00:58:54 +0000 Subject: Add GpsPosition data class and NMEA RMC parser with tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - GpsPosition: latitude, longitude, sog (knots), cog (degrees true), timestampMs - NmeaParser.parseRmc: handles GP/GN talker IDs, void status, malformed input - SOG/COG default to 0.0 when fields absent; S/W coords are negative - 13 unit tests: GpsPositionTest (2), NmeaParserTest (11) — all GREEN Co-Authored-By: Claude Sonnet 4.6 --- .../com/example/androidapp/gps/GpsPositionTest.kt | 33 +++++++ .../com/example/androidapp/nmea/NmeaParserTest.kt | 105 +++++++++++++++++++++ 2 files changed, 138 insertions(+) create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt new file mode 100644 index 0000000..8b2753c --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt @@ -0,0 +1,33 @@ +package com.example.androidapp.gps + +import org.junit.Assert.* +import org.junit.Test + +class GpsPositionTest { + + @Test + fun `GpsPosition holds correct values`() { + val pos = GpsPosition( + latitude = 41.5, + longitude = -71.0, + sog = 5.2, + cog = 180.0, + timestampMs = 1_000L + ) + assertEquals(41.5, pos.latitude, 0.0) + assertEquals(-71.0, pos.longitude, 0.0) + assertEquals(5.2, pos.sog, 0.0) + assertEquals(180.0, pos.cog, 0.0) + assertEquals(1_000L, pos.timestampMs) + } + + @Test + fun `GpsPosition equality works as expected for data class`() { + val pos1 = GpsPosition(41.5, -71.0, 5.2, 180.0, 1_000L) + val pos2 = GpsPosition(41.5, -71.0, 5.2, 180.0, 1_000L) + val pos3 = GpsPosition(42.0, -70.0, 3.0, 90.0, 2_000L) + + assertEquals(pos1, pos2) + assertNotEquals(pos1, pos3) + } +} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt new file mode 100644 index 0000000..b8a878a --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt @@ -0,0 +1,105 @@ +package com.example.androidapp.nmea + +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test + +class NmeaParserTest { + + private lateinit var parser: NmeaParser + + @Before + fun setUp() { + parser = NmeaParser() + } + + // $GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A + // lat: 48 + 7.038/60 = 48.1173°N, lon: 11 + 31.000/60 = 11.51667°E + // SOG 22.4 kn, COG 84.4° + + @Test + fun `valid RMC sentence parses latitude and longitude`() { + val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A" + val pos = parser.parseRmc(sentence) + assertNotNull(pos) + assertEquals(48.1173, pos!!.latitude, 0.0001) + assertEquals(11.51667, pos.longitude, 0.0001) + } + + @Test + fun `valid RMC sentence parses SOG and COG`() { + val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A" + val pos = parser.parseRmc(sentence) + assertNotNull(pos) + assertEquals(22.4, pos!!.sog, 0.001) + assertEquals(84.4, pos.cog, 0.001) + } + + @Test + fun `void status V returns null`() { + val sentence = "\$GPRMC,123519,V,4807.038,N,01131.000,E,,,230394,003.1,W" + assertNull(parser.parseRmc(sentence)) + } + + @Test + fun `malformed sentence with too few fields returns null`() { + assertNull(parser.parseRmc("\$GPRMC,123519,A")) + } + + @Test + fun `empty string returns null`() { + assertNull(parser.parseRmc("")) + } + + @Test + fun `non-RMC sentence returns null`() { + val sentence = "\$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,," + assertNull(parser.parseRmc(sentence)) + } + + @Test + fun `south latitude is negative`() { + // lat: -(42 + 50.5589/60) = -42.84265 + val sentence = "\$GPRMC,092204.999,A,4250.5589,S,14718.5084,E,0.00,89.68,211200,," + val pos = parser.parseRmc(sentence) + assertNotNull(pos) + assertTrue("South latitude must be negative", pos!!.latitude < 0) + assertEquals(-42.84265, pos.latitude, 0.0001) + } + + @Test + fun `west longitude is negative`() { + // lon: -(11 + 31.000/60) = -11.51667 + val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,W,022.4,084.4,230394,003.1,E" + val pos = parser.parseRmc(sentence) + assertNotNull(pos) + assertTrue("West longitude must be negative", pos!!.longitude < 0) + assertEquals(-11.51667, pos.longitude, 0.0001) + } + + @Test + fun `SOG and COG parse with decimal precision`() { + val sentence = "\$GPRMC,093456,A,3352.1234,N,11801.5678,W,12.345,270.5,140326,," + val pos = parser.parseRmc(sentence) + assertNotNull(pos) + assertEquals(12.345, pos!!.sog, 0.0001) + assertEquals(270.5, pos.cog, 0.0001) + } + + @Test + fun `empty SOG and COG fields default to zero`() { + val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,E,,,230394,003.1,W" + val pos = parser.parseRmc(sentence) + assertNotNull(pos) + assertEquals(0.0, pos!!.sog, 0.001) + assertEquals(0.0, pos.cog, 0.001) + } + + @Test + fun `GNRMC talker ID is also accepted`() { + val sentence = "\$GNRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W" + val pos = parser.parseRmc(sentence) + assertNotNull(pos) + assertEquals(48.1173, pos!!.latitude, 0.0001) + } +} -- cgit v1.2.3 From 826d56ede2c59cad19748f61d8b5d75d08a702d9 Mon Sep 17 00:00:00 2001 From: Claudomator Agent Date: Sun, 15 Mar 2026 03:44:25 +0000 Subject: feat: add harmonic tide height predictions (Section 3.2 / 4.2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implement offline harmonic tide prediction as specified in COMPONENT_DESIGN.md: - TideConstituent: name, speedDegPerHour, amplitudeMeters, phaseDeg - TidePrediction: timestampMs, heightMeters - TideStation: id, name, lat, lon, datumOffsetMeters, constituents - HarmonicTideCalculator: predictHeight(), predictRange(), findHighLow() Formula: h(t) = Z0 + Σ [ Hi × cos( ωi × (t − t0) − φi ) ] - 15 unit tests covering all calculation paths Co-Authored-By: Claude Sonnet 4.6 --- .../androidapp/tide/HarmonicTideCalculator.kt | 88 ++++++++++++++ .../org/terst/nav/data/model/TideConstituent.kt | 9 ++ .../org/terst/nav/data/model/TidePrediction.kt | 7 ++ .../kotlin/org/terst/nav/data/model/TideStation.kt | 11 ++ .../terst\\/nav/data/model/TideConstituent.kt" | 0 .../terst\\/nav/data/model/TidePrediction.kt" | 0 .../org\\/terst\\/nav/data/model/TideStation.kt" | 0 .../androidapp/tide/HarmonicTideCalculatorTest.kt | 135 +++++++++++++++++++++ .../org/terst/nav/data/model/TideModelTest.kt | 56 +++++++++ .../org\\/terst\\/nav/data/model/TideModelTest.kt" | 0 10 files changed, 306 insertions(+) create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/TideConstituent.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/TidePrediction.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/TideStation.kt create mode 100644 "android-app/app/src/main/kotlin/org\\/terst\\/nav/data/model/TideConstituent.kt" create mode 100644 "android-app/app/src/main/kotlin/org\\/terst\\/nav/data/model/TidePrediction.kt" create mode 100644 "android-app/app/src/main/kotlin/org\\/terst\\/nav/data/model/TideStation.kt" create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt create mode 100644 android-app/app/src/test/kotlin/org/terst/nav/data/model/TideModelTest.kt create mode 100644 "android-app/app/src/test/kotlin/org\\/terst\\/nav/data/model/TideModelTest.kt" (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt b/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt new file mode 100644 index 0000000..2bdbf6c --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt @@ -0,0 +1,88 @@ +package com.example.androidapp.tide + +import com.example.androidapp.data.model.TidePrediction +import com.example.androidapp.data.model.TideStation +import kotlin.math.cos + +/** + * Computes harmonic tide predictions using the standard formula: + * h(t) = Z0 + Σ [ Hi × cos( ωi × (t − t0) − φi ) ] + * + * where: + * Z0 = datum offset (mean water level above chart datum, metres) + * Hi = amplitude of constituent i (metres) + * ωi = angular speed of constituent i (degrees / hour) + * t = hours elapsed since [EPOCH_MS] (2000-01-01 00:00 UTC) + * φi = phase lag (degrees) + */ +object HarmonicTideCalculator { + + /** Reference epoch: 2000-01-01 00:00:00 UTC in Unix milliseconds. */ + internal const val EPOCH_MS = 946_684_800_000L + + /** + * Predict the tide height at a single moment. + * + * @param station Tide station with harmonic constituents. + * @param timestampMs Unix epoch milliseconds for the desired time. + * @return Predicted height in metres above chart datum. + */ + fun predictHeight(station: TideStation, timestampMs: Long): Double { + val hoursFromEpoch = (timestampMs - EPOCH_MS) / 3_600_000.0 + var height = station.datumOffsetMeters + for (c in station.constituents) { + val angleDeg = c.speedDegPerHour * hoursFromEpoch - c.phaseDeg + height += c.amplitudeMeters * cos(Math.toRadians(angleDeg)) + } + return height + } + + /** + * Predict tide heights over a time range at regular intervals. + * + * @param station Tide station. + * @param fromMs Start of range (Unix milliseconds, inclusive). + * @param toMs End of range (Unix milliseconds, inclusive). + * @param intervalMs Time step in milliseconds (must be positive). + * @return List of [TidePrediction] ordered by ascending timestamp. + */ + fun predictRange( + station: TideStation, + fromMs: Long, + toMs: Long, + intervalMs: Long + ): List { + require(intervalMs > 0) { "intervalMs must be positive" } + require(fromMs <= toMs) { "fromMs must not exceed toMs" } + val predictions = mutableListOf() + var t = fromMs + while (t <= toMs) { + predictions += TidePrediction(t, predictHeight(station, t)) + t += intervalMs + } + return predictions + } + + /** + * Find high and low water events from a pre-computed prediction series. + * + * Detects local maxima (high water) and minima (low water) by comparing + * each interior sample with its immediate neighbours. + * + * @param predictions Ordered list of tide predictions (at least 3 points). + * @return Subset list containing only high/low turning points. + */ + fun findHighLow(predictions: List): List { + if (predictions.size < 3) return emptyList() + val result = mutableListOf() + for (i in 1 until predictions.size - 1) { + val prev = predictions[i - 1].heightMeters + val curr = predictions[i].heightMeters + val next = predictions[i + 1].heightMeters + val isMax = curr >= prev && curr >= next + val isMin = curr <= prev && curr <= next + if (isMax || isMin) result += predictions[i] + } + return result + } +} 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 +) 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..e69de29 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..e69de29 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..e69de29 diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt new file mode 100644 index 0000000..612ae34 --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt @@ -0,0 +1,135 @@ +package com.example.androidapp.tide + +import com.example.androidapp.data.model.TideConstituent +import com.example.androidapp.data.model.TideStation +import org.junit.Assert.* +import org.junit.Test + +class HarmonicTideCalculatorTest { + + // Reference epoch: 2000-01-01 00:00:00 UTC = 946_684_800_000 ms + private val epochMs = HarmonicTideCalculator.EPOCH_MS + private val oneHourMs = 3_600_000L + + private fun stationWith( + speed: Double = 30.0, + amplitude: Double = 1.0, + phase: Double = 0.0, + datum: Double = 0.0 + ) = TideStation( + id = "test", name = "Test", lat = 0.0, lon = 0.0, + datumOffsetMeters = datum, + constituents = listOf(TideConstituent("S2", speed, amplitude, phase)) + ) + + @Test + fun `predictHeight at epoch gives datum plus amplitude for zero-phase constituent`() { + val station = stationWith(speed = 30.0, amplitude = 1.5, phase = 0.0, datum = 0.5) + val height = HarmonicTideCalculator.predictHeight(station, epochMs) + assertEquals(0.5 + 1.5, height, 1e-9) // cos(0°) = 1.0 + } + + @Test + fun `predictHeight at half period gives datum minus amplitude`() { + // speed = 30 deg/hr → half period = 6 hours → cos(180°) = -1.0 + val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 0.0, datum = 0.0) + val height = HarmonicTideCalculator.predictHeight(station, epochMs + 6 * oneHourMs) + assertEquals(-1.0, height, 1e-9) + } + + @Test + fun `predictHeight at quarter period is near zero`() { + // speed = 30 deg/hr → quarter period = 3 hours → cos(90°) ≈ 0.0 + val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 0.0, datum = 0.0) + val height = HarmonicTideCalculator.predictHeight(station, epochMs + 3 * oneHourMs) + assertEquals(0.0, height, 1e-9) + } + + @Test + fun `predictHeight applies phase offset correctly`() { + // phase = 90 → cos(0 - 90°) = cos(-90°) ≈ 0.0 at epoch + val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 90.0, datum = 0.0) + val height = HarmonicTideCalculator.predictHeight(station, epochMs) + assertEquals(0.0, height, 1e-9) + } + + @Test + fun `predictHeight sums multiple constituents at epoch`() { + val station = TideStation( + id = "test", name = "Test", lat = 0.0, lon = 0.0, + datumOffsetMeters = 2.0, + constituents = listOf( + TideConstituent("S2", 30.0, 1.0, 0.0), // +1.0 at epoch + TideConstituent("K1", 30.0, 0.5, 0.0) // +0.5 at epoch + ) + ) + val height = HarmonicTideCalculator.predictHeight(station, epochMs) + assertEquals(3.5, height, 1e-9) // 2.0 + 1.0 + 0.5 + } + + @Test + fun `predictHeight with empty constituents returns datum offset only`() { + val station = TideStation("t", "T", 0.0, 0.0, 3.14, emptyList()) + assertEquals(3.14, HarmonicTideCalculator.predictHeight(station, epochMs), 1e-9) + } + + @Test + fun `predictRange returns correct number of predictions`() { + val station = stationWith() + val predictions = HarmonicTideCalculator.predictRange( + station, epochMs, epochMs + 3 * oneHourMs, oneHourMs + ) + assertEquals(4, predictions.size) // t=0h, 1h, 2h, 3h + } + + @Test + fun `predictRange timestamps are evenly spaced`() { + val station = stationWith() + val predictions = HarmonicTideCalculator.predictRange( + station, epochMs, epochMs + 2 * oneHourMs, oneHourMs + ) + assertEquals(epochMs, predictions[0].timestampMs) + assertEquals(epochMs + oneHourMs, predictions[1].timestampMs) + assertEquals(epochMs + 2 * oneHourMs, predictions[2].timestampMs) + } + + @Test + fun `predictRange with equal from and to returns single prediction`() { + val station = stationWith() + val predictions = HarmonicTideCalculator.predictRange(station, epochMs, epochMs, oneHourMs) + assertEquals(1, predictions.size) + assertEquals(epochMs, predictions[0].timestampMs) + } + + @Test + fun `findHighLow returns empty list for fewer than 3 predictions`() { + val station = stationWith() + val predictions = HarmonicTideCalculator.predictRange( + station, epochMs, epochMs + oneHourMs, oneHourMs + ) + assertEquals(2, predictions.size) + assertTrue(HarmonicTideCalculator.findHighLow(predictions).isEmpty()) + } + + @Test + fun `findHighLow detects high and low water events`() { + // speed = 30 deg/hr, 3-hour samples over 24 hours + // Heights: 1.0, 0.0, -1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 1.0 + // Turning points at t=6h(low), t=12h(high), t=18h(low) + val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 0.0, datum = 0.0) + val predictions = HarmonicTideCalculator.predictRange( + station, + epochMs, + epochMs + 24 * oneHourMs, + 3 * oneHourMs + ) + val highLow = HarmonicTideCalculator.findHighLow(predictions) + assertEquals(3, highLow.size) + assertEquals(epochMs + 6 * oneHourMs, highLow[0].timestampMs) + assertEquals(-1.0, highLow[0].heightMeters, 1e-9) + assertEquals(epochMs + 12 * oneHourMs, highLow[1].timestampMs) + assertEquals(1.0, highLow[1].heightMeters, 1e-9) + assertEquals(epochMs + 18 * oneHourMs, highLow[2].timestampMs) + assertEquals(-1.0, highLow[2].heightMeters, 1e-9) + } +} diff --git a/android-app/app/src/test/kotlin/org/terst/nav/data/model/TideModelTest.kt b/android-app/app/src/test/kotlin/org/terst/nav/data/model/TideModelTest.kt new file mode 100644 index 0000000..0a6f4bb --- /dev/null +++ b/android-app/app/src/test/kotlin/org/terst/nav/data/model/TideModelTest.kt @@ -0,0 +1,56 @@ +package com.example.androidapp.data.model + +import org.junit.Assert.* +import org.junit.Test + +class TideModelTest { + + @Test + fun `TideConstituent holds all fields`() { + val c = TideConstituent("M2", 28.9841042, 0.85, 120.0) + assertEquals("M2", c.name) + assertEquals(28.9841042, c.speedDegPerHour, 1e-7) + assertEquals(0.85, c.amplitudeMeters, 1e-9) + assertEquals(120.0, c.phaseDeg, 1e-9) + } + + @Test + fun `TidePrediction holds timestamp and height`() { + val p = TidePrediction(1_700_000_000_000L, 2.34) + assertEquals(1_700_000_000_000L, p.timestampMs) + assertEquals(2.34, p.heightMeters, 1e-9) + } + + @Test + fun `TidePrediction data class equality`() { + val p1 = TidePrediction(1_000L, 1.5) + val p2 = TidePrediction(1_000L, 1.5) + assertEquals(p1, p2) + } + + @Test + fun `TideStation holds all fields and constituents`() { + val c = TideConstituent("K1", 15.0410686, 0.3, 45.0) + val station = TideStation( + id = "9447130", + name = "Seattle, WA", + lat = 47.602, + lon = -122.339, + datumOffsetMeters = 1.8, + constituents = listOf(c) + ) + assertEquals("9447130", station.id) + assertEquals("Seattle, WA", station.name) + assertEquals(47.602, station.lat, 1e-9) + assertEquals(-122.339, station.lon, 1e-9) + assertEquals(1.8, station.datumOffsetMeters, 1e-9) + assertEquals(1, station.constituents.size) + assertEquals("K1", station.constituents[0].name) + } + + @Test + fun `TideStation with empty constituents is valid`() { + val station = TideStation("test", "Test", 0.0, 0.0, 0.0, emptyList()) + assertTrue(station.constituents.isEmpty()) + } +} diff --git "a/android-app/app/src/test/kotlin/org\\/terst\\/nav/data/model/TideModelTest.kt" "b/android-app/app/src/test/kotlin/org\\/terst\\/nav/data/model/TideModelTest.kt" new file mode 100644 index 0000000..e69de29 -- cgit v1.2.3 From 984f915525184a9aaff87f3d5687ef46ebb00702 Mon Sep 17 00:00:00 2001 From: Claudomator Agent Date: Sun, 15 Mar 2026 05:55:47 +0000 Subject: feat: implement isochrone-based weather routing (Section 3.4) --- .../example/androidapp/routing/IsochroneResult.kt | 12 ++ .../example/androidapp/routing/IsochroneRouter.kt | 178 +++++++++++++++++++++ .../com/example/androidapp/routing/RoutePoint.kt | 16 ++ .../kotlin/org/terst/nav/data/model/BoatPolars.kt | 69 ++++++++ .../org/terst/nav/data/model/WindForecast.kt | 18 +++ .../androidapp/routing/IsochroneRouterTest.kt | 169 +++++++++++++++++++ 6 files changed, 462 insertions(+) create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/BoatPolars.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/WindForecast.kt create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt new file mode 100644 index 0000000..60a5918 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt @@ -0,0 +1,12 @@ +package com.example.androidapp.routing + +/** + * The result of an isochrone weather routing computation. + * + * @param path Ordered list of [RoutePoint]s from the start to the destination. + * @param etaMs Estimated Time of Arrival as a UNIX timestamp in milliseconds. + */ +data class IsochroneResult( + val path: List, + val etaMs: Long +) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt new file mode 100644 index 0000000..25055a8 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt @@ -0,0 +1,178 @@ +package com.example.androidapp.routing + +import com.example.androidapp.data.model.BoatPolars +import com.example.androidapp.data.model.WindForecast +import kotlin.math.asin +import kotlin.math.atan2 +import kotlin.math.cos +import kotlin.math.pow +import kotlin.math.sin +import kotlin.math.sqrt + +/** + * Isochrone-based weather routing engine (Section 3.4). + * + * Algorithm: + * 1. Start from a single point; expand a fan of headings at each time step. + * 2. For each candidate heading, compute BSP from [BoatPolars] at the local forecast wind. + * 3. Advance position by BSP × Δt using the spherical-Earth destination-point formula. + * 4. Check whether the destination has been reached (within [arrivalRadiusM]). + * 5. Prune candidates: for each angular sector around the start, keep only the point that + * advanced furthest (removes dominated points). + * 6. Repeat until the destination is reached or [maxSteps] is exhausted. + * 7. Backtrace parent pointers to produce the optimal path. + */ +object IsochroneRouter { + + private const val EARTH_RADIUS_M = 6_371_000.0 + internal const val NM_TO_M = 1_852.0 + private const val KT_TO_M_PER_S = NM_TO_M / 3600.0 + + const val DEFAULT_HEADING_STEP_DEG = 5.0 + const val DEFAULT_ARRIVAL_RADIUS_M = 1_852.0 // 1 NM + const val DEFAULT_PRUNE_SECTORS = 72 // 5° sectors + const val DEFAULT_MAX_STEPS = 200 + + /** + * Compute an optimised route from start to destination. + * + * @param startLat Start latitude (decimal degrees). + * @param startLon Start longitude (decimal degrees). + * @param destLat Destination latitude (decimal degrees). + * @param destLon Destination longitude (decimal degrees). + * @param startTimeMs Departure time as UNIX timestamp (ms). + * @param stepMs Time increment per isochrone step (ms). Typical: 1–3 hours. + * @param polars Boat polar table. + * @param windAt Function returning [WindForecast] for a given position and time. + * @param headingStepDeg Angular resolution of the heading fan (degrees). Default 5°. + * @param arrivalRadiusM Distance threshold to consider destination reached (metres). + * @param maxSteps Maximum number of isochrone expansions before giving up. + * @return [IsochroneResult] with the optimal path and ETA, or null if unreachable. + */ + fun route( + startLat: Double, + startLon: Double, + destLat: Double, + destLon: Double, + startTimeMs: Long, + stepMs: Long, + polars: BoatPolars, + windAt: (lat: Double, lon: Double, timeMs: Long) -> WindForecast, + headingStepDeg: Double = DEFAULT_HEADING_STEP_DEG, + arrivalRadiusM: Double = DEFAULT_ARRIVAL_RADIUS_M, + maxSteps: Int = DEFAULT_MAX_STEPS + ): IsochroneResult? { + val start = RoutePoint(startLat, startLon, startTimeMs) + var isochrone = listOf(start) + + repeat(maxSteps) { step -> + val nextTimeMs = startTimeMs + (step + 1).toLong() * stepMs + val candidates = mutableListOf() + + for (point in isochrone) { + var heading = 0.0 + while (heading < 360.0) { + val wind = windAt(point.lat, point.lon, point.timestampMs) + val twa = ((heading - wind.twdDeg + 360.0) % 360.0) + val bspKt = polars.bsp(twa, wind.twsKt) + if (bspKt > 0.0) { + val distM = bspKt * KT_TO_M_PER_S * (stepMs / 1000.0) + val (newLat, newLon) = destinationPoint(point.lat, point.lon, heading, distM) + val newPoint = RoutePoint(newLat, newLon, nextTimeMs, parent = point) + + if (haversineM(newLat, newLon, destLat, destLon) <= arrivalRadiusM) { + return IsochroneResult( + path = backtrace(newPoint), + etaMs = nextTimeMs + ) + } + candidates.add(newPoint) + } + heading += headingStepDeg + } + } + + if (candidates.isEmpty()) return null + isochrone = prune(candidates, startLat, startLon, DEFAULT_PRUNE_SECTORS) + } + + return null + } + + /** Walk parent pointers from destination back to start, then reverse. */ + internal fun backtrace(dest: RoutePoint): List { + val path = mutableListOf() + var current: RoutePoint? = dest + while (current != null) { + path.add(current) + current = current.parent + } + path.reverse() + return path + } + + /** + * Angular-sector pruning: divide the plane into [sectors] equal angular sectors around the + * start. Within each sector keep only the candidate that is furthest from the start. + */ + internal fun prune( + candidates: List, + startLat: Double, + startLon: Double, + sectors: Int + ): List { + val sectorSize = 360.0 / sectors + val best = mutableMapOf() + + for (point in candidates) { + val bearing = bearingDeg(startLat, startLon, point.lat, point.lon) + val sector = (bearing / sectorSize).toInt().coerceIn(0, sectors - 1) + val existing = best[sector] + if (existing == null || + haversineM(startLat, startLon, point.lat, point.lon) > + haversineM(startLat, startLon, existing.lat, existing.lon) + ) { + best[sector] = point + } + } + + return best.values.toList() + } + + /** Haversine great-circle distance in metres. */ + internal fun haversineM(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double { + val dLat = Math.toRadians(lat2 - lat1) + val dLon = Math.toRadians(lon2 - lon1) + val a = sin(dLat / 2).pow(2) + + cos(Math.toRadians(lat1)) * cos(Math.toRadians(lat2)) * sin(dLon / 2).pow(2) + return 2.0 * EARTH_RADIUS_M * asin(sqrt(a)) + } + + /** Initial bearing from point 1 to point 2 (degrees, 0 = North, clockwise). */ + internal fun bearingDeg(lat1Deg: Double, lon1Deg: Double, lat2Deg: Double, lon2Deg: Double): Double { + val lat1 = Math.toRadians(lat1Deg) + val lat2 = Math.toRadians(lat2Deg) + val dLon = Math.toRadians(lon2Deg - lon1Deg) + val y = sin(dLon) * cos(lat2) + val x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon) + return (Math.toDegrees(atan2(y, x)) + 360.0) % 360.0 + } + + /** Spherical-Earth destination-point given start, bearing, and distance. */ + internal fun destinationPoint( + lat1Deg: Double, + lon1Deg: Double, + bearingDeg: Double, + distM: Double + ): Pair { + val lat1 = Math.toRadians(lat1Deg) + val lon1 = Math.toRadians(lon1Deg) + val brng = Math.toRadians(bearingDeg) + val d = distM / EARTH_RADIUS_M + + val lat2 = asin(sin(lat1) * cos(d) + cos(lat1) * sin(d) * cos(brng)) + val lon2 = lon1 + atan2(sin(brng) * sin(d) * cos(lat1), cos(d) - sin(lat1) * sin(lat2)) + + return Pair(Math.toDegrees(lat2), Math.toDegrees(lon2)) + } +} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt new file mode 100644 index 0000000..02988d1 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt @@ -0,0 +1,16 @@ +package com.example.androidapp.routing + +/** + * A single point in the isochrone routing tree. + * + * @param lat Latitude (decimal degrees). + * @param lon Longitude (decimal degrees). + * @param timestampMs UNIX time in milliseconds when this position is reached. + * @param parent The previous [RoutePoint] (null for the start point). + */ +data class RoutePoint( + val lat: Double, + val lon: Double, + val timestampMs: Long, + val parent: RoutePoint? = null +) 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> +) { + /** + * 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 { + 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/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/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt new file mode 100644 index 0000000..e5615e9 --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt @@ -0,0 +1,169 @@ +package com.example.androidapp.routing + +import com.example.androidapp.data.model.BoatPolars +import com.example.androidapp.data.model.WindForecast +import org.junit.Assert.* +import org.junit.Test + +class IsochroneRouterTest { + + private val startTimeMs = 1_000_000_000L + private val oneHourMs = 3_600_000L + + // ── BoatPolars ──────────────────────────────────────────────────────────── + + @Test + fun `bsp returns exact value for exact twa and tws entry`() { + val polars = BoatPolars.DEFAULT + // At TWS=10, TWA=90 the table has 7.0 kt + assertEquals(7.0, polars.bsp(90.0, 10.0), 1e-9) + } + + @Test + fun `bsp interpolates between twa entries`() { + val polars = BoatPolars.DEFAULT + // At TWS=10: TWA=60 → 6.5, TWA=90 → 7.0; midpoint TWA=75 → 6.75 + assertEquals(6.75, polars.bsp(75.0, 10.0), 1e-9) + } + + @Test + fun `bsp interpolates between tws entries`() { + val polars = BoatPolars.DEFAULT + // At TWA=90: TWS=10 → 7.0, TWS=15 → 8.0; midpoint TWS=12.5 → 7.5 + assertEquals(7.5, polars.bsp(90.0, 12.5), 1e-9) + } + + @Test + fun `bsp mirrors port tack twa to starboard`() { + val polars = BoatPolars.DEFAULT + // TWA=270 should mirror to 360-270=90, giving same as TWA=90 + assertEquals(polars.bsp(90.0, 10.0), polars.bsp(270.0, 10.0), 1e-9) + } + + @Test + fun `bsp clamps tws below table minimum`() { + val polars = BoatPolars.DEFAULT + // TWS=0 clamps to minimum TWS=5 + assertEquals(polars.bsp(90.0, 5.0), polars.bsp(90.0, 0.0), 1e-9) + } + + @Test + fun `bsp clamps tws above table maximum`() { + val polars = BoatPolars.DEFAULT + // TWS=100 clamps to maximum TWS=20 + assertEquals(polars.bsp(90.0, 20.0), polars.bsp(90.0, 100.0), 1e-9) + } + + // ── IsochroneRouter geometry helpers ───────────────────────────────────── + + @Test + fun `haversineM returns zero for same point`() { + assertEquals(0.0, IsochroneRouter.haversineM(10.0, 20.0, 10.0, 20.0), 1e-3) + } + + @Test + fun `haversineM one degree of latitude is approximately 111_195 m`() { + val dist = IsochroneRouter.haversineM(0.0, 0.0, 1.0, 0.0) + assertEquals(111_195.0, dist, 50.0) + } + + @Test + fun `bearingDeg returns 0 for due north`() { + val bearing = IsochroneRouter.bearingDeg(0.0, 0.0, 1.0, 0.0) + assertEquals(0.0, bearing, 1e-6) + } + + @Test + fun `bearingDeg returns 90 for due east`() { + val bearing = IsochroneRouter.bearingDeg(0.0, 0.0, 0.0, 1.0) + assertEquals(90.0, bearing, 1e-4) + } + + @Test + fun `destinationPoint due north by 1 NM moves latitude by expected amount`() { + val (lat, lon) = IsochroneRouter.destinationPoint(0.0, 0.0, 0.0, IsochroneRouter.NM_TO_M) + assertTrue("latitude should increase", lat > 0.0) + assertEquals(0.0, lon, 1e-9) + // 1 NM ≈ 1/60 degree of latitude + assertEquals(1.0 / 60.0, lat, 1e-4) + } + + // ── Pruning ─────────────────────────────────────────────────────────────── + + @Test + fun `prune keeps only furthest point per sector`() { + // Two points both due north of origin at different distances + val close = RoutePoint(1.0, 0.0, startTimeMs) + val far = RoutePoint(2.0, 0.0, startTimeMs) + val result = IsochroneRouter.prune(listOf(close, far), 0.0, 0.0, 72) + assertEquals(1, result.size) + assertEquals(far, result[0]) + } + + @Test + fun `prune keeps points in different sectors separately`() { + // One point north, one point east — different sectors + val north = RoutePoint(1.0, 0.0, startTimeMs) + val east = RoutePoint(0.0, 1.0, startTimeMs) + val result = IsochroneRouter.prune(listOf(north, east), 0.0, 0.0, 72) + assertEquals(2, result.size) + } + + // ── Full routing ────────────────────────────────────────────────────────── + + @Test + fun `route finds path to destination with constant wind`() { + // Destination is ~5 NM due east of start; constant 10kt easterly (FROM east = 90°) + // A 10kt boat sailing downwind (TWA=180) = 6.0 kt; ~5 NM / 6 kt ≈ 50 min → 1 step + val destLat = 0.0 + val destLon = 0.0 + (5.0 / 60.0) // ~5 NM east + val constantWind = { _: Double, _: Double, _: Long -> + WindForecast(0.0, 0.0, startTimeMs, twsKt = 10.0, twdDeg = 90.0) + } + val result = IsochroneRouter.route( + startLat = 0.0, + startLon = 0.0, + destLat = destLat, + destLon = destLon, + startTimeMs = startTimeMs, + stepMs = oneHourMs, + polars = BoatPolars.DEFAULT, + windAt = constantWind, + arrivalRadiusM = 2_000.0 // 2 km arrival radius + ) + assertNotNull("Should find a route", result) + result!! + assertTrue("Path should have at least 2 points (start + arrival)", result.path.size >= 2) + assertEquals("Path should start at origin", 0.0, result.path.first().lat, 1e-6) + assertEquals("ETA should be after start", startTimeMs, result.etaMs - oneHourMs) + } + + @Test + fun `route returns null when polars produce zero speed`() { + val zeroPolar = BoatPolars(emptyMap()) + val result = IsochroneRouter.route( + startLat = 0.0, + startLon = 0.0, + destLat = 1.0, + destLon = 0.0, + startTimeMs = startTimeMs, + stepMs = oneHourMs, + polars = zeroPolar, + windAt = { _, _, _ -> WindForecast(0.0, 0.0, startTimeMs, 10.0, 0.0) }, + maxSteps = 3 + ) + assertNull("Should return null when no progress is possible", result) + } + + @Test + fun `backtrace returns path from start to arrival in order`() { + val p0 = RoutePoint(0.0, 0.0, 0L) + val p1 = RoutePoint(1.0, 0.0, 1L, parent = p0) + val p2 = RoutePoint(2.0, 0.0, 2L, parent = p1) + val path = IsochroneRouter.backtrace(p2) + assertEquals(3, path.size) + assertEquals(p0, path[0]) + assertEquals(p1, path[1]) + assertEquals(p2, path[2]) + } +} -- cgit v1.2.3 From 7193b2b3478171a49330f9cbcae5cd238a7d74d7 Mon Sep 17 00:00:00 2001 From: Claudomator Agent Date: Mon, 16 Mar 2026 00:03:17 +0000 Subject: feat: implement PDF logbook export (Section 4.8) - LogbookEntry data class: timestampMs, lat/lon, SOG, COG, wind, baro, depth, event/notes - LogbookFormatter: UTC time, position (deg/dec-min), 16-pt compass, row/page builders - LogbookPdfExporter: landscape A4 PDF via android.graphics.pdf.PdfDocument with column headers, alternating row shading, and table border - 20 unit tests covering all formatting helpers and data model behaviour Co-Authored-By: Claude Sonnet 4.6 --- .../example/androidapp/logbook/LogbookFormatter.kt | 81 ++++++++++ .../androidapp/logbook/LogbookPdfExporter.kt | 137 ++++++++++++++++ .../org/terst/nav/data/model/LogbookEntry.kt | 19 +++ .../androidapp/logbook/LogbookFormatterTest.kt | 178 +++++++++++++++++++++ .../org/terst/nav/data/model/LogbookEntryTest.kt | 67 ++++++++ 5 files changed, 482 insertions(+) create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/LogbookEntry.kt create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt create mode 100644 android-app/app/src/test/kotlin/org/terst/nav/data/model/LogbookEntryTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt new file mode 100644 index 0000000..b0a910a --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt @@ -0,0 +1,81 @@ +package com.example.androidapp.logbook + +import com.example.androidapp.data.model.LogbookEntry +import java.util.Calendar +import java.util.TimeZone + +data class LogbookRow( + val time: String, + val position: String, + val sog: String, + val cog: String, + val wind: String, + val baro: String, + val depth: String, + val eventNotes: String +) + +data class LogbookPage( + val title: String, + val columns: List, + val rows: List +) + +object LogbookFormatter { + + val COLUMNS = listOf( + "Time (UTC)", "Position", "SOG", "COG", "Wind", "Baro", "Depth", "Event / Notes" + ) + + private val COMPASS_POINTS = arrayOf( + "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", + "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW" + ) + + fun formatTime(timestampMs: Long): String { + val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC")) + cal.timeInMillis = timestampMs + return "%02d:%02d".format( + cal.get(Calendar.HOUR_OF_DAY), + cal.get(Calendar.MINUTE) + ) + } + + fun formatPosition(lat: Double, lon: Double): String { + val latDir = if (lat >= 0) "N" else "S" + val lonDir = if (lon >= 0) "E" else "W" + val absLat = Math.abs(lat) + val absLon = Math.abs(lon) + val latDeg = absLat.toInt() + val lonDeg = absLon.toInt() + val latMin = (absLat - latDeg) * 60.0 + val lonMin = (absLon - lonDeg) * 60.0 + return "%d°%.1f%s %d°%.1f%s".format(latDeg, latMin, latDir, lonDeg, lonMin, lonDir) + } + + fun toCompassPoint(degrees: Double): String { + val normalized = ((degrees % 360.0) + 360.0) % 360.0 + val index = ((normalized + 11.25) / 22.5).toInt() % 16 + return COMPASS_POINTS[index] + } + + fun formatWind(knots: Double?, directionDeg: Double?): String { + if (knots == null) return "" + val knotsStr = "%.0fkt".format(knots) + return if (directionDeg == null) knotsStr else "$knotsStr ${toCompassPoint(directionDeg)}" + } + + fun toRow(entry: LogbookEntry): LogbookRow = LogbookRow( + time = formatTime(entry.timestampMs), + position = formatPosition(entry.lat, entry.lon), + sog = "%.1f".format(entry.sogKnots), + cog = "%.0f".format(entry.cogDegrees), + wind = formatWind(entry.windKnots, entry.windDirectionDeg), + baro = entry.baroHpa?.let { "%.0f".format(it) } ?: "", + depth = entry.depthMeters?.let { "%.0fm".format(it) } ?: "", + eventNotes = listOfNotNull(entry.event, entry.notes).joinToString(": ") + ) + + fun toPage(entries: List, title: String = "Trip Logbook"): LogbookPage = + LogbookPage(title = title, columns = COLUMNS, rows = entries.map { toRow(it) }) +} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt new file mode 100644 index 0000000..ff8ce9a --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt @@ -0,0 +1,137 @@ +package com.example.androidapp.logbook + +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.Paint +import android.graphics.Typeface +import android.graphics.pdf.PdfDocument +import com.example.androidapp.data.model.LogbookEntry +import java.io.OutputStream + +/** + * Renders trip logbook entries to a formatted PDF (landscape A4). + * Section 4.8 — Trip Logging and Electronic Logbook. + */ +object LogbookPdfExporter { + + // Landscape A4 in points (1 point = 1/72 inch) + private const val PAGE_WIDTH = 842 + private const val PAGE_HEIGHT = 595 + private const val MARGIN = 36f + private const val ROW_HEIGHT = 22f + private const val HEADER_HEIGHT = 36f + private const val TITLE_SIZE = 16f + private const val CELL_TEXT_SIZE = 9f + + // Column width fractions (must sum to 1.0) + private val COL_FRACTIONS = floatArrayOf( + 0.08f, // Time + 0.18f, // Position + 0.06f, // SOG + 0.06f, // COG + 0.10f, // Wind + 0.07f, // Baro + 0.07f, // Depth + 0.38f // Event / Notes + ) + + fun export( + entries: List, + outputStream: OutputStream, + title: String = "Trip Logbook" + ) { + val page = LogbookFormatter.toPage(entries, title) + val document = PdfDocument() + try { + val pageInfo = PdfDocument.PageInfo.Builder(PAGE_WIDTH, PAGE_HEIGHT, 1).create() + val pdfPage = document.startPage(pageInfo) + drawPage(pdfPage.canvas, page) + document.finishPage(pdfPage) + document.writeTo(outputStream) + } finally { + document.close() + } + } + + private fun drawPage(canvas: Canvas, page: LogbookPage) { + val usableWidth = PAGE_WIDTH - 2 * MARGIN + val colWidths = COL_FRACTIONS.map { it * usableWidth } + + val titlePaint = Paint().apply { + textSize = TITLE_SIZE + typeface = Typeface.DEFAULT_BOLD + color = Color.BLACK + } + val headerTextPaint = Paint().apply { + textSize = CELL_TEXT_SIZE + typeface = Typeface.DEFAULT_BOLD + color = Color.WHITE + } + val cellPaint = Paint().apply { + textSize = CELL_TEXT_SIZE + color = Color.BLACK + } + val linePaint = Paint().apply { + color = Color.LTGRAY + strokeWidth = 0.5f + } + val headerBgPaint = Paint().apply { + color = Color.rgb(41, 82, 123) + style = Paint.Style.FILL + } + val altBgPaint = Paint().apply { + color = Color.rgb(235, 242, 252) + style = Paint.Style.FILL + } + val borderPaint = Paint().apply { + color = Color.DKGRAY + strokeWidth = 1f + style = Paint.Style.STROKE + } + + var y = MARGIN + + // Title + canvas.drawText(page.title, MARGIN, y + TITLE_SIZE, titlePaint) + y += HEADER_HEIGHT + + val tableTop = y + + // Column header background + canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, headerBgPaint) + + // Column header text + var x = MARGIN + 3f + page.columns.forEachIndexed { i, col -> + canvas.drawText(col, x, y + ROW_HEIGHT - 6f, headerTextPaint) + x += colWidths[i] + } + y += ROW_HEIGHT + + // Data rows + page.rows.forEach { row -> + if (y + ROW_HEIGHT > PAGE_HEIGHT - MARGIN) return@forEach + + if (page.rows.indexOf(row) % 2 == 1) { + canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, altBgPaint) + } + + val cells = listOf( + row.time, row.position, row.sog, row.cog, + row.wind, row.baro, row.depth, row.eventNotes + ) + x = MARGIN + 3f + cells.forEachIndexed { i, cell -> + val maxChars = (colWidths[i] / (CELL_TEXT_SIZE * 0.55)).toInt().coerceAtLeast(4) + canvas.drawText(cell.take(maxChars), x, y + ROW_HEIGHT - 6f, cellPaint) + x += colWidths[i] + } + + canvas.drawLine(MARGIN, y + ROW_HEIGHT, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, linePaint) + y += ROW_HEIGHT + } + + // Table border + canvas.drawRect(MARGIN, tableTop, PAGE_WIDTH - MARGIN, y, borderPaint) + } +} 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/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt new file mode 100644 index 0000000..30b421f --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt @@ -0,0 +1,178 @@ +package com.example.androidapp.logbook + +import com.example.androidapp.data.model.LogbookEntry +import org.junit.Assert.* +import org.junit.Test + +class LogbookFormatterTest { + + // 2021-06-15 08:00:00 UTC = 1623744000000 ms + private val t0 = 1_623_744_000_000L + + private fun entry( + ts: Long = t0, + lat: Double = 41.39, + lon: Double = -71.202, + sog: Double = 6.2, + cog: Double = 225.0, + windKt: Double? = 15.0, + windDir: Double? = 225.0, + baro: Double? = 1018.0, + depth: Double? = 14.0, + event: String? = "Departed slip", + notes: String? = null + ) = LogbookEntry(ts, lat, lon, sog, cog, windKt, windDir, baro, depth, event, notes) + + // --- formatTime --- + + @Test + fun `formatTime returns HH_MM for UTC midnight`() { + // 2021-06-15 00:00:00 UTC + val ts = 1_623_715_200_000L + assertEquals("00:00", LogbookFormatter.formatTime(ts)) + } + + @Test + fun `formatTime returns correct UTC hour for known timestamp`() { + // t0 = 2021-06-15 08:00:00 UTC + assertEquals("08:00", LogbookFormatter.formatTime(t0)) + } + + @Test + fun `formatTime pads single-digit hour and minute`() { + // 2021-06-15 01:05:00 UTC = 1623715200000 + 65*60*1000 = 1623715200000 + 3900000 + val ts = 1_623_715_200_000L + 65 * 60_000L + assertEquals("01:05", LogbookFormatter.formatTime(ts)) + } + + // --- formatPosition --- + + @Test + fun `formatPosition north east`() { + // 41.39°N → 41°23.4N, 71.202°E → 71°12.1E + val result = LogbookFormatter.formatPosition(41.39, 71.202) + assertEquals("41°23.4N 71°12.1E", result) + } + + @Test + fun `formatPosition south west`() { + // -41.39°S → 41°23.4S, -71.202°W → 71°12.1W + val result = LogbookFormatter.formatPosition(-41.39, -71.202) + assertEquals("41°23.4S 71°12.1W", result) + } + + @Test + fun `formatPosition zero zero`() { + val result = LogbookFormatter.formatPosition(0.0, 0.0) + assertEquals("0°0.0N 0°0.0E", result) + } + + // --- formatWind --- + + @Test + fun `formatWind null knots returns empty string`() { + assertEquals("", LogbookFormatter.formatWind(null, null)) + } + + @Test + fun `formatWind with knots and null direction returns knots only`() { + assertEquals("15kt", LogbookFormatter.formatWind(15.0, null)) + } + + @Test + fun `formatWind 225 degrees is SW`() { + assertEquals("15kt SW", LogbookFormatter.formatWind(15.0, 225.0)) + } + + @Test + fun `formatWind 0 degrees is N`() { + assertEquals("10kt N", LogbookFormatter.formatWind(10.0, 0.0)) + } + + @Test + fun `formatWind 360 degrees is N`() { + assertEquals("10kt N", LogbookFormatter.formatWind(10.0, 360.0)) + } + + @Test + fun `formatWind 90 degrees is E`() { + assertEquals("8kt E", LogbookFormatter.formatWind(8.0, 90.0)) + } + + // --- toCompassPoint --- + + @Test + fun `toCompassPoint covers all 16 cardinal and intercardinal points`() { + val expected = listOf("N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", + "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW") + expected.forEachIndexed { i, dir -> + val degrees = i * 22.5 + assertEquals("degrees=$degrees", dir, LogbookFormatter.toCompassPoint(degrees)) + } + } + + // --- toRow --- + + @Test + fun `toRow formats all fields correctly`() { + val row = LogbookFormatter.toRow(entry()) + assertEquals("08:00", row.time) + assertEquals("41°23.4N 71°12.1W", row.position) + assertEquals("6.2", row.sog) + assertEquals("225", row.cog) + assertEquals("15kt SW", row.wind) + assertEquals("1018", row.baro) + assertEquals("14m", row.depth) + assertEquals("Departed slip", row.eventNotes) + } + + @Test + fun `toRow combines event and notes with colon`() { + val row = LogbookFormatter.toRow(entry(event = "Reef #1", notes = "Strong gusts")) + assertEquals("Reef #1: Strong gusts", row.eventNotes) + } + + @Test + fun `toRow with only notes has no colon prefix`() { + val row = LogbookFormatter.toRow(entry(event = null, notes = "Calm seas")) + assertEquals("Calm seas", row.eventNotes) + } + + @Test + fun `toRow with null optional fields uses empty strings`() { + val e = LogbookEntry(t0, 0.0, 0.0, 0.0, 0.0) + val row = LogbookFormatter.toRow(e) + assertEquals("", row.wind) + assertEquals("", row.baro) + assertEquals("", row.depth) + assertEquals("", row.eventNotes) + } + + // --- toPage --- + + @Test + fun `toPage returns page with default title and correct column count`() { + val page = LogbookFormatter.toPage(emptyList()) + assertEquals("Trip Logbook", page.title) + assertEquals(8, page.columns.size) + } + + @Test + fun `toPage maps entries to rows in order`() { + val entries = listOf( + entry(ts = t0, event = "First"), + entry(ts = t0 + 3_600_000L, event = "Second") + ) + val page = LogbookFormatter.toPage(entries, "Voyage Log") + assertEquals("Voyage Log", page.title) + assertEquals(2, page.rows.size) + assertEquals("First", page.rows[0].eventNotes) + assertEquals("Second", page.rows[1].eventNotes) + } + + @Test + fun `toPage empty entries produces empty rows`() { + val page = LogbookFormatter.toPage(emptyList()) + assertTrue(page.rows.isEmpty()) + } +} diff --git a/android-app/app/src/test/kotlin/org/terst/nav/data/model/LogbookEntryTest.kt b/android-app/app/src/test/kotlin/org/terst/nav/data/model/LogbookEntryTest.kt new file mode 100644 index 0000000..fc4580c --- /dev/null +++ b/android-app/app/src/test/kotlin/org/terst/nav/data/model/LogbookEntryTest.kt @@ -0,0 +1,67 @@ +package org.terst.nav.data.model + +import org.junit.Assert.* +import org.junit.Test + +class LogbookEntryTest { + + @Test + fun `LogbookEntry holds all required fields`() { + val entry = LogbookEntry( + timestampMs = 1_000_000L, + lat = 41.39, + lon = -71.202, + sogKnots = 6.2, + cogDegrees = 225.0, + windKnots = 15.0, + windDirectionDeg = 225.0, + baroHpa = 1018.0, + depthMeters = 14.0, + event = "Departed slip", + notes = "Crew ready" + ) + assertEquals(1_000_000L, entry.timestampMs) + assertEquals(41.39, entry.lat, 1e-9) + assertEquals(-71.202, entry.lon, 1e-9) + assertEquals(6.2, entry.sogKnots, 1e-9) + assertEquals(225.0, entry.cogDegrees, 1e-9) + assertEquals(15.0, entry.windKnots) + assertEquals(225.0, entry.windDirectionDeg) + assertEquals(1018.0, entry.baroHpa) + assertEquals(14.0, entry.depthMeters) + assertEquals("Departed slip", entry.event) + assertEquals("Crew ready", entry.notes) + } + + @Test + fun `LogbookEntry optional fields default to null`() { + val entry = LogbookEntry( + timestampMs = 0L, + lat = 0.0, + lon = 0.0, + sogKnots = 0.0, + cogDegrees = 0.0 + ) + assertNull(entry.windKnots) + assertNull(entry.windDirectionDeg) + assertNull(entry.baroHpa) + assertNull(entry.depthMeters) + assertNull(entry.event) + assertNull(entry.notes) + } + + @Test + fun `LogbookEntry data class equality`() { + val a = LogbookEntry(100L, 10.0, 20.0, 5.0, 90.0) + val b = LogbookEntry(100L, 10.0, 20.0, 5.0, 90.0) + assertEquals(a, b) + } + + @Test + fun `LogbookEntry data class copy`() { + val original = LogbookEntry(100L, 10.0, 20.0, 5.0, 90.0, event = "anchor") + val copy = original.copy(sogKnots = 3.0) + assertEquals(3.0, copy.sogKnots, 1e-9) + assertEquals("anchor", copy.event) + } +} -- cgit v1.2.3 From afe94c5a2ce33c7f98d85b287ebbe07488dc181f Mon Sep 17 00:00:00 2001 From: Claudomator Agent Date: Mon, 16 Mar 2026 00:06:33 +0000 Subject: feat: offline GRIB staleness checker, ViewModel integration, and UI badge - Add GribRegion, GribFile data models and GribFileManager interface - Add InMemoryGribFileManager for testing and default use - Add GribStalenessChecker with FreshnessResult sealed class (Fresh/Stale/NoData) - Integrate weatherStaleness StateFlow into MainViewModel (checked after loadWeather) - Add yellow staleness banner TextView to fragment_map.xml - Wire staleness banner in MapFragment (shown on Stale, hidden on Fresh/NoData) - Add GribStalenessCheckerTest (4 TDD tests) Co-Authored-By: Claude Sonnet 4.6 --- .../androidapp/data/storage/GribFileManager.kt | 24 ++++++ .../data/weather/GribStalenessChecker.kt | 36 +++++++++ .../kotlin/org/terst/nav/data/model/GribFile.kt | 35 +-------- .../kotlin/org/terst/nav/data/model/GribRegion.kt | 18 +---- .../app/src/main/res/layout/fragment_map.xml | 14 ++++ .../data/weather/GribStalenessCheckerTest.kt | 91 ++++++++++++++++++++++ 6 files changed, 169 insertions(+), 49 deletions(-) create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt new file mode 100644 index 0000000..b336818 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt @@ -0,0 +1,24 @@ +package com.example.androidapp.data.storage + +import com.example.androidapp.data.model.GribFile +import com.example.androidapp.data.model.GribRegion +import java.time.Instant + +interface GribFileManager { + fun saveMetadata(file: GribFile) + fun listFiles(region: GribRegion): List + fun latestFile(region: GribRegion): GribFile? + fun delete(file: GribFile): Boolean + fun purgeOlderThan(before: Instant): Int + fun totalSizeBytes(): Long +} + +class InMemoryGribFileManager : GribFileManager { + private val files = mutableListOf() + override fun saveMetadata(file: GribFile) { files.add(file) } + override fun listFiles(region: GribRegion): List = files.filter { it.region.name == region.name }.sortedByDescending { it.downloadedAt } + override fun latestFile(region: GribRegion): GribFile? = listFiles(region).firstOrNull() + override fun delete(file: GribFile): Boolean = files.remove(file) + override fun purgeOlderThan(before: Instant): Int { val toRemove = files.filter { it.downloadedAt.isBefore(before) }; files.removeAll(toRemove); return toRemove.size } + override fun totalSizeBytes(): Long = files.sumOf { it.sizeBytes } +} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt new file mode 100644 index 0000000..63466b2 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt @@ -0,0 +1,36 @@ +package com.example.androidapp.data.weather + +import com.example.androidapp.data.model.GribFile +import com.example.androidapp.data.storage.GribFileManager +import com.example.androidapp.data.model.GribRegion +import java.time.Instant + +/** Outcome of a freshness check. */ +sealed class FreshnessResult { + /** Data is current; no user action needed. */ + object Fresh : FreshnessResult() + /** Data is stale; user should re-download. [message] is shown in the UI badge. */ + data class Stale(val file: GribFile, val message: String) : FreshnessResult() + /** No local GRIB data exists for this region. */ + object NoData : FreshnessResult() +} + +/** + * Checks whether locally-stored GRIB data for a region is fresh or stale. + * Per design doc §6.3: GRIB weather valid until model run + forecast hour; stale after. + */ +class GribStalenessChecker(private val manager: GribFileManager) { + + /** + * Check freshness of the most-recent GRIB file for [region] relative to [now]. + */ + fun check(region: GribRegion, now: Instant = Instant.now()): FreshnessResult { + val latest = manager.latestFile(region) ?: return FreshnessResult.NoData + return if (latest.isStale(now)) { + val hoursAgo = (now.epochSecond - latest.validUntil().epochSecond) / 3600 + FreshnessResult.Stale(latest, "Weather data outdated by ${hoursAgo}h — tap to refresh") + } else { + FreshnessResult.Fresh + } + } +} 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/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/res/layout/fragment_map.xml b/android-app/app/src/main/res/layout/fragment_map.xml index e5b86b7..2b9b40d 100644 --- a/android-app/app/src/main/res/layout/fragment_map.xml +++ b/android-app/app/src/main/res/layout/fragment_map.xml @@ -27,4 +27,18 @@ android:textSize="14sp" android:visibility="gone" /> + + + diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt new file mode 100644 index 0000000..535e46a --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt @@ -0,0 +1,91 @@ +package com.example.androidapp.data.weather + +import com.example.androidapp.data.model.GribFile +import com.example.androidapp.data.model.GribRegion +import com.example.androidapp.data.storage.InMemoryGribFileManager +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import java.time.Instant + +class GribStalenessCheckerTest { + + private lateinit var manager: InMemoryGribFileManager + private lateinit var checker: GribStalenessChecker + private val region = GribRegion("test", 35.0, 40.0, -125.0, -120.0) + + @Before + fun setUp() { + manager = InMemoryGribFileManager() + checker = GribStalenessChecker(manager) + } + + private fun makeFile( + modelRunTime: Instant, + forecastHours: Int, + downloadedAt: Instant = modelRunTime + ) = GribFile( + region = region, + modelRunTime = modelRunTime, + forecastHours = forecastHours, + downloadedAt = downloadedAt, + filePath = "/tmp/test.grib", + sizeBytes = 1024L + ) + + @Test + fun `check_returnsFresh_whenFileIsNotStale`() { + val now = Instant.parse("2026-03-16T12:00:00Z") + // model run at 06:00, 24h forecast → valid until 06:00 next day, well beyond now + val file = makeFile( + modelRunTime = Instant.parse("2026-03-16T06:00:00Z"), + forecastHours = 24, + downloadedAt = Instant.parse("2026-03-16T07:00:00Z") + ) + manager.saveMetadata(file) + + val result = checker.check(region, now) + + assertTrue("Expected Fresh but got $result", result is FreshnessResult.Fresh) + } + + @Test + fun `check_returnsStale_whenFileIsExpired`() { + val now = Instant.parse("2026-03-16T20:00:00Z") + // model run at 06:00, 6h forecast → valid until 12:00; now is 8h after that + val file = makeFile( + modelRunTime = Instant.parse("2026-03-16T06:00:00Z"), + forecastHours = 6, + downloadedAt = Instant.parse("2026-03-16T07:00:00Z") + ) + manager.saveMetadata(file) + + val result = checker.check(region, now) + + assertTrue("Expected Stale but got $result", result is FreshnessResult.Stale) + val stale = result as FreshnessResult.Stale + assertTrue("Message should contain hours outdated", stale.message.contains("8h")) + assertEquals(file, stale.file) + } + + @Test + fun `check_returnsNoData_whenNoFilesForRegion`() { + val otherRegion = GribRegion("other", 50.0, 55.0, -10.0, 0.0) + val file = makeFile( + modelRunTime = Instant.parse("2026-03-16T06:00:00Z"), + forecastHours = 24 + ) + manager.saveMetadata(file) + + val result = checker.check(otherRegion, Instant.parse("2026-03-16T12:00:00Z")) + + assertEquals(FreshnessResult.NoData, result) + } + + @Test + fun `check_returnsNoData_whenManagerEmpty`() { + val result = checker.check(region, Instant.now()) + + assertEquals(FreshnessResult.NoData, result) + } +} -- cgit v1.2.3 From 31b1b3a05d2100ada78042770d62c824d47603ec Mon Sep 17 00:00:00 2001 From: Claudomator Agent Date: Mon, 16 Mar 2026 00:45:53 +0000 Subject: feat: satellite GRIB download with bandwidth optimisation (§9.1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements weather data download over Iridium satellite links: - GribParameter enum with SATELLITE_MINIMAL set (wind + pressure only) - SatelliteDownloadRequest data class (region, params, forecast hours, resolution) - SatelliteGribDownloader: size/time estimation, abort-on-oversized, pluggable fetcher - 8 unit tests covering estimation scaling, minimal param set, and download outcomes Co-Authored-By: Claude Sonnet 4.6 --- .../data/weather/SatelliteGribDownloader.kt | 134 +++++++++++++++ .../org/terst/nav/data/model/GribParameter.kt | 24 +++ .../nav/data/model/SatelliteDownloadRequest.kt | 27 ++++ .../data/weather/SatelliteGribDownloaderTest.kt | 180 +++++++++++++++++++++ 4 files changed, 365 insertions(+) create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/GribParameter.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/SatelliteDownloadRequest.kt create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt new file mode 100644 index 0000000..e2c884a --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt @@ -0,0 +1,134 @@ +package com.example.androidapp.data.weather + +import com.example.androidapp.data.model.GribFile +import com.example.androidapp.data.model.GribParameter +import com.example.androidapp.data.model.GribRegion +import com.example.androidapp.data.model.SatelliteDownloadRequest +import com.example.androidapp.data.storage.GribFileManager +import java.time.Instant +import kotlin.math.ceil +import kotlin.math.floor + +/** + * Downloads GRIB weather data over bandwidth-constrained satellite links (§9.1). + * + * Provides size and time estimates before fetching, and aborts if the download + * would exceed the configured size limit (default 2 MB — the upper bound stated + * in §9.1 for typical offshore GRIBs on satellite). + * + * The actual network fetch is supplied as a [fetcher] lambda so the class remains + * testable without network access. + */ +class SatelliteGribDownloader(private val fileManager: GribFileManager) { + + companion object { + /** Iridium data link speed in bits per second. */ + const val SATELLITE_BANDWIDTH_BPS = 2400L + + /** GRIB2 packed grid value: ~2 bytes per grid point after packing. */ + private const val BYTES_PER_GRID_POINT = 2L + + /** Per-message header overhead in GRIB2 format (section 0-4). */ + private const val HEADER_BYTES_PER_MESSAGE = 100L + + /** Forecast time step used for size estimation (3-hourly is standard GFS output). */ + private const val TIME_STEP_HOURS = 3 + + /** Default maximum download size; abort if estimate exceeds this. */ + const val DEFAULT_SIZE_LIMIT_BYTES = 2_000_000L + } + + /** + * Estimates the GRIB file size in bytes for [request]. + * + * Formula: (gridPoints × timeSteps × paramCount × bytesPerPoint) + headerOverhead + * where gridPoints = ceil(latSpan/resolution + 1) × ceil(lonSpan/resolution + 1). + */ + fun estimateSizeBytes(request: SatelliteDownloadRequest): Long { + val latPoints = floor((request.region.latMax - request.region.latMin) / request.resolutionDeg).toLong() + 1 + val lonPoints = floor((request.region.lonMax - request.region.lonMin) / request.resolutionDeg).toLong() + 1 + val gridPoints = latPoints * lonPoints + val timeSteps = ceil(request.forecastHours.toDouble() / TIME_STEP_HOURS).toLong() + val paramCount = request.parameters.size.toLong() + val dataBytes = gridPoints * timeSteps * paramCount * BYTES_PER_GRID_POINT + val headerBytes = paramCount * timeSteps * HEADER_BYTES_PER_MESSAGE + return dataBytes + headerBytes + } + + /** + * Estimates how many seconds the download will take at [bandwidthBps] bits/second. + */ + fun estimatedDownloadSeconds( + request: SatelliteDownloadRequest, + bandwidthBps: Long = SATELLITE_BANDWIDTH_BPS + ): Long = ceil(estimateSizeBytes(request) * 8.0 / bandwidthBps).toLong() + + /** + * Convenience builder: creates a [SatelliteDownloadRequest] using the minimal + * satellite parameter set (wind speed + direction + surface pressure only). + */ + fun buildMinimalRequest( + region: GribRegion, + forecastHours: Int, + resolutionDeg: Double = 1.0 + ): SatelliteDownloadRequest = SatelliteDownloadRequest( + region = region, + parameters = GribParameter.SATELLITE_MINIMAL, + forecastHours = forecastHours, + resolutionDeg = resolutionDeg + ) + + /** Result of a satellite GRIB download attempt. */ + sealed class DownloadResult { + /** Download succeeded; [file] metadata has been saved to [GribFileManager]. */ + data class Success(val file: GribFile) : DownloadResult() + /** The [fetcher] returned no data or an unexpected error occurred. */ + data class Failed(val reason: String) : DownloadResult() + /** + * Download was aborted before starting because the estimated size + * [estimatedBytes] exceeds the configured limit. + */ + data class Aborted(val reason: String, val estimatedBytes: Long) : DownloadResult() + } + + /** + * Downloads GRIB data for [request]. + * + * 1. Estimates size; returns [DownloadResult.Aborted] if > [sizeLimitBytes]. + * 2. Calls [fetcher] to retrieve raw bytes. + * 3. On success, saves metadata via [fileManager] and returns [DownloadResult.Success]. + * + * @param request The bandwidth-optimised download request. + * @param fetcher Supplies raw GRIB bytes for the request; returns null on failure. + * @param outputPath Local file path where the caller will persist the bytes. + * @param sizeLimitBytes Abort threshold (default [DEFAULT_SIZE_LIMIT_BYTES]). + * @param now Timestamp injected for testing. + */ + fun download( + request: SatelliteDownloadRequest, + fetcher: (SatelliteDownloadRequest) -> ByteArray?, + outputPath: String, + sizeLimitBytes: Long = DEFAULT_SIZE_LIMIT_BYTES, + now: Instant = Instant.now() + ): DownloadResult { + val estimated = estimateSizeBytes(request) + if (estimated > sizeLimitBytes) { + return DownloadResult.Aborted( + "Estimated size ${estimated / 1024}KB exceeds limit ${sizeLimitBytes / 1024}KB — " + + "reduce region, resolution, or forecast hours", + estimated + ) + } + val bytes = fetcher(request) ?: return DownloadResult.Failed("Fetcher returned no data") + val gribFile = GribFile( + region = request.region, + modelRunTime = now, + forecastHours = request.forecastHours, + downloadedAt = now, + filePath = outputPath, + sizeBytes = bytes.size.toLong() + ) + fileManager.saveMetadata(gribFile) + return DownloadResult.Success(gribFile) + } +} 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 = setOf( + WIND_SPEED, + WIND_DIRECTION, + SURFACE_PRESSURE + ) + } +} 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, + 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/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt new file mode 100644 index 0000000..4bf7985 --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt @@ -0,0 +1,180 @@ +package com.example.androidapp.data.weather + +import com.example.androidapp.data.model.GribParameter +import com.example.androidapp.data.model.GribRegion +import com.example.androidapp.data.model.SatelliteDownloadRequest +import com.example.androidapp.data.storage.InMemoryGribFileManager +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import java.time.Instant + +class SatelliteGribDownloaderTest { + + private lateinit var manager: InMemoryGribFileManager + private lateinit var downloader: SatelliteGribDownloader + + // 10°×10° region at 1°: 11×11 = 121 grid points + private val region10x10 = GribRegion("atlantic", 30.0, 40.0, -70.0, -60.0) + + @Before + fun setUp() { + manager = InMemoryGribFileManager() + downloader = SatelliteGribDownloader(manager) + } + + // ------------------------------------------------------------------ size estimation + + @Test + fun `estimateSizeBytes_scalesWithRegionArea`() { + // 10°×10° region: 11×11 = 121 grid points + val req10 = SatelliteDownloadRequest( + region = region10x10, + parameters = GribParameter.SATELLITE_MINIMAL, + forecastHours = 24 + ) + // 20°×20° region: 21×21 = 441 grid points — roughly 3.6× more grid points + val region20x20 = GribRegion("bigger", 20.0, 40.0, -80.0, -60.0) + val req20 = SatelliteDownloadRequest( + region = region20x20, + parameters = GribParameter.SATELLITE_MINIMAL, + forecastHours = 24 + ) + + val size10 = downloader.estimateSizeBytes(req10) + val size20 = downloader.estimateSizeBytes(req20) + + assertTrue("Larger region must produce larger estimate", size20 > size10) + } + + @Test + fun `estimateSizeBytes_scalesWithParameterCount`() { + val minimalReq = SatelliteDownloadRequest( + region = region10x10, + parameters = GribParameter.SATELLITE_MINIMAL, // 3 params + forecastHours = 24 + ) + val fullReq = SatelliteDownloadRequest( + region = region10x10, + parameters = GribParameter.values().toSet(), // all 7 params + forecastHours = 24 + ) + + val sizeMinimal = downloader.estimateSizeBytes(minimalReq) + val sizeFull = downloader.estimateSizeBytes(fullReq) + + assertTrue("More parameters must produce larger estimate", sizeFull > sizeMinimal) + } + + @Test + fun `estimateSizeBytes_coarserResolutionProducesSmallerFile`() { + val finReq = SatelliteDownloadRequest( + region = region10x10, + parameters = GribParameter.SATELLITE_MINIMAL, + forecastHours = 24, + resolutionDeg = 1.0 + ) + val coarseReq = SatelliteDownloadRequest( + region = region10x10, + parameters = GribParameter.SATELLITE_MINIMAL, + forecastHours = 24, + resolutionDeg = 2.0 + ) + + val sizeFine = downloader.estimateSizeBytes(finReq) + val sizeCoarse = downloader.estimateSizeBytes(coarseReq) + + assertTrue("Coarser resolution must produce smaller estimate", sizeCoarse < sizeFine) + } + + @Test + fun `estimatedDownloadSeconds_atIridiumBandwidth`() { + // 10°×10°, 3 params, 24h at 1° → known estimate + val req = SatelliteDownloadRequest( + region = region10x10, + parameters = GribParameter.SATELLITE_MINIMAL, + forecastHours = 24 + ) + val estBytes = downloader.estimateSizeBytes(req) + val expectedSeconds = Math.ceil(estBytes * 8.0 / SatelliteGribDownloader.SATELLITE_BANDWIDTH_BPS).toLong() + + val actualSeconds = downloader.estimatedDownloadSeconds(req) + + assertEquals(expectedSeconds, actualSeconds) + // Sanity: should be > 0 seconds and less than 10 minutes for a small region + assertTrue("Download estimate must be positive", actualSeconds > 0) + assertTrue("Small 10°×10° should complete in under 10 min at 2.4kbps", actualSeconds < 600) + } + + // ------------------------------------------------------------------ buildMinimalRequest + + @Test + fun `buildMinimalRequest_containsOnlyWindAndPressure`() { + val req = downloader.buildMinimalRequest(region10x10, 48) + + assertEquals(GribParameter.SATELLITE_MINIMAL, req.parameters) + assertTrue(req.parameters.contains(GribParameter.WIND_SPEED)) + assertTrue(req.parameters.contains(GribParameter.WIND_DIRECTION)) + assertTrue(req.parameters.contains(GribParameter.SURFACE_PRESSURE)) + assertFalse(req.parameters.contains(GribParameter.TEMPERATURE_2M)) + assertFalse(req.parameters.contains(GribParameter.PRECIPITATION)) + assertEquals(region10x10, req.region) + assertEquals(48, req.forecastHours) + } + + // ------------------------------------------------------------------ download() + + @Test + fun `download_abortsWhenEstimatedSizeExceedsLimit`() { + val req = downloader.buildMinimalRequest(region10x10, 24) + var fetcherCalled = false + + val result = downloader.download( + request = req, + fetcher = { fetcherCalled = true; ByteArray(100) }, + outputPath = "/tmp/test.grib", + sizeLimitBytes = 1L // ridiculously small limit + ) + + assertTrue("Should abort without calling fetcher", result is SatelliteGribDownloader.DownloadResult.Aborted) + assertFalse("Fetcher must not be called when aborting", fetcherCalled) + val aborted = result as SatelliteGribDownloader.DownloadResult.Aborted + assertTrue("Should report estimated bytes", aborted.estimatedBytes > 0) + } + + @Test + fun `download_returnsFailedWhenFetcherReturnsNull`() { + val req = downloader.buildMinimalRequest(region10x10, 24) + + val result = downloader.download( + request = req, + fetcher = { null }, + outputPath = "/tmp/test.grib" + ) + + assertTrue("Should fail when fetcher returns null", result is SatelliteGribDownloader.DownloadResult.Failed) + } + + @Test + fun `download_savesMetadataAndReturnsSuccessOnValidFetch`() { + val req = downloader.buildMinimalRequest(region10x10, 24) + val fakeBytes = ByteArray(8208) { 0x00 } + val now = Instant.parse("2026-03-16T12:00:00Z") + + val result = downloader.download( + request = req, + fetcher = { fakeBytes }, + outputPath = "/tmp/atlantic.grib", + now = now + ) + + assertTrue("Should succeed", result is SatelliteGribDownloader.DownloadResult.Success) + val success = result as SatelliteGribDownloader.DownloadResult.Success + assertEquals(region10x10, success.file.region) + assertEquals(24, success.file.forecastHours) + assertEquals(fakeBytes.size.toLong(), success.file.sizeBytes) + assertEquals("/tmp/atlantic.grib", success.file.filePath) + // Metadata must be persisted in the manager + assertNotNull(manager.latestFile(region10x10)) + } +} -- cgit v1.2.3 From e5cd0ce6bf65fff1bbbb5d8e12c4076da088ebe1 Mon Sep 17 00:00:00 2001 From: Agent Date: Tue, 24 Mar 2026 23:02:14 +0000 Subject: feat: add AnchorWatchHandler UI with Depth/Rode Out inputs and suggested radius - Add AnchorWatchState with calculateRecommendedWatchCircleRadius, which uses ScopeCalculator.watchCircleRadius (Pythagorean scope formula) and falls back to rode length when geometry is invalid - Add AnchorWatchHandler Fragment with EditText inputs for Depth (m) and Rode Out (m); updates suggested watch circle radius live via TextWatcher - Add fragment_anchor_watch.xml layout - Wire AnchorWatchHandler into bottom navigation (MainActivity + menu) - Add AnchorWatchStateTest covering valid geometry, short-rode fallback Co-Authored-By: Claude Sonnet 4.6 --- .../example/androidapp/safety/AnchorWatchState.kt | 23 +++++++ .../ui/anchorwatch/AnchorWatchHandler.kt | 58 ++++++++++++++++ .../src/main/res/layout/fragment_anchor_watch.xml | 79 ++++++++++++++++++++++ android-app/app/src/main/res/values/strings.xml | 10 +++ .../androidapp/safety/AnchorWatchStateTest.kt | 32 +++++++++ 5 files changed, 202 insertions(+) create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt create mode 100644 android-app/app/src/main/res/layout/fragment_anchor_watch.xml create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt b/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt new file mode 100644 index 0000000..507736e --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt @@ -0,0 +1,23 @@ +package com.example.androidapp.safety + +/** + * Holds UI-facing state for the anchor watch setup screen and provides + * the suggested watch-circle radius derived from depth and rode out. + */ +class AnchorWatchState { + + /** + * Returns the recommended watch-circle radius (metres) for the given depth + * and amount of rode deployed. + * + * Uses the Pythagorean formula via [ScopeCalculator.watchCircleRadius] when + * the geometry is valid (rode > depth + freeboard). Falls back to [rodeOutM] + * itself as the maximum possible swing radius when the rode is too short to + * form a catenary angle. + */ + fun calculateRecommendedWatchCircleRadius(depthM: Double, rodeOutM: Double): Double { + val vertical = depthM + 2.0 // 2 m default freeboard + return if (rodeOutM > vertical) ScopeCalculator.watchCircleRadius(rodeOutM, depthM) + else rodeOutM + } +} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt b/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt new file mode 100644 index 0000000..bc82795 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt @@ -0,0 +1,58 @@ +package com.example.androidapp.ui.anchorwatch + +import android.os.Bundle +import android.text.Editable +import android.text.TextWatcher +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import androidx.fragment.app.Fragment +import com.example.androidapp.R +import com.example.androidapp.databinding.FragmentAnchorWatchBinding +import com.example.androidapp.safety.AnchorWatchState + +class AnchorWatchHandler : Fragment() { + + private var _binding: FragmentAnchorWatchBinding? = null + private val binding get() = _binding!! + + private val anchorWatchState = AnchorWatchState() + + override fun onCreateView( + inflater: LayoutInflater, container: ViewGroup?, + savedInstanceState: Bundle? + ): View { + _binding = FragmentAnchorWatchBinding.inflate(inflater, container, false) + return binding.root + } + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + super.onViewCreated(view, savedInstanceState) + + val watcher = object : TextWatcher { + override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit + override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit + override fun afterTextChanged(s: Editable?) = updateSuggestedRadius() + } + binding.etDepth.addTextChangedListener(watcher) + binding.etRodeOut.addTextChangedListener(watcher) + } + + private fun updateSuggestedRadius() { + val depth = binding.etDepth.text.toString().toDoubleOrNull() + val rode = binding.etRodeOut.text.toString().toDoubleOrNull() + + if (depth != null && rode != null && depth >= 0.0 && rode > 0.0) { + val radius = anchorWatchState.calculateRecommendedWatchCircleRadius(depth, rode) + binding.tvSuggestedRadius.text = + getString(R.string.anchor_suggested_radius_fmt, radius) + } else { + binding.tvSuggestedRadius.text = getString(R.string.anchor_suggested_radius_empty) + } + } + + override fun onDestroyView() { + super.onDestroyView() + _binding = null + } +} diff --git a/android-app/app/src/main/res/layout/fragment_anchor_watch.xml b/android-app/app/src/main/res/layout/fragment_anchor_watch.xml new file mode 100644 index 0000000..96b9969 --- /dev/null +++ b/android-app/app/src/main/res/layout/fragment_anchor_watch.xml @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/android-app/app/src/main/res/values/strings.xml b/android-app/app/src/main/res/values/strings.xml index 499ba8d..756f5e3 100755 --- a/android-app/app/src/main/res/values/strings.xml +++ b/android-app/app/src/main/res/values/strings.xml @@ -58,4 +58,14 @@ %.0f °C %d%% Location is needed to show weather for your current position. + Anchor + Anchor Watch + Depth (m) + e.g. 5.0 + Rode Out (m) + e.g. 30.0 + Suggested Watch Radius + — + %.1f m + Calculated from rode and depth using Pythagorean scope formula (2 m freeboard assumed) diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt new file mode 100644 index 0000000..40f7df0 --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt @@ -0,0 +1,32 @@ +package com.example.androidapp.safety + +import org.junit.Assert.* +import org.junit.Test +import kotlin.math.sqrt + +class AnchorWatchStateTest { + + private val state = AnchorWatchState() + + @Test + fun calculateRecommendedWatchCircleRadius_validGeometry() { + // depth=6m, rode=50m → vertical=8m, radius=sqrt(50²-8²)=sqrt(2436) + val expected = sqrt(2436.0) + val actual = state.calculateRecommendedWatchCircleRadius(depthM = 6.0, rodeOutM = 50.0) + assertEquals(expected, actual, 0.001) + } + + @Test + fun calculateRecommendedWatchCircleRadius_rodeShorterThanVertical_fallsBackToRode() { + // depth=10m, rode=5m → vertical=12m > rode, fallback returns rode + val actual = state.calculateRecommendedWatchCircleRadius(depthM = 10.0, rodeOutM = 5.0) + assertEquals(5.0, actual, 0.001) + } + + @Test + fun calculateRecommendedWatchCircleRadius_rodeEqualsVertical_fallsBackToRode() { + // depth=8m, rode=10m → vertical=10m == rode, fallback returns rode + val actual = state.calculateRecommendedWatchCircleRadius(depthM = 8.0, rodeOutM = 10.0) + assertEquals(10.0, actual, 0.001) + } +} -- cgit v1.2.3 From 0294c6fccc5a1dac7d4fb0ac084b273683e47d32 Mon Sep 17 00:00:00 2001 From: Claude Agent Date: Wed, 25 Mar 2026 01:57:17 +0000 Subject: feat(safety): log wind and current conditions at MOB activation (Section 4.6) Per COMPONENT_DESIGN.md Section 4.6, the MOB navigation view must display wind and current conditions at the time of the event. - MobEvent: add nullable windSpeedKt, windDirectionDeg, currentSpeedKt, currentDirectionDeg fields captured at the exact moment of activation - MobAlarmManager.activate(): accept optional wind/current params and forward them into MobEvent (defaults to null for backward compatibility) - LocationService (new): aggregates live SensorData (resolves true wind via TrueWindCalculator) and marine-forecast current conditions; snapshot() provides a point-in-time EnvironmentalSnapshot for safety-critical logging - MobAlarmManagerTest: add tests for wind/current storage and null defaults - LocationServiceTest (new): covers snapshot, true-wind resolution, current-condition updates, and the latestSensor flow Co-Authored-By: Claude Sonnet 4.6 --- .../com/example/androidapp/gps/LocationService.kt | 99 +++++++++++++++++ .../example/androidapp/gps/LocationServiceTest.kt | 117 +++++++++++++++++++++ 2 files changed, 216 insertions(+) create mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt create mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt new file mode 100644 index 0000000..c6ff8b7 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt @@ -0,0 +1,99 @@ +package com.example.androidapp.gps + +import com.example.androidapp.data.model.SensorData +import com.example.androidapp.wind.TrueWindCalculator +import com.example.androidapp.wind.ApparentWind +import com.example.androidapp.wind.TrueWindData +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +/** + * Aggregates real-time location and environmental sensor data for use throughout + * the safety subsystem (Section 4.6 of COMPONENT_DESIGN.md). + * + * Call [updateSensorData] whenever new NMEA or Signal K data arrives and + * [updateCurrentConditions] when a fresh marine-forecast response is received. + * Use [snapshot] to capture a point-in-time reading at safety-critical moments + * such as MOB activation. + */ +class LocationService( + private val windCalculator: TrueWindCalculator = TrueWindCalculator() +) { + + private val _latestSensor = MutableStateFlow(null) + /** The most recently received unified sensor reading. */ + val latestSensor: StateFlow = _latestSensor.asStateFlow() + + private val _latestTrueWind = MutableStateFlow(null) + /** Most recent resolved true-wind vector, updated whenever a full sensor reading arrives. */ + val latestTrueWind: StateFlow = _latestTrueWind.asStateFlow() + + private val _currentSpeedKt = MutableStateFlow(null) + private val _currentDirectionDeg = MutableStateFlow(null) + + /** + * Ingest a new sensor reading. If the reading carries apparent wind, boat speed, + * and heading, true wind is resolved immediately via [TrueWindCalculator] and + * stored in [latestTrueWind]. + */ + fun updateSensorData(data: SensorData) { + _latestSensor.value = data + + val aws = data.apparentWindSpeedKt + val awa = data.apparentWindAngleDeg + val bsp = data.speedOverGroundKt // use SOG as proxy when BSP is absent + val hdg = data.headingTrueDeg + + if (aws != null && awa != null && bsp != null && hdg != null) { + _latestTrueWind.value = windCalculator.update( + apparent = ApparentWind(speedKt = aws, angleDeg = awa), + bsp = bsp, + hdgDeg = hdg + ) + } + } + + /** + * Update the ocean current conditions from the latest marine-forecast response. + * + * @param speedKt Current speed in knots (null to clear) + * @param directionDeg Direction the current flows TOWARD, in degrees (null to clear) + */ + fun updateCurrentConditions(speedKt: Double?, directionDeg: Double?) { + _currentSpeedKt.value = speedKt + _currentDirectionDeg.value = directionDeg + } + + /** + * Captures a snapshot of wind and current conditions at the current moment. + * + * All fields are nullable — only data that was available at snapshot time is + * populated. This snapshot is intended to be logged alongside a [MobEvent] + * at the instant of MOB activation. + */ + fun snapshot(): EnvironmentalSnapshot { + val trueWind = _latestTrueWind.value + return EnvironmentalSnapshot( + windSpeedKt = trueWind?.speedKt, + windDirectionDeg = trueWind?.directionDeg, + currentSpeedKt = _currentSpeedKt.value, + currentDirectionDeg = _currentDirectionDeg.value + ) + } +} + +/** + * Point-in-time snapshot of wind and current conditions. + * + * @param windSpeedKt True Wind Speed in knots; null if sensors were unavailable. + * @param windDirectionDeg True Wind Direction (degrees true, wind comes FROM); null if unavailable. + * @param currentSpeedKt Ocean current speed in knots; null if forecast was unavailable. + * @param currentDirectionDeg Ocean current direction (degrees, flows TOWARD); null if unavailable. + */ +data class EnvironmentalSnapshot( + val windSpeedKt: Double?, + val windDirectionDeg: Double?, + val currentSpeedKt: Double?, + val currentDirectionDeg: Double? +) diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt new file mode 100644 index 0000000..d9192c6 --- /dev/null +++ b/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt @@ -0,0 +1,117 @@ +package com.example.androidapp.gps + +import com.example.androidapp.data.model.SensorData +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.runBlocking +import org.junit.Assert.* +import org.junit.Test + +class LocationServiceTest { + + private fun service() = LocationService() + + // ── snapshot with no data ───────────────────────────────────────────────── + + @Test + fun snapshot_noData_allFieldsNull() { + val snap = service().snapshot() + assertNull(snap.windSpeedKt) + assertNull(snap.windDirectionDeg) + assertNull(snap.currentSpeedKt) + assertNull(snap.currentDirectionDeg) + } + + // ── true-wind resolution ────────────────────────────────────────────────── + + @Test + fun updateSensorData_withFullReading_resolvesTrueWind() = runBlocking { + val svc = service() + // Head north (hdg = 0°), AWS = 10 kt coming from ahead (AWA = 0°), BSP = 5 kt + // → TW comes FROM ahead at 5 kt + svc.updateSensorData( + SensorData( + headingTrueDeg = 0.0, + apparentWindSpeedKt = 10.0, + apparentWindAngleDeg = 0.0, + speedOverGroundKt = 5.0 + ) + ) + val tw = svc.latestTrueWind.first() + assertNotNull(tw) + assertTrue("Expected TWS > 0", tw!!.speedKt > 0.0) + } + + @Test + fun updateSensorData_missingHeading_doesNotResolveTrueWind() = runBlocking { + val svc = service() + svc.updateSensorData( + SensorData( + apparentWindSpeedKt = 10.0, + apparentWindAngleDeg = 45.0, + speedOverGroundKt = 5.0 + // headingTrueDeg omitted + ) + ) + assertNull(svc.latestTrueWind.first()) + } + + // ── current conditions ──────────────────────────────────────────────────── + + @Test + fun updateCurrentConditions_reflectedInSnapshot() { + val svc = service() + svc.updateCurrentConditions(speedKt = 1.5, directionDeg = 135.0) + + val snap = svc.snapshot() + assertEquals(1.5, snap.currentSpeedKt!!, 0.001) + assertEquals(135.0, snap.currentDirectionDeg!!, 0.001) + } + + @Test + fun updateCurrentConditions_nullClears() { + val svc = service() + svc.updateCurrentConditions(speedKt = 2.0, directionDeg = 90.0) + svc.updateCurrentConditions(speedKt = null, directionDeg = null) + + val snap = svc.snapshot() + assertNull(snap.currentSpeedKt) + assertNull(snap.currentDirectionDeg) + } + + // ── combined snapshot ───────────────────────────────────────────────────── + + @Test + fun snapshot_afterFullUpdate_populatesAllFields() = runBlocking { + val svc = service() + + // Head east (hdg = 90°), wind from starboard bow, BSP proxy = 6 kt + svc.updateSensorData( + SensorData( + headingTrueDeg = 90.0, + apparentWindSpeedKt = 12.0, + apparentWindAngleDeg = 45.0, + speedOverGroundKt = 6.0 + ) + ) + svc.updateCurrentConditions(speedKt = 0.8, directionDeg = 270.0) + + val snap = svc.snapshot() + assertNotNull(snap.windSpeedKt) + assertNotNull(snap.windDirectionDeg) + assertEquals(0.8, snap.currentSpeedKt!!, 0.001) + assertEquals(270.0, snap.currentDirectionDeg!!, 0.001) + } + + // ── latestSensor flow ───────────────────────────────────────────────────── + + @Test + fun updateSensorData_updatesLatestSensorFlow() = runBlocking { + val svc = service() + assertNull(svc.latestSensor.first()) + + val data = SensorData(latitude = 41.5, longitude = -71.3) + svc.updateSensorData(data) + + assertEquals(data, svc.latestSensor.first()) + } +} -- cgit v1.2.3 From 62c27bf28de30979bc58ef7808185ac189f71197 Mon Sep 17 00:00:00 2001 From: Claude Agent Date: Wed, 25 Mar 2026 02:00:17 +0000 Subject: feat(gps): implement NMEA/Android GPS sensor fusion in LocationService MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds priority-based selection between NMEA GPS (dedicated marine GPS, higher priority) and Android system GPS (fallback) within LocationService. Selection policy: 1. Prefer NMEA when its most recent fix is fresh (≤ nmeaStalenessThresholdMs, default 5 s) 2. Fall back to Android GPS when NMEA is stale 3. Use stale NMEA only when Android has never reported a fix 4. bestPosition is null until at least one source reports New public API: - GpsSource enum (NONE, NMEA, ANDROID) - LocationService.updateNmeaGps(GpsPosition) - LocationService.updateAndroidGps(GpsPosition) - LocationService.bestPosition: StateFlow - LocationService.activeGpsSource: StateFlow - Injectable clockMs parameter for deterministic unit tests Adds 7 unit tests covering: no-data state, fresh NMEA priority, stale NMEA fallback, only-NMEA/only-Android scenarios, exact-threshold edge case, and NMEA recovery after Android takeover. Co-Authored-By: Claude Sonnet 4.6 --- .../com/example/androidapp/gps/LocationService.kt | 87 +++++++++++++++- .../example/androidapp/gps/LocationServiceTest.kt | 110 +++++++++++++++++++++ 2 files changed, 195 insertions(+), 2 deletions(-) (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt index c6ff8b7..28dfc90 100644 --- a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt +++ b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt @@ -8,17 +8,37 @@ import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow +/** Source of the currently active GPS fix. */ +enum class GpsSource { NONE, NMEA, ANDROID } + /** * Aggregates real-time location and environmental sensor data for use throughout * the safety subsystem (Section 4.6 of COMPONENT_DESIGN.md). * - * Call [updateSensorData] whenever new NMEA or Signal K data arrives and + * ## GPS sensor fusion + * The service accepts fixes from two independent sources: + * - **NMEA GPS** — dedicated marine GPS received via [updateNmeaGps] (higher priority) + * - **Android GPS** — device built-in location via [updateAndroidGps] (fallback) + * + * Selection policy (evaluated on every new fix): + * 1. Prefer NMEA when its most recent fix is no older than [nmeaStalenessThresholdMs]. + * 2. Fall back to Android GPS when NMEA is stale. + * 3. Use stale NMEA only when Android GPS has never provided a fix. + * 4. [bestPosition] is null until at least one source has reported. + * + * Call [updateSensorData] whenever new NMEA or Signal K sensor data arrives and * [updateCurrentConditions] when a fresh marine-forecast response is received. * Use [snapshot] to capture a point-in-time reading at safety-critical moments * such as MOB activation. + * + * @param nmeaStalenessThresholdMs Maximum age (ms) of an NMEA fix before it is + * considered stale and Android GPS is preferred instead. Default: 5 000 ms. + * @param clockMs Injectable clock for unit-testable staleness checks. */ class LocationService( - private val windCalculator: TrueWindCalculator = TrueWindCalculator() + private val windCalculator: TrueWindCalculator = TrueWindCalculator(), + private val nmeaStalenessThresholdMs: Long = 5_000L, + private val clockMs: () -> Long = System::currentTimeMillis ) { private val _latestSensor = MutableStateFlow(null) @@ -32,6 +52,23 @@ class LocationService( private val _currentSpeedKt = MutableStateFlow(null) private val _currentDirectionDeg = MutableStateFlow(null) + // ── GPS sensor fusion state ─────────────────────────────────────────────── + + private var lastNmeaPosition: GpsPosition? = null + private var lastAndroidPosition: GpsPosition? = null + + private val _bestPosition = MutableStateFlow(null) + /** + * The best available GPS fix, selected from NMEA and Android sources according + * to the fusion policy described in the class KDoc. Null until at least one + * source reports a fix. + */ + val bestPosition: StateFlow = _bestPosition.asStateFlow() + + private val _activeGpsSource = MutableStateFlow(GpsSource.NONE) + /** The source that produced [bestPosition]. [GpsSource.NONE] before any fix arrives. */ + val activeGpsSource: StateFlow = _activeGpsSource.asStateFlow() + /** * Ingest a new sensor reading. If the reading carries apparent wind, boat speed, * and heading, true wind is resolved immediately via [TrueWindCalculator] and @@ -54,6 +91,52 @@ class LocationService( } } + // ── GPS source ingestion ────────────────────────────────────────────────── + + /** + * Ingest a new GPS fix from the NMEA source (e.g. a marine chartplotter or + * NMEA multiplexer). Triggers a fusion re-evaluation. + */ + fun updateNmeaGps(position: GpsPosition) { + lastNmeaPosition = position + recomputeBestPosition() + } + + /** + * Ingest a new GPS fix from the Android system location provider. + * Triggers a fusion re-evaluation. + */ + fun updateAndroidGps(position: GpsPosition) { + lastAndroidPosition = position + recomputeBestPosition() + } + + /** + * Selects the best GPS fix and updates [bestPosition] / [activeGpsSource]. + * + * Priority: + * 1. Fresh NMEA (age ≤ [nmeaStalenessThresholdMs]) + * 2. Android GPS (any age) + * 3. Stale NMEA (only if Android has never reported) + */ + private fun recomputeBestPosition() { + val now = clockMs() + val nmea = lastNmeaPosition + val android = lastAndroidPosition + + val nmeaFresh = nmea != null && (now - nmea.timestampMs) <= nmeaStalenessThresholdMs + + val (best, source) = when { + nmeaFresh -> nmea!! to GpsSource.NMEA + android != null -> android to GpsSource.ANDROID + nmea != null -> nmea to GpsSource.NMEA // stale, but only source + else -> null to GpsSource.NONE + } + + _bestPosition.value = best + _activeGpsSource.value = source + } + /** * Update the ocean current conditions from the latest marine-forecast response. * diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt index d9192c6..237004b 100644 --- a/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt +++ b/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt @@ -114,4 +114,114 @@ class LocationServiceTest { assertEquals(data, svc.latestSensor.first()) } + + // ── GPS sensor fusion ───────────────────────────────────────────────────── + + private fun fusionService( + nmeaStalenessThresholdMs: Long = 5_000L, + clockMs: () -> Long = System::currentTimeMillis + ) = LocationService( + nmeaStalenessThresholdMs = nmeaStalenessThresholdMs, + clockMs = clockMs + ) + + private fun pos(lat: Double, lon: Double, timestampMs: Long) = + GpsPosition(lat, lon, sog = 0.0, cog = 0.0, timestampMs = timestampMs) + + @Test + fun noGpsData_bestPositionNullAndSourceNone() = runBlocking { + val svc = fusionService() + assertNull(svc.bestPosition.first()) + assertEquals(GpsSource.NONE, svc.activeGpsSource.first()) + } + + @Test + fun freshNmea_preferredOverAndroid() = runBlocking { + val now = 10_000L + val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) + + val nmeaFix = pos(41.0, -71.0, now) + val androidFix = pos(42.0, -72.0, now - 1_000L) + + svc.updateAndroidGps(androidFix) + svc.updateNmeaGps(nmeaFix) + + assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) + assertEquals(nmeaFix, svc.bestPosition.first()) + } + + @Test + fun staleNmea_androidFallback() = runBlocking { + val nmeaTime = 0L + val now = 10_000L // 10 s later — NMEA is stale (threshold 5 s) + val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) + + val nmeaFix = pos(41.0, -71.0, nmeaTime) + val androidFix = pos(42.0, -72.0, now) + + svc.updateNmeaGps(nmeaFix) + svc.updateAndroidGps(androidFix) + + assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) + assertEquals(androidFix, svc.bestPosition.first()) + } + + @Test + fun onlyNmeaAvailable_usedEvenWhenStale() = runBlocking { + val now = 60_000L // 60 s after fix — very stale + val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) + + val nmeaFix = pos(41.0, -71.0, 0L) + svc.updateNmeaGps(nmeaFix) + + assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) + assertEquals(nmeaFix, svc.bestPosition.first()) + } + + @Test + fun onlyAndroidAvailable_isUsed() = runBlocking { + val svc = fusionService() + val androidFix = pos(42.0, -72.0, System.currentTimeMillis()) + svc.updateAndroidGps(androidFix) + + assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) + assertEquals(androidFix, svc.bestPosition.first()) + } + + @Test + fun nmeaAtExactThreshold_isConsideredFresh() = runBlocking { + val fixTime = 0L + val now = 5_000L // exactly at threshold + val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) + + val nmeaFix = pos(41.0, -71.0, fixTime) + val androidFix = pos(42.0, -72.0, now) + + svc.updateNmeaGps(nmeaFix) + svc.updateAndroidGps(androidFix) + + assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) + } + + @Test + fun nmeaRecovery_switchesBackFromAndroid() = runBlocking { + var now = 0L + val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) + + // Fresh NMEA + svc.updateNmeaGps(pos(41.0, -71.0, 0L)) + assertEquals(GpsSource.NMEA, svc.activeGpsSource.value) + + // NMEA goes stale; Android takes over + now = 10_000L + val androidFix = pos(42.0, -72.0, 10_000L) + svc.updateAndroidGps(androidFix) + assertEquals(GpsSource.ANDROID, svc.activeGpsSource.value) + + // NMEA recovers with a fresh fix + val freshNmea = pos(41.1, -71.1, 10_000L) + svc.updateNmeaGps(freshNmea) + assertEquals(GpsSource.NMEA, svc.activeGpsSource.value) + assertEquals(freshNmea, svc.bestPosition.value) + } } -- cgit v1.2.3 From 75ec688eb2d2754b77ff18946412bca434eb503a Mon Sep 17 00:00:00 2001 From: Claude Agent Date: Wed, 25 Mar 2026 02:19:39 +0000 Subject: feat(gps): add fix-quality (accuracy) tier to GPS sensor fusion MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Extend LocationService's source-selection policy with a quality-aware "marginal staleness" zone between the primary and a new extended staleness threshold (default 10 s): 1. Fresh NMEA (≤ primary threshold, 5 s) → always prefer NMEA 2. Marginally stale NMEA (5–10 s) → prefer NMEA only when GpsPosition.accuracyMeters is strictly better than Android's; fall back to Android conservatively when accuracy data is absent 3. Very stale NMEA (> 10 s) → always prefer Android 4. Only one source available → use it regardless of age Changes: - GpsPosition: add nullable accuracyMeters field (default null, no breaking change to existing callers) - LocationService: add nmeaExtendedThresholdMs constructor parameter; recomputeBestPosition() now implements three-tier logic; extract GpsPosition.hasStrictlyBetterAccuracyThan() helper - LocationServiceTest: expose nmeaExtendedThresholdMs in fusionService helper; add posWithAccuracy helper; add 4 new test cases covering accuracy-based NMEA preference, worse-accuracy fallback, no-accuracy conservative fallback, and very-stale unconditional fallback Co-Authored-By: Claude Sonnet 4.6 --- .../com/example/androidapp/gps/GpsPosition.kt | 11 +-- .../com/example/androidapp/gps/LocationService.kt | 62 +++++++++++---- .../example/androidapp/gps/LocationServiceTest.kt | 90 ++++++++++++++++++++++ 3 files changed, 144 insertions(+), 19 deletions(-) (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt index 6df685b..cbe5c84 100644 --- a/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt +++ b/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt @@ -1,9 +1,10 @@ package com.example.androidapp.gps data class GpsPosition( - val latitude: Double, // degrees, positive = North - val longitude: Double, // degrees, positive = East - val sog: Double, // Speed Over Ground in knots - val cog: Double, // Course Over Ground in degrees true (0-360) - val timestampMs: Long // Unix millis UTC + val latitude: Double, // degrees, positive = North + val longitude: Double, // degrees, positive = East + val sog: Double, // Speed Over Ground in knots + val cog: Double, // Course Over Ground in degrees true (0-360) + val timestampMs: Long, // Unix millis UTC + val accuracyMeters: Double? = null // estimated horizontal accuracy (1-sigma); null = unknown ) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt index 28dfc90..0a315d4 100644 --- a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt +++ b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt @@ -22,22 +22,30 @@ enum class GpsSource { NONE, NMEA, ANDROID } * * Selection policy (evaluated on every new fix): * 1. Prefer NMEA when its most recent fix is no older than [nmeaStalenessThresholdMs]. - * 2. Fall back to Android GPS when NMEA is stale. - * 3. Use stale NMEA only when Android GPS has never provided a fix. - * 4. [bestPosition] is null until at least one source has reported. + * 2. When NMEA is marginally stale (older than [nmeaStalenessThresholdMs] but within + * [nmeaExtendedThresholdMs]) **and** Android GPS is also available, compare + * [GpsPosition.accuracyMeters]: keep NMEA if its reported accuracy is strictly better + * (lower metres). Fall back to Android when accuracy is unavailable or Android wins. + * 3. Fall back to Android GPS when NMEA is very stale (beyond [nmeaExtendedThresholdMs]). + * 4. Use stale NMEA only when Android GPS has never provided a fix. + * 5. [bestPosition] is null until at least one source has reported. * * Call [updateSensorData] whenever new NMEA or Signal K sensor data arrives and * [updateCurrentConditions] when a fresh marine-forecast response is received. * Use [snapshot] to capture a point-in-time reading at safety-critical moments * such as MOB activation. * - * @param nmeaStalenessThresholdMs Maximum age (ms) of an NMEA fix before it is - * considered stale and Android GPS is preferred instead. Default: 5 000 ms. + * @param nmeaStalenessThresholdMs Maximum age (ms) of an NMEA fix before it enters the + * quality-comparison zone. Default: 5 000 ms. + * @param nmeaExtendedThresholdMs Maximum age (ms) up to which a marginally-stale NMEA fix + * can still win over Android if its [GpsPosition.accuracyMeters] is strictly better. + * Must be ≥ [nmeaStalenessThresholdMs]. Default: 10 000 ms. * @param clockMs Injectable clock for unit-testable staleness checks. */ class LocationService( private val windCalculator: TrueWindCalculator = TrueWindCalculator(), private val nmeaStalenessThresholdMs: Long = 5_000L, + private val nmeaExtendedThresholdMs: Long = 10_000L, private val clockMs: () -> Long = System::currentTimeMillis ) { @@ -114,29 +122,55 @@ class LocationService( /** * Selects the best GPS fix and updates [bestPosition] / [activeGpsSource]. * - * Priority: - * 1. Fresh NMEA (age ≤ [nmeaStalenessThresholdMs]) - * 2. Android GPS (any age) - * 3. Stale NMEA (only if Android has never reported) + * Priority tiers (in order): + * 1. Fresh NMEA (age ≤ [nmeaStalenessThresholdMs]) — always preferred. + * 2. Marginally-stale NMEA (age in (primary, extended] threshold) when Android is + * also available — keep NMEA only if its [GpsPosition.accuracyMeters] is strictly + * better than Android's; otherwise use Android. + * 3. Android GPS (any age) once NMEA is beyond the extended threshold. + * 4. Stale NMEA — used as last resort when Android has never reported. */ private fun recomputeBestPosition() { val now = clockMs() val nmea = lastNmeaPosition val android = lastAndroidPosition - val nmeaFresh = nmea != null && (now - nmea.timestampMs) <= nmeaStalenessThresholdMs + val nmeaAge = nmea?.let { now - it.timestampMs } + val nmeaFresh = nmeaAge != null && nmeaAge <= nmeaStalenessThresholdMs + val nmeaMarginallyStale = nmeaAge != null && + nmeaAge > nmeaStalenessThresholdMs && + nmeaAge <= nmeaExtendedThresholdMs val (best, source) = when { - nmeaFresh -> nmea!! to GpsSource.NMEA - android != null -> android to GpsSource.ANDROID - nmea != null -> nmea to GpsSource.NMEA // stale, but only source - else -> null to GpsSource.NONE + nmeaFresh -> nmea!! to GpsSource.NMEA + + nmeaMarginallyStale && android != null -> + // Quality tie-break: NMEA wins only when it has a strictly better accuracy. + if (nmea!!.hasStrictlyBetterAccuracyThan(android)) nmea to GpsSource.NMEA + else android to GpsSource.ANDROID + + android != null -> android to GpsSource.ANDROID + nmea != null -> nmea to GpsSource.NMEA // only source, however stale + else -> null to GpsSource.NONE } _bestPosition.value = best _activeGpsSource.value = source } + // ── private helpers ─────────────────────────────────────────────────────── + + /** + * Returns true when this fix carries an accuracy estimate that is numerically + * smaller (i.e. better) than [other]'s. Returns false when either estimate is + * absent — conservatively preferring the other source when quality is unknown. + */ + private fun GpsPosition.hasStrictlyBetterAccuracyThan(other: GpsPosition): Boolean { + val thisAccuracy = accuracyMeters ?: return false + val otherAccuracy = other.accuracyMeters ?: return true + return thisAccuracy < otherAccuracy + } + /** * Update the ocean current conditions from the latest marine-forecast response. * diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt index 237004b..4eb9898 100644 --- a/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt +++ b/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt @@ -119,15 +119,20 @@ class LocationServiceTest { private fun fusionService( nmeaStalenessThresholdMs: Long = 5_000L, + nmeaExtendedThresholdMs: Long = 10_000L, clockMs: () -> Long = System::currentTimeMillis ) = LocationService( nmeaStalenessThresholdMs = nmeaStalenessThresholdMs, + nmeaExtendedThresholdMs = nmeaExtendedThresholdMs, clockMs = clockMs ) private fun pos(lat: Double, lon: Double, timestampMs: Long) = GpsPosition(lat, lon, sog = 0.0, cog = 0.0, timestampMs = timestampMs) + private fun posWithAccuracy(lat: Double, lon: Double, timestampMs: Long, accuracyMeters: Double) = + GpsPosition(lat, lon, sog = 0.0, cog = 0.0, timestampMs = timestampMs, accuracyMeters = accuracyMeters) + @Test fun noGpsData_bestPositionNullAndSourceNone() = runBlocking { val svc = fusionService() @@ -203,6 +208,91 @@ class LocationServiceTest { assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) } + // ── fix-quality (accuracy) tie-breaking ────────────────────────────────── + + @Test + fun marginallyStaleNmea_betterAccuracy_preferredOverAndroid() = runBlocking { + // NMEA is 7 s old (> primary 5 s, ≤ extended 10 s) but has accuracy 3 m vs Android 15 m. + val nmeaTime = 0L + val now = 7_000L + val svc = fusionService( + nmeaStalenessThresholdMs = 5_000L, + nmeaExtendedThresholdMs = 10_000L, + clockMs = { now } + ) + + val nmeaFix = posWithAccuracy(41.0, -71.0, nmeaTime, accuracyMeters = 3.0) + val androidFix = posWithAccuracy(42.0, -72.0, now, accuracyMeters = 15.0) + + svc.updateNmeaGps(nmeaFix) + svc.updateAndroidGps(androidFix) + + assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) + assertEquals(nmeaFix, svc.bestPosition.first()) + } + + @Test + fun marginallyStaleNmea_worseAccuracy_fallsBackToAndroid() = runBlocking { + // NMEA is 7 s old with accuracy 15 m; Android has accuracy 3 m → Android wins. + val nmeaTime = 0L + val now = 7_000L + val svc = fusionService( + nmeaStalenessThresholdMs = 5_000L, + nmeaExtendedThresholdMs = 10_000L, + clockMs = { now } + ) + + val nmeaFix = posWithAccuracy(41.0, -71.0, nmeaTime, accuracyMeters = 15.0) + val androidFix = posWithAccuracy(42.0, -72.0, now, accuracyMeters = 3.0) + + svc.updateNmeaGps(nmeaFix) + svc.updateAndroidGps(androidFix) + + assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) + assertEquals(androidFix, svc.bestPosition.first()) + } + + @Test + fun marginallyStaleNmea_noAccuracyData_fallsBackToAndroid() = runBlocking { + // Neither source has accuracy metadata — conservative: prefer Android. + val nmeaTime = 0L + val now = 7_000L + val svc = fusionService( + nmeaStalenessThresholdMs = 5_000L, + nmeaExtendedThresholdMs = 10_000L, + clockMs = { now } + ) + + val nmeaFix = pos(41.0, -71.0, nmeaTime) + val androidFix = pos(42.0, -72.0, now) + + svc.updateNmeaGps(nmeaFix) + svc.updateAndroidGps(androidFix) + + assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) + } + + @Test + fun veryStaleNmea_beyondExtendedThreshold_androidPreferred() = runBlocking { + // NMEA is 15 s old (beyond extended 10 s); Android wins even if NMEA has better accuracy. + val nmeaTime = 0L + val now = 15_000L + val svc = fusionService( + nmeaStalenessThresholdMs = 5_000L, + nmeaExtendedThresholdMs = 10_000L, + clockMs = { now } + ) + + val nmeaFix = posWithAccuracy(41.0, -71.0, nmeaTime, accuracyMeters = 2.0) + val androidFix = posWithAccuracy(42.0, -72.0, now, accuracyMeters = 20.0) + + svc.updateNmeaGps(nmeaFix) + svc.updateAndroidGps(androidFix) + + assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) + assertEquals(androidFix, svc.bestPosition.first()) + } + @Test fun nmeaRecovery_switchesBackFromAndroid() = runBlocking { var now = 0L -- cgit v1.2.3 From 97715ab4007ff3101f58edf4385cef1fc3d1615b Mon Sep 17 00:00:00 2001 From: Peter Stone Date: Sat, 4 Apr 2026 07:45:41 +0000 Subject: refactor: unify core models and finish org.terst.nav migration --- .claude/settings.local.json | 3 +- .remember/logs/autonomous/save-045406.log | 4 + .remember/tmp/save-session.pid | 1 - .../kotlin/org/terst/nav/MainActivitySmokeTest.kt | 9 +- .../example/androidapp/data/model/SensorData.kt | 10 - .../androidapp/data/storage/GribFileManager.kt | 24 -- .../data/weather/GribStalenessChecker.kt | 36 --- .../data/weather/SatelliteGribDownloader.kt | 134 --------- .../com/example/androidapp/gps/GpsPosition.kt | 10 - .../com/example/androidapp/gps/LocationService.kt | 216 -------------- .../example/androidapp/logbook/LogbookFormatter.kt | 81 ------ .../androidapp/logbook/LogbookPdfExporter.kt | 137 --------- .../com/example/androidapp/nmea/NmeaParser.kt | 94 ------ .../example/androidapp/routing/IsochroneResult.kt | 12 - .../example/androidapp/routing/IsochroneRouter.kt | 178 ------------ .../com/example/androidapp/routing/RoutePoint.kt | 16 -- .../example/androidapp/safety/AnchorWatchState.kt | 24 -- .../androidapp/tide/HarmonicTideCalculator.kt | 88 ------ .../ui/anchorwatch/AnchorWatchHandler.kt | 58 ---- .../com/example/androidapp/wind/ApparentWind.kt | 3 - .../example/androidapp/wind/TrueWindCalculator.kt | 20 -- .../com/example/androidapp/wind/TrueWindData.kt | 3 - .../main/kotlin/org/terst/nav/AnchorWatchData.kt | 57 ---- .../main/kotlin/org/terst/nav/LocationService.kt | 290 ++++++++++--------- .../src/main/kotlin/org/terst/nav/MainActivity.kt | 15 +- .../kotlin/org/terst/nav/data/model/SensorData.kt | 10 + .../org/terst/nav/data/storage/GribFileManager.kt | 22 +- .../terst/nav/data/weather/GribStalenessChecker.kt | 36 +++ .../nav/data/weather/SatelliteGribDownloader.kt | 134 +++++++++ .../main/kotlin/org/terst/nav/gps/GpsPosition.kt | 17 +- .../org/terst/nav/logbook/LogbookFormatter.kt | 81 ++++++ .../org/terst/nav/logbook/LogbookPdfExporter.kt | 137 +++++++++ .../main/kotlin/org/terst/nav/nmea/NmeaParser.kt | 5 +- .../org/terst/nav/routing/IsochroneResult.kt | 12 + .../org/terst/nav/routing/IsochroneRouter.kt | 178 ++++++++++++ .../kotlin/org/terst/nav/routing/RoutePoint.kt | 16 ++ .../org/terst/nav/safety/AnchorWatchState.kt | 40 +++ .../org/terst/nav/tide/HarmonicTideCalculator.kt | 88 ++++++ .../kotlin/org/terst/nav/ui/AnchorWatchHandler.kt | 99 ------- .../src/main/kotlin/org/terst/nav/ui/MapHandler.kt | 2 +- .../terst/nav/ui/anchorwatch/AnchorWatchHandler.kt | 58 ++++ .../main/kotlin/org/terst/nav/wind/ApparentWind.kt | 3 + .../org/terst/nav/wind/TrueWindCalculator.kt | 20 ++ .../main/kotlin/org/terst/nav/wind/TrueWindData.kt | 3 + .../data/weather/GribStalenessCheckerTest.kt | 91 ------ .../data/weather/SatelliteGribDownloaderTest.kt | 180 ------------ .../com/example/androidapp/gps/GpsPositionTest.kt | 33 --- .../example/androidapp/gps/LocationServiceTest.kt | 317 --------------------- .../androidapp/logbook/LogbookFormatterTest.kt | 178 ------------ .../com/example/androidapp/nmea/NmeaParserTest.kt | 105 ------- .../androidapp/routing/IsochroneRouterTest.kt | 169 ----------- .../androidapp/safety/AnchorWatchStateTest.kt | 32 --- .../androidapp/tide/HarmonicTideCalculatorTest.kt | 135 --------- .../nav/data/repository/WeatherRepositoryTest.kt | 31 +- 54 files changed, 1030 insertions(+), 2725 deletions(-) create mode 100644 .remember/logs/autonomous/save-045406.log delete mode 100644 .remember/tmp/save-session.pid delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/data/model/SensorData.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/nmea/NmeaParser.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/wind/ApparentWind.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindCalculator.kt delete mode 100644 android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindData.kt delete mode 100644 android-app/app/src/main/kotlin/org/terst/nav/AnchorWatchData.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/model/SensorData.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/weather/GribStalenessChecker.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/data/weather/SatelliteGribDownloader.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookFormatter.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookPdfExporter.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneResult.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneRouter.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/routing/RoutePoint.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/safety/AnchorWatchState.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/tide/HarmonicTideCalculator.kt delete mode 100644 android-app/app/src/main/kotlin/org/terst/nav/ui/AnchorWatchHandler.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/ui/anchorwatch/AnchorWatchHandler.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/wind/ApparentWind.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindCalculator.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindData.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt delete mode 100644 android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/.claude/settings.local.json b/.claude/settings.local.json index d8a1091..e581baf 100644 --- a/.claude/settings.local.json +++ b/.claude/settings.local.json @@ -60,7 +60,8 @@ "Bash(./gradlew assembleDebug)", "Bash(gh:*)", "Skill(commit-commands:commit-push-pr)", - "Skill(code-review:code-review)" + "Skill(code-review:code-review)", + "Bash(python3 -m json.tool)" ] } } diff --git a/.remember/logs/autonomous/save-045406.log b/.remember/logs/autonomous/save-045406.log new file mode 100644 index 0000000..189a2f2 --- /dev/null +++ b/.remember/logs/autonomous/save-045406.log @@ -0,0 +1,4 @@ +/root/.claude/plugins/cache/claude-plugins-official/remember/0.1.0/scripts/save-session.sh: line 135: cd: /root/.claude/plugins/cache/claude-plugins-official/.claude/remember: No such file or directory +/root/.claude/plugins/cache/claude-plugins-official/remember/0.1.0/scripts/save-session.sh: line 140: [: : integer expression expected +/root/.claude/plugins/cache/claude-plugins-official/remember/0.1.0/scripts/save-session.sh: line 142: [: : integer expression expected +/root/.claude/plugins/cache/claude-plugins-official/remember/0.1.0/scripts/save-session.sh: line 164: cd: /root/.claude/plugins/cache/claude-plugins-official/.claude/remember: No such file or directory diff --git a/.remember/tmp/save-session.pid b/.remember/tmp/save-session.pid deleted file mode 100644 index efca6cd..0000000 --- a/.remember/tmp/save-session.pid +++ /dev/null @@ -1 +0,0 @@ -3500589 diff --git a/android-app/app/src/androidTest/kotlin/org/terst/nav/MainActivitySmokeTest.kt b/android-app/app/src/androidTest/kotlin/org/terst/nav/MainActivitySmokeTest.kt index 30841c7..2d75cf4 100644 --- a/android-app/app/src/androidTest/kotlin/org/terst/nav/MainActivitySmokeTest.kt +++ b/android-app/app/src/androidTest/kotlin/org/terst/nav/MainActivitySmokeTest.kt @@ -65,7 +65,7 @@ class MainActivitySmokeTest { onView(withText("Safety")).perform(click()) onView(withText("Safety Dashboard")).check(matches(isDisplayed())) onView(withText("ACTIVATE MOB")).check(matches(isDisplayed())) - onView(withText("ANCHOR WATCH")).check(matches(isDisplayed())) + onView(withText("CONFIGURE ANCHOR WATCH")).check(matches(isDisplayed())) } @Test @@ -80,6 +80,13 @@ class MainActivitySmokeTest { onView(withId(R.id.instrument_bottom_sheet)).check(matches(isDisplayed())) } + @Test + fun instrumentSheet_surfacedReportButtons_areDisplayed() { + onView(withText("Instruments")).perform(click()) + onView(withText("PRE-TRIP PLAN")).check(matches(isDisplayed())) + onView(withText("GENERATE REPORT")).check(matches(isDisplayed())) + } + @Test fun bottomNav_mapTab_returnsFromOverlay() { onView(withText("Safety")).perform(click()) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/model/SensorData.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/model/SensorData.kt deleted file mode 100644 index d427a5d..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/data/model/SensorData.kt +++ /dev/null @@ -1,10 +0,0 @@ -package com.example.androidapp.data.model - -data class SensorData( - val latitude: Double? = null, - val longitude: Double? = null, - val headingTrueDeg: Double? = null, - val apparentWindSpeedKt: Double? = null, - val apparentWindAngleDeg: Double? = null, - val speedOverGroundKt: Double? = null -) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt deleted file mode 100644 index d6f685a..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/data/storage/GribFileManager.kt +++ /dev/null @@ -1,24 +0,0 @@ -package com.example.androidapp.data.storage - -import org.terst.nav.data.model.GribFile -import org.terst.nav.data.model.GribRegion -import java.time.Instant - -interface GribFileManager { - fun saveMetadata(file: GribFile) - fun listFiles(region: GribRegion): List - fun latestFile(region: GribRegion): GribFile? - fun delete(file: GribFile): Boolean - fun purgeOlderThan(before: Instant): Int - fun totalSizeBytes(): Long -} - -class InMemoryGribFileManager : GribFileManager { - private val files = mutableListOf() - override fun saveMetadata(file: GribFile) { files.add(file) } - override fun listFiles(region: GribRegion): List = files.filter { it.region.name == region.name }.sortedByDescending { it.downloadedAt } - override fun latestFile(region: GribRegion): GribFile? = listFiles(region).firstOrNull() - override fun delete(file: GribFile): Boolean = files.remove(file) - override fun purgeOlderThan(before: Instant): Int { val toRemove = files.filter { it.downloadedAt.isBefore(before) }; files.removeAll(toRemove); return toRemove.size } - override fun totalSizeBytes(): Long = files.sumOf { it.sizeBytes } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt deleted file mode 100644 index 70f36d9..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/GribStalenessChecker.kt +++ /dev/null @@ -1,36 +0,0 @@ -package com.example.androidapp.data.weather - -import org.terst.nav.data.model.GribFile -import com.example.androidapp.data.storage.GribFileManager -import org.terst.nav.data.model.GribRegion -import java.time.Instant - -/** Outcome of a freshness check. */ -sealed class FreshnessResult { - /** Data is current; no user action needed. */ - object Fresh : FreshnessResult() - /** Data is stale; user should re-download. [message] is shown in the UI badge. */ - data class Stale(val file: GribFile, val message: String) : FreshnessResult() - /** No local GRIB data exists for this region. */ - object NoData : FreshnessResult() -} - -/** - * Checks whether locally-stored GRIB data for a region is fresh or stale. - * Per design doc §6.3: GRIB weather valid until model run + forecast hour; stale after. - */ -class GribStalenessChecker(private val manager: GribFileManager) { - - /** - * Check freshness of the most-recent GRIB file for [region] relative to [now]. - */ - fun check(region: GribRegion, now: Instant = Instant.now()): FreshnessResult { - val latest = manager.latestFile(region) ?: return FreshnessResult.NoData - return if (latest.isStale(now)) { - val hoursAgo = (now.epochSecond - latest.validUntil().epochSecond) / 3600 - FreshnessResult.Stale(latest, "Weather data outdated by ${hoursAgo}h — tap to refresh") - } else { - FreshnessResult.Fresh - } - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt b/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt deleted file mode 100644 index 6e565b7..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloader.kt +++ /dev/null @@ -1,134 +0,0 @@ -package com.example.androidapp.data.weather - -import org.terst.nav.data.model.GribFile -import org.terst.nav.data.model.GribParameter -import org.terst.nav.data.model.GribRegion -import org.terst.nav.data.model.SatelliteDownloadRequest -import com.example.androidapp.data.storage.GribFileManager -import java.time.Instant -import kotlin.math.ceil -import kotlin.math.floor - -/** - * Downloads GRIB weather data over bandwidth-constrained satellite links (§9.1). - * - * Provides size and time estimates before fetching, and aborts if the download - * would exceed the configured size limit (default 2 MB — the upper bound stated - * in §9.1 for typical offshore GRIBs on satellite). - * - * The actual network fetch is supplied as a [fetcher] lambda so the class remains - * testable without network access. - */ -class SatelliteGribDownloader(private val fileManager: GribFileManager) { - - companion object { - /** Iridium data link speed in bits per second. */ - const val SATELLITE_BANDWIDTH_BPS = 2400L - - /** GRIB2 packed grid value: ~2 bytes per grid point after packing. */ - private const val BYTES_PER_GRID_POINT = 2L - - /** Per-message header overhead in GRIB2 format (section 0-4). */ - private const val HEADER_BYTES_PER_MESSAGE = 100L - - /** Forecast time step used for size estimation (3-hourly is standard GFS output). */ - private const val TIME_STEP_HOURS = 3 - - /** Default maximum download size; abort if estimate exceeds this. */ - const val DEFAULT_SIZE_LIMIT_BYTES = 2_000_000L - } - - /** - * Estimates the GRIB file size in bytes for [request]. - * - * Formula: (gridPoints × timeSteps × paramCount × bytesPerPoint) + headerOverhead - * where gridPoints = ceil(latSpan/resolution + 1) × ceil(lonSpan/resolution + 1). - */ - fun estimateSizeBytes(request: SatelliteDownloadRequest): Long { - val latPoints = floor((request.region.latMax - request.region.latMin) / request.resolutionDeg).toLong() + 1 - val lonPoints = floor((request.region.lonMax - request.region.lonMin) / request.resolutionDeg).toLong() + 1 - val gridPoints = latPoints * lonPoints - val timeSteps = ceil(request.forecastHours.toDouble() / TIME_STEP_HOURS).toLong() - val paramCount = request.parameters.size.toLong() - val dataBytes = gridPoints * timeSteps * paramCount * BYTES_PER_GRID_POINT - val headerBytes = paramCount * timeSteps * HEADER_BYTES_PER_MESSAGE - return dataBytes + headerBytes - } - - /** - * Estimates how many seconds the download will take at [bandwidthBps] bits/second. - */ - fun estimatedDownloadSeconds( - request: SatelliteDownloadRequest, - bandwidthBps: Long = SATELLITE_BANDWIDTH_BPS - ): Long = ceil(estimateSizeBytes(request) * 8.0 / bandwidthBps).toLong() - - /** - * Convenience builder: creates a [SatelliteDownloadRequest] using the minimal - * satellite parameter set (wind speed + direction + surface pressure only). - */ - fun buildMinimalRequest( - region: GribRegion, - forecastHours: Int, - resolutionDeg: Double = 1.0 - ): SatelliteDownloadRequest = SatelliteDownloadRequest( - region = region, - parameters = GribParameter.SATELLITE_MINIMAL, - forecastHours = forecastHours, - resolutionDeg = resolutionDeg - ) - - /** Result of a satellite GRIB download attempt. */ - sealed class DownloadResult { - /** Download succeeded; [file] metadata has been saved to [GribFileManager]. */ - data class Success(val file: GribFile) : DownloadResult() - /** The [fetcher] returned no data or an unexpected error occurred. */ - data class Failed(val reason: String) : DownloadResult() - /** - * Download was aborted before starting because the estimated size - * [estimatedBytes] exceeds the configured limit. - */ - data class Aborted(val reason: String, val estimatedBytes: Long) : DownloadResult() - } - - /** - * Downloads GRIB data for [request]. - * - * 1. Estimates size; returns [DownloadResult.Aborted] if > [sizeLimitBytes]. - * 2. Calls [fetcher] to retrieve raw bytes. - * 3. On success, saves metadata via [fileManager] and returns [DownloadResult.Success]. - * - * @param request The bandwidth-optimised download request. - * @param fetcher Supplies raw GRIB bytes for the request; returns null on failure. - * @param outputPath Local file path where the caller will persist the bytes. - * @param sizeLimitBytes Abort threshold (default [DEFAULT_SIZE_LIMIT_BYTES]). - * @param now Timestamp injected for testing. - */ - fun download( - request: SatelliteDownloadRequest, - fetcher: (SatelliteDownloadRequest) -> ByteArray?, - outputPath: String, - sizeLimitBytes: Long = DEFAULT_SIZE_LIMIT_BYTES, - now: Instant = Instant.now() - ): DownloadResult { - val estimated = estimateSizeBytes(request) - if (estimated > sizeLimitBytes) { - return DownloadResult.Aborted( - "Estimated size ${estimated / 1024}KB exceeds limit ${sizeLimitBytes / 1024}KB — " + - "reduce region, resolution, or forecast hours", - estimated - ) - } - val bytes = fetcher(request) ?: return DownloadResult.Failed("Fetcher returned no data") - val gribFile = GribFile( - region = request.region, - modelRunTime = now, - forecastHours = request.forecastHours, - downloadedAt = now, - filePath = outputPath, - sizeBytes = bytes.size.toLong() - ) - fileManager.saveMetadata(gribFile) - return DownloadResult.Success(gribFile) - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt deleted file mode 100644 index cbe5c84..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/gps/GpsPosition.kt +++ /dev/null @@ -1,10 +0,0 @@ -package com.example.androidapp.gps - -data class GpsPosition( - val latitude: Double, // degrees, positive = North - val longitude: Double, // degrees, positive = East - val sog: Double, // Speed Over Ground in knots - val cog: Double, // Course Over Ground in degrees true (0-360) - val timestampMs: Long, // Unix millis UTC - val accuracyMeters: Double? = null // estimated horizontal accuracy (1-sigma); null = unknown -) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt b/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt deleted file mode 100644 index 0a315d4..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/gps/LocationService.kt +++ /dev/null @@ -1,216 +0,0 @@ -package com.example.androidapp.gps - -import com.example.androidapp.data.model.SensorData -import com.example.androidapp.wind.TrueWindCalculator -import com.example.androidapp.wind.ApparentWind -import com.example.androidapp.wind.TrueWindData -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.flow.asStateFlow - -/** Source of the currently active GPS fix. */ -enum class GpsSource { NONE, NMEA, ANDROID } - -/** - * Aggregates real-time location and environmental sensor data for use throughout - * the safety subsystem (Section 4.6 of COMPONENT_DESIGN.md). - * - * ## GPS sensor fusion - * The service accepts fixes from two independent sources: - * - **NMEA GPS** — dedicated marine GPS received via [updateNmeaGps] (higher priority) - * - **Android GPS** — device built-in location via [updateAndroidGps] (fallback) - * - * Selection policy (evaluated on every new fix): - * 1. Prefer NMEA when its most recent fix is no older than [nmeaStalenessThresholdMs]. - * 2. When NMEA is marginally stale (older than [nmeaStalenessThresholdMs] but within - * [nmeaExtendedThresholdMs]) **and** Android GPS is also available, compare - * [GpsPosition.accuracyMeters]: keep NMEA if its reported accuracy is strictly better - * (lower metres). Fall back to Android when accuracy is unavailable or Android wins. - * 3. Fall back to Android GPS when NMEA is very stale (beyond [nmeaExtendedThresholdMs]). - * 4. Use stale NMEA only when Android GPS has never provided a fix. - * 5. [bestPosition] is null until at least one source has reported. - * - * Call [updateSensorData] whenever new NMEA or Signal K sensor data arrives and - * [updateCurrentConditions] when a fresh marine-forecast response is received. - * Use [snapshot] to capture a point-in-time reading at safety-critical moments - * such as MOB activation. - * - * @param nmeaStalenessThresholdMs Maximum age (ms) of an NMEA fix before it enters the - * quality-comparison zone. Default: 5 000 ms. - * @param nmeaExtendedThresholdMs Maximum age (ms) up to which a marginally-stale NMEA fix - * can still win over Android if its [GpsPosition.accuracyMeters] is strictly better. - * Must be ≥ [nmeaStalenessThresholdMs]. Default: 10 000 ms. - * @param clockMs Injectable clock for unit-testable staleness checks. - */ -class LocationService( - private val windCalculator: TrueWindCalculator = TrueWindCalculator(), - private val nmeaStalenessThresholdMs: Long = 5_000L, - private val nmeaExtendedThresholdMs: Long = 10_000L, - private val clockMs: () -> Long = System::currentTimeMillis -) { - - private val _latestSensor = MutableStateFlow(null) - /** The most recently received unified sensor reading. */ - val latestSensor: StateFlow = _latestSensor.asStateFlow() - - private val _latestTrueWind = MutableStateFlow(null) - /** Most recent resolved true-wind vector, updated whenever a full sensor reading arrives. */ - val latestTrueWind: StateFlow = _latestTrueWind.asStateFlow() - - private val _currentSpeedKt = MutableStateFlow(null) - private val _currentDirectionDeg = MutableStateFlow(null) - - // ── GPS sensor fusion state ─────────────────────────────────────────────── - - private var lastNmeaPosition: GpsPosition? = null - private var lastAndroidPosition: GpsPosition? = null - - private val _bestPosition = MutableStateFlow(null) - /** - * The best available GPS fix, selected from NMEA and Android sources according - * to the fusion policy described in the class KDoc. Null until at least one - * source reports a fix. - */ - val bestPosition: StateFlow = _bestPosition.asStateFlow() - - private val _activeGpsSource = MutableStateFlow(GpsSource.NONE) - /** The source that produced [bestPosition]. [GpsSource.NONE] before any fix arrives. */ - val activeGpsSource: StateFlow = _activeGpsSource.asStateFlow() - - /** - * Ingest a new sensor reading. If the reading carries apparent wind, boat speed, - * and heading, true wind is resolved immediately via [TrueWindCalculator] and - * stored in [latestTrueWind]. - */ - fun updateSensorData(data: SensorData) { - _latestSensor.value = data - - val aws = data.apparentWindSpeedKt - val awa = data.apparentWindAngleDeg - val bsp = data.speedOverGroundKt // use SOG as proxy when BSP is absent - val hdg = data.headingTrueDeg - - if (aws != null && awa != null && bsp != null && hdg != null) { - _latestTrueWind.value = windCalculator.update( - apparent = ApparentWind(speedKt = aws, angleDeg = awa), - bsp = bsp, - hdgDeg = hdg - ) - } - } - - // ── GPS source ingestion ────────────────────────────────────────────────── - - /** - * Ingest a new GPS fix from the NMEA source (e.g. a marine chartplotter or - * NMEA multiplexer). Triggers a fusion re-evaluation. - */ - fun updateNmeaGps(position: GpsPosition) { - lastNmeaPosition = position - recomputeBestPosition() - } - - /** - * Ingest a new GPS fix from the Android system location provider. - * Triggers a fusion re-evaluation. - */ - fun updateAndroidGps(position: GpsPosition) { - lastAndroidPosition = position - recomputeBestPosition() - } - - /** - * Selects the best GPS fix and updates [bestPosition] / [activeGpsSource]. - * - * Priority tiers (in order): - * 1. Fresh NMEA (age ≤ [nmeaStalenessThresholdMs]) — always preferred. - * 2. Marginally-stale NMEA (age in (primary, extended] threshold) when Android is - * also available — keep NMEA only if its [GpsPosition.accuracyMeters] is strictly - * better than Android's; otherwise use Android. - * 3. Android GPS (any age) once NMEA is beyond the extended threshold. - * 4. Stale NMEA — used as last resort when Android has never reported. - */ - private fun recomputeBestPosition() { - val now = clockMs() - val nmea = lastNmeaPosition - val android = lastAndroidPosition - - val nmeaAge = nmea?.let { now - it.timestampMs } - val nmeaFresh = nmeaAge != null && nmeaAge <= nmeaStalenessThresholdMs - val nmeaMarginallyStale = nmeaAge != null && - nmeaAge > nmeaStalenessThresholdMs && - nmeaAge <= nmeaExtendedThresholdMs - - val (best, source) = when { - nmeaFresh -> nmea!! to GpsSource.NMEA - - nmeaMarginallyStale && android != null -> - // Quality tie-break: NMEA wins only when it has a strictly better accuracy. - if (nmea!!.hasStrictlyBetterAccuracyThan(android)) nmea to GpsSource.NMEA - else android to GpsSource.ANDROID - - android != null -> android to GpsSource.ANDROID - nmea != null -> nmea to GpsSource.NMEA // only source, however stale - else -> null to GpsSource.NONE - } - - _bestPosition.value = best - _activeGpsSource.value = source - } - - // ── private helpers ─────────────────────────────────────────────────────── - - /** - * Returns true when this fix carries an accuracy estimate that is numerically - * smaller (i.e. better) than [other]'s. Returns false when either estimate is - * absent — conservatively preferring the other source when quality is unknown. - */ - private fun GpsPosition.hasStrictlyBetterAccuracyThan(other: GpsPosition): Boolean { - val thisAccuracy = accuracyMeters ?: return false - val otherAccuracy = other.accuracyMeters ?: return true - return thisAccuracy < otherAccuracy - } - - /** - * Update the ocean current conditions from the latest marine-forecast response. - * - * @param speedKt Current speed in knots (null to clear) - * @param directionDeg Direction the current flows TOWARD, in degrees (null to clear) - */ - fun updateCurrentConditions(speedKt: Double?, directionDeg: Double?) { - _currentSpeedKt.value = speedKt - _currentDirectionDeg.value = directionDeg - } - - /** - * Captures a snapshot of wind and current conditions at the current moment. - * - * All fields are nullable — only data that was available at snapshot time is - * populated. This snapshot is intended to be logged alongside a [MobEvent] - * at the instant of MOB activation. - */ - fun snapshot(): EnvironmentalSnapshot { - val trueWind = _latestTrueWind.value - return EnvironmentalSnapshot( - windSpeedKt = trueWind?.speedKt, - windDirectionDeg = trueWind?.directionDeg, - currentSpeedKt = _currentSpeedKt.value, - currentDirectionDeg = _currentDirectionDeg.value - ) - } -} - -/** - * Point-in-time snapshot of wind and current conditions. - * - * @param windSpeedKt True Wind Speed in knots; null if sensors were unavailable. - * @param windDirectionDeg True Wind Direction (degrees true, wind comes FROM); null if unavailable. - * @param currentSpeedKt Ocean current speed in knots; null if forecast was unavailable. - * @param currentDirectionDeg Ocean current direction (degrees, flows TOWARD); null if unavailable. - */ -data class EnvironmentalSnapshot( - val windSpeedKt: Double?, - val windDirectionDeg: Double?, - val currentSpeedKt: Double?, - val currentDirectionDeg: Double? -) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt deleted file mode 100644 index d4cf50d..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookFormatter.kt +++ /dev/null @@ -1,81 +0,0 @@ -package com.example.androidapp.logbook - -import org.terst.nav.data.model.LogbookEntry -import java.util.Calendar -import java.util.TimeZone - -data class LogbookRow( - val time: String, - val position: String, - val sog: String, - val cog: String, - val wind: String, - val baro: String, - val depth: String, - val eventNotes: String -) - -data class LogbookPage( - val title: String, - val columns: List, - val rows: List -) - -object LogbookFormatter { - - val COLUMNS = listOf( - "Time (UTC)", "Position", "SOG", "COG", "Wind", "Baro", "Depth", "Event / Notes" - ) - - private val COMPASS_POINTS = arrayOf( - "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", - "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW" - ) - - fun formatTime(timestampMs: Long): String { - val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC")) - cal.timeInMillis = timestampMs - return "%02d:%02d".format( - cal.get(Calendar.HOUR_OF_DAY), - cal.get(Calendar.MINUTE) - ) - } - - fun formatPosition(lat: Double, lon: Double): String { - val latDir = if (lat >= 0) "N" else "S" - val lonDir = if (lon >= 0) "E" else "W" - val absLat = Math.abs(lat) - val absLon = Math.abs(lon) - val latDeg = absLat.toInt() - val lonDeg = absLon.toInt() - val latMin = (absLat - latDeg) * 60.0 - val lonMin = (absLon - lonDeg) * 60.0 - return "%d°%.1f%s %d°%.1f%s".format(latDeg, latMin, latDir, lonDeg, lonMin, lonDir) - } - - fun toCompassPoint(degrees: Double): String { - val normalized = ((degrees % 360.0) + 360.0) % 360.0 - val index = ((normalized + 11.25) / 22.5).toInt() % 16 - return COMPASS_POINTS[index] - } - - fun formatWind(knots: Double?, directionDeg: Double?): String { - if (knots == null) return "" - val knotsStr = "%.0fkt".format(knots) - return if (directionDeg == null) knotsStr else "$knotsStr ${toCompassPoint(directionDeg)}" - } - - fun toRow(entry: LogbookEntry): LogbookRow = LogbookRow( - time = formatTime(entry.timestampMs), - position = formatPosition(entry.lat, entry.lon), - sog = "%.1f".format(entry.sogKnots), - cog = "%.0f".format(entry.cogDegrees), - wind = formatWind(entry.windKnots, entry.windDirectionDeg), - baro = entry.baroHpa?.let { "%.0f".format(it) } ?: "", - depth = entry.depthMeters?.let { "%.0fm".format(it) } ?: "", - eventNotes = listOfNotNull(entry.event, entry.notes).joinToString(": ") - ) - - fun toPage(entries: List, title: String = "Trip Logbook"): LogbookPage = - LogbookPage(title = title, columns = COLUMNS, rows = entries.map { toRow(it) }) -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt deleted file mode 100644 index 78ea834..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/logbook/LogbookPdfExporter.kt +++ /dev/null @@ -1,137 +0,0 @@ -package com.example.androidapp.logbook - -import android.graphics.Canvas -import android.graphics.Color -import android.graphics.Paint -import android.graphics.Typeface -import android.graphics.pdf.PdfDocument -import org.terst.nav.data.model.LogbookEntry -import java.io.OutputStream - -/** - * Renders trip logbook entries to a formatted PDF (landscape A4). - * Section 4.8 — Trip Logging and Electronic Logbook. - */ -object LogbookPdfExporter { - - // Landscape A4 in points (1 point = 1/72 inch) - private const val PAGE_WIDTH = 842 - private const val PAGE_HEIGHT = 595 - private const val MARGIN = 36f - private const val ROW_HEIGHT = 22f - private const val HEADER_HEIGHT = 36f - private const val TITLE_SIZE = 16f - private const val CELL_TEXT_SIZE = 9f - - // Column width fractions (must sum to 1.0) - private val COL_FRACTIONS = floatArrayOf( - 0.08f, // Time - 0.18f, // Position - 0.06f, // SOG - 0.06f, // COG - 0.10f, // Wind - 0.07f, // Baro - 0.07f, // Depth - 0.38f // Event / Notes - ) - - fun export( - entries: List, - outputStream: OutputStream, - title: String = "Trip Logbook" - ) { - val page = LogbookFormatter.toPage(entries, title) - val document = PdfDocument() - try { - val pageInfo = PdfDocument.PageInfo.Builder(PAGE_WIDTH, PAGE_HEIGHT, 1).create() - val pdfPage = document.startPage(pageInfo) - drawPage(pdfPage.canvas, page) - document.finishPage(pdfPage) - document.writeTo(outputStream) - } finally { - document.close() - } - } - - private fun drawPage(canvas: Canvas, page: LogbookPage) { - val usableWidth = PAGE_WIDTH - 2 * MARGIN - val colWidths = COL_FRACTIONS.map { it * usableWidth } - - val titlePaint = Paint().apply { - textSize = TITLE_SIZE - typeface = Typeface.DEFAULT_BOLD - color = Color.BLACK - } - val headerTextPaint = Paint().apply { - textSize = CELL_TEXT_SIZE - typeface = Typeface.DEFAULT_BOLD - color = Color.WHITE - } - val cellPaint = Paint().apply { - textSize = CELL_TEXT_SIZE - color = Color.BLACK - } - val linePaint = Paint().apply { - color = Color.LTGRAY - strokeWidth = 0.5f - } - val headerBgPaint = Paint().apply { - color = Color.rgb(41, 82, 123) - style = Paint.Style.FILL - } - val altBgPaint = Paint().apply { - color = Color.rgb(235, 242, 252) - style = Paint.Style.FILL - } - val borderPaint = Paint().apply { - color = Color.DKGRAY - strokeWidth = 1f - style = Paint.Style.STROKE - } - - var y = MARGIN - - // Title - canvas.drawText(page.title, MARGIN, y + TITLE_SIZE, titlePaint) - y += HEADER_HEIGHT - - val tableTop = y - - // Column header background - canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, headerBgPaint) - - // Column header text - var x = MARGIN + 3f - page.columns.forEachIndexed { i, col -> - canvas.drawText(col, x, y + ROW_HEIGHT - 6f, headerTextPaint) - x += colWidths[i] - } - y += ROW_HEIGHT - - // Data rows - page.rows.forEach { row -> - if (y + ROW_HEIGHT > PAGE_HEIGHT - MARGIN) return@forEach - - if (page.rows.indexOf(row) % 2 == 1) { - canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, altBgPaint) - } - - val cells = listOf( - row.time, row.position, row.sog, row.cog, - row.wind, row.baro, row.depth, row.eventNotes - ) - x = MARGIN + 3f - cells.forEachIndexed { i, cell -> - val maxChars = (colWidths[i] / (CELL_TEXT_SIZE * 0.55)).toInt().coerceAtLeast(4) - canvas.drawText(cell.take(maxChars), x, y + ROW_HEIGHT - 6f, cellPaint) - x += colWidths[i] - } - - canvas.drawLine(MARGIN, y + ROW_HEIGHT, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, linePaint) - y += ROW_HEIGHT - } - - // Table border - canvas.drawRect(MARGIN, tableTop, PAGE_WIDTH - MARGIN, y, borderPaint) - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/nmea/NmeaParser.kt b/android-app/app/src/main/kotlin/com/example/androidapp/nmea/NmeaParser.kt deleted file mode 100644 index b1b186a..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/nmea/NmeaParser.kt +++ /dev/null @@ -1,94 +0,0 @@ -package com.example.androidapp.nmea - -import com.example.androidapp.gps.GpsPosition -import java.util.Calendar -import java.util.TimeZone - -class NmeaParser { - - /** - * Parses an NMEA RMC sentence and returns a [GpsPosition], or null if the - * sentence is void (status=V), malformed, or cannot be parsed. - * - * Supported talker IDs: GP, GN, and any other standard prefix. - * SOG and COG default to 0.0 when the fields are absent. - */ - fun parseRmc(sentence: String): GpsPosition? { - if (sentence.isBlank()) return null - - val body = if ('*' in sentence) sentence.substringBefore('*') else sentence - val fields = body.split(',') - if (fields.size < 10) return null - - if (!fields[0].endsWith("RMC")) return null - if (fields[2] != "A") return null - - val latStr = fields.getOrNull(3) ?: return null - val latDir = fields.getOrNull(4) ?: return null - val lonStr = fields.getOrNull(5) ?: return null - val lonDir = fields.getOrNull(6) ?: return null - - val latitude = parseNmeaDegrees(latStr) * if (latDir == "S") -1.0 else 1.0 - val longitude = parseNmeaDegrees(lonStr) * if (lonDir == "W") -1.0 else 1.0 - - val sog = fields.getOrNull(7)?.toDoubleOrNull() ?: 0.0 - val cog = fields.getOrNull(8)?.toDoubleOrNull() ?: 0.0 - - val timestampMs = parseTimestamp( - timeStr = fields.getOrNull(1) ?: "", - dateStr = fields.getOrNull(9) ?: "" - ) - if (timestampMs == 0L) return null - - return GpsPosition(latitude, longitude, sog, cog, timestampMs) - } - - /** - * Converts NMEA degree-minutes format (DDDMM.MMMM) to decimal degrees. - */ - private fun parseNmeaDegrees(value: String): Double { - val raw = value.toDoubleOrNull() ?: return 0.0 - val degrees = (raw / 100.0).toInt() - val minutes = raw - degrees * 100.0 - return degrees + minutes / 60.0 - } - - /** - * Combines NMEA time (HHMMSS.ss) and date (DDMMYY) into Unix epoch millis UTC. - * Returns 0 on any parse failure. - */ - private fun parseTimestamp(timeStr: String, dateStr: String): Long { - return try { - val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC")) - cal.isLenient = false - - if (dateStr.length >= 6) { - val day = dateStr.substring(0, 2).toInt() - val month = dateStr.substring(2, 4).toInt() - 1 - val yy = dateStr.substring(4, 6).toInt() - val year = if (yy < 70) 2000 + yy else 1900 + yy - cal.set(Calendar.YEAR, year) - cal.set(Calendar.MONTH, month) - cal.set(Calendar.DAY_OF_MONTH, day) - } - - if (timeStr.length >= 6) { - val hours = timeStr.substring(0, 2).toInt() - val minutes = timeStr.substring(2, 4).toInt() - val seconds = timeStr.substring(4, 6).toInt() - val millis = if (timeStr.length > 7) { - val fracStr = timeStr.substring(7) - (("0.$fracStr").toDoubleOrNull()?.times(1000.0))?.toInt() ?: 0 - } else 0 - cal.set(Calendar.HOUR_OF_DAY, hours) - cal.set(Calendar.MINUTE, minutes) - cal.set(Calendar.SECOND, seconds) - cal.set(Calendar.MILLISECOND, millis) - } - - cal.timeInMillis - } catch (e: Exception) { - 0L - } - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt deleted file mode 100644 index 60a5918..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneResult.kt +++ /dev/null @@ -1,12 +0,0 @@ -package com.example.androidapp.routing - -/** - * The result of an isochrone weather routing computation. - * - * @param path Ordered list of [RoutePoint]s from the start to the destination. - * @param etaMs Estimated Time of Arrival as a UNIX timestamp in milliseconds. - */ -data class IsochroneResult( - val path: List, - val etaMs: Long -) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt deleted file mode 100644 index 901fdbc..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/routing/IsochroneRouter.kt +++ /dev/null @@ -1,178 +0,0 @@ -package com.example.androidapp.routing - -import org.terst.nav.data.model.BoatPolars -import org.terst.nav.data.model.WindForecast -import kotlin.math.asin -import kotlin.math.atan2 -import kotlin.math.cos -import kotlin.math.pow -import kotlin.math.sin -import kotlin.math.sqrt - -/** - * Isochrone-based weather routing engine (Section 3.4). - * - * Algorithm: - * 1. Start from a single point; expand a fan of headings at each time step. - * 2. For each candidate heading, compute BSP from [BoatPolars] at the local forecast wind. - * 3. Advance position by BSP × Δt using the spherical-Earth destination-point formula. - * 4. Check whether the destination has been reached (within [arrivalRadiusM]). - * 5. Prune candidates: for each angular sector around the start, keep only the point that - * advanced furthest (removes dominated points). - * 6. Repeat until the destination is reached or [maxSteps] is exhausted. - * 7. Backtrace parent pointers to produce the optimal path. - */ -object IsochroneRouter { - - private const val EARTH_RADIUS_M = 6_371_000.0 - internal const val NM_TO_M = 1_852.0 - private const val KT_TO_M_PER_S = NM_TO_M / 3600.0 - - const val DEFAULT_HEADING_STEP_DEG = 5.0 - const val DEFAULT_ARRIVAL_RADIUS_M = 1_852.0 // 1 NM - const val DEFAULT_PRUNE_SECTORS = 72 // 5° sectors - const val DEFAULT_MAX_STEPS = 200 - - /** - * Compute an optimised route from start to destination. - * - * @param startLat Start latitude (decimal degrees). - * @param startLon Start longitude (decimal degrees). - * @param destLat Destination latitude (decimal degrees). - * @param destLon Destination longitude (decimal degrees). - * @param startTimeMs Departure time as UNIX timestamp (ms). - * @param stepMs Time increment per isochrone step (ms). Typical: 1–3 hours. - * @param polars Boat polar table. - * @param windAt Function returning [WindForecast] for a given position and time. - * @param headingStepDeg Angular resolution of the heading fan (degrees). Default 5°. - * @param arrivalRadiusM Distance threshold to consider destination reached (metres). - * @param maxSteps Maximum number of isochrone expansions before giving up. - * @return [IsochroneResult] with the optimal path and ETA, or null if unreachable. - */ - fun route( - startLat: Double, - startLon: Double, - destLat: Double, - destLon: Double, - startTimeMs: Long, - stepMs: Long, - polars: BoatPolars, - windAt: (lat: Double, lon: Double, timeMs: Long) -> WindForecast, - headingStepDeg: Double = DEFAULT_HEADING_STEP_DEG, - arrivalRadiusM: Double = DEFAULT_ARRIVAL_RADIUS_M, - maxSteps: Int = DEFAULT_MAX_STEPS - ): IsochroneResult? { - val start = RoutePoint(startLat, startLon, startTimeMs) - var isochrone = listOf(start) - - repeat(maxSteps) { step -> - val nextTimeMs = startTimeMs + (step + 1).toLong() * stepMs - val candidates = mutableListOf() - - for (point in isochrone) { - var heading = 0.0 - while (heading < 360.0) { - val wind = windAt(point.lat, point.lon, point.timestampMs) - val twa = ((heading - wind.twdDeg + 360.0) % 360.0) - val bspKt = polars.bsp(twa, wind.twsKt) - if (bspKt > 0.0) { - val distM = bspKt * KT_TO_M_PER_S * (stepMs / 1000.0) - val (newLat, newLon) = destinationPoint(point.lat, point.lon, heading, distM) - val newPoint = RoutePoint(newLat, newLon, nextTimeMs, parent = point) - - if (haversineM(newLat, newLon, destLat, destLon) <= arrivalRadiusM) { - return IsochroneResult( - path = backtrace(newPoint), - etaMs = nextTimeMs - ) - } - candidates.add(newPoint) - } - heading += headingStepDeg - } - } - - if (candidates.isEmpty()) return null - isochrone = prune(candidates, startLat, startLon, DEFAULT_PRUNE_SECTORS) - } - - return null - } - - /** Walk parent pointers from destination back to start, then reverse. */ - internal fun backtrace(dest: RoutePoint): List { - val path = mutableListOf() - var current: RoutePoint? = dest - while (current != null) { - path.add(current) - current = current.parent - } - path.reverse() - return path - } - - /** - * Angular-sector pruning: divide the plane into [sectors] equal angular sectors around the - * start. Within each sector keep only the candidate that is furthest from the start. - */ - internal fun prune( - candidates: List, - startLat: Double, - startLon: Double, - sectors: Int - ): List { - val sectorSize = 360.0 / sectors - val best = mutableMapOf() - - for (point in candidates) { - val bearing = bearingDeg(startLat, startLon, point.lat, point.lon) - val sector = (bearing / sectorSize).toInt().coerceIn(0, sectors - 1) - val existing = best[sector] - if (existing == null || - haversineM(startLat, startLon, point.lat, point.lon) > - haversineM(startLat, startLon, existing.lat, existing.lon) - ) { - best[sector] = point - } - } - - return best.values.toList() - } - - /** Haversine great-circle distance in metres. */ - internal fun haversineM(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double { - val dLat = Math.toRadians(lat2 - lat1) - val dLon = Math.toRadians(lon2 - lon1) - val a = sin(dLat / 2).pow(2) + - cos(Math.toRadians(lat1)) * cos(Math.toRadians(lat2)) * sin(dLon / 2).pow(2) - return 2.0 * EARTH_RADIUS_M * asin(sqrt(a)) - } - - /** Initial bearing from point 1 to point 2 (degrees, 0 = North, clockwise). */ - internal fun bearingDeg(lat1Deg: Double, lon1Deg: Double, lat2Deg: Double, lon2Deg: Double): Double { - val lat1 = Math.toRadians(lat1Deg) - val lat2 = Math.toRadians(lat2Deg) - val dLon = Math.toRadians(lon2Deg - lon1Deg) - val y = sin(dLon) * cos(lat2) - val x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon) - return (Math.toDegrees(atan2(y, x)) + 360.0) % 360.0 - } - - /** Spherical-Earth destination-point given start, bearing, and distance. */ - internal fun destinationPoint( - lat1Deg: Double, - lon1Deg: Double, - bearingDeg: Double, - distM: Double - ): Pair { - val lat1 = Math.toRadians(lat1Deg) - val lon1 = Math.toRadians(lon1Deg) - val brng = Math.toRadians(bearingDeg) - val d = distM / EARTH_RADIUS_M - - val lat2 = asin(sin(lat1) * cos(d) + cos(lat1) * sin(d) * cos(brng)) - val lon2 = lon1 + atan2(sin(brng) * sin(d) * cos(lat1), cos(d) - sin(lat1) * sin(lat2)) - - return Pair(Math.toDegrees(lat2), Math.toDegrees(lon2)) - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt b/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt deleted file mode 100644 index 02988d1..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/routing/RoutePoint.kt +++ /dev/null @@ -1,16 +0,0 @@ -package com.example.androidapp.routing - -/** - * A single point in the isochrone routing tree. - * - * @param lat Latitude (decimal degrees). - * @param lon Longitude (decimal degrees). - * @param timestampMs UNIX time in milliseconds when this position is reached. - * @param parent The previous [RoutePoint] (null for the start point). - */ -data class RoutePoint( - val lat: Double, - val lon: Double, - val timestampMs: Long, - val parent: RoutePoint? = null -) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt b/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt deleted file mode 100644 index f544f63..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/safety/AnchorWatchState.kt +++ /dev/null @@ -1,24 +0,0 @@ -package com.example.androidapp.safety - -import kotlin.math.sqrt - -/** - * Holds UI-facing state for the anchor watch setup screen and provides - * the suggested watch-circle radius derived from depth and rode out. - */ -class AnchorWatchState { - - /** - * Returns the recommended watch-circle radius (metres) for the given depth - * and amount of rode deployed. - * - * Uses the Pythagorean formula sqrt(rode² - vertical²) when the geometry is - * valid (rode > depth + freeboard). Falls back to [rodeOutM] itself as the - * maximum possible swing radius when the rode is too short to form a catenary angle. - */ - fun calculateRecommendedWatchCircleRadius(depthM: Double, rodeOutM: Double): Double { - val vertical = depthM + 2.0 // 2 m default freeboard - return if (rodeOutM > vertical) sqrt(rodeOutM * rodeOutM - vertical * vertical) - else rodeOutM - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt b/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt deleted file mode 100644 index 2bdbf6c..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/tide/HarmonicTideCalculator.kt +++ /dev/null @@ -1,88 +0,0 @@ -package com.example.androidapp.tide - -import com.example.androidapp.data.model.TidePrediction -import com.example.androidapp.data.model.TideStation -import kotlin.math.cos - -/** - * Computes harmonic tide predictions using the standard formula: - * h(t) = Z0 + Σ [ Hi × cos( ωi × (t − t0) − φi ) ] - * - * where: - * Z0 = datum offset (mean water level above chart datum, metres) - * Hi = amplitude of constituent i (metres) - * ωi = angular speed of constituent i (degrees / hour) - * t = hours elapsed since [EPOCH_MS] (2000-01-01 00:00 UTC) - * φi = phase lag (degrees) - */ -object HarmonicTideCalculator { - - /** Reference epoch: 2000-01-01 00:00:00 UTC in Unix milliseconds. */ - internal const val EPOCH_MS = 946_684_800_000L - - /** - * Predict the tide height at a single moment. - * - * @param station Tide station with harmonic constituents. - * @param timestampMs Unix epoch milliseconds for the desired time. - * @return Predicted height in metres above chart datum. - */ - fun predictHeight(station: TideStation, timestampMs: Long): Double { - val hoursFromEpoch = (timestampMs - EPOCH_MS) / 3_600_000.0 - var height = station.datumOffsetMeters - for (c in station.constituents) { - val angleDeg = c.speedDegPerHour * hoursFromEpoch - c.phaseDeg - height += c.amplitudeMeters * cos(Math.toRadians(angleDeg)) - } - return height - } - - /** - * Predict tide heights over a time range at regular intervals. - * - * @param station Tide station. - * @param fromMs Start of range (Unix milliseconds, inclusive). - * @param toMs End of range (Unix milliseconds, inclusive). - * @param intervalMs Time step in milliseconds (must be positive). - * @return List of [TidePrediction] ordered by ascending timestamp. - */ - fun predictRange( - station: TideStation, - fromMs: Long, - toMs: Long, - intervalMs: Long - ): List { - require(intervalMs > 0) { "intervalMs must be positive" } - require(fromMs <= toMs) { "fromMs must not exceed toMs" } - val predictions = mutableListOf() - var t = fromMs - while (t <= toMs) { - predictions += TidePrediction(t, predictHeight(station, t)) - t += intervalMs - } - return predictions - } - - /** - * Find high and low water events from a pre-computed prediction series. - * - * Detects local maxima (high water) and minima (low water) by comparing - * each interior sample with its immediate neighbours. - * - * @param predictions Ordered list of tide predictions (at least 3 points). - * @return Subset list containing only high/low turning points. - */ - fun findHighLow(predictions: List): List { - if (predictions.size < 3) return emptyList() - val result = mutableListOf() - for (i in 1 until predictions.size - 1) { - val prev = predictions[i - 1].heightMeters - val curr = predictions[i].heightMeters - val next = predictions[i + 1].heightMeters - val isMax = curr >= prev && curr >= next - val isMin = curr <= prev && curr <= next - if (isMax || isMin) result += predictions[i] - } - return result - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt b/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt deleted file mode 100644 index 289a857..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/ui/anchorwatch/AnchorWatchHandler.kt +++ /dev/null @@ -1,58 +0,0 @@ -package com.example.androidapp.ui.anchorwatch - -import android.os.Bundle -import android.text.Editable -import android.text.TextWatcher -import android.view.LayoutInflater -import android.view.View -import android.view.ViewGroup -import androidx.fragment.app.Fragment -import org.terst.nav.R -import org.terst.nav.databinding.FragmentAnchorWatchBinding -import com.example.androidapp.safety.AnchorWatchState - -class AnchorWatchHandler : Fragment() { - - private var _binding: FragmentAnchorWatchBinding? = null - private val binding get() = _binding!! - - private val anchorWatchState = AnchorWatchState() - - override fun onCreateView( - inflater: LayoutInflater, container: ViewGroup?, - savedInstanceState: Bundle? - ): View { - _binding = FragmentAnchorWatchBinding.inflate(inflater, container, false) - return binding.root - } - - override fun onViewCreated(view: View, savedInstanceState: Bundle?) { - super.onViewCreated(view, savedInstanceState) - - val watcher = object : TextWatcher { - override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit - override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit - override fun afterTextChanged(s: Editable?) = updateSuggestedRadius() - } - binding.etDepth.addTextChangedListener(watcher) - binding.etRodeOut.addTextChangedListener(watcher) - } - - private fun updateSuggestedRadius() { - val depth = binding.etDepth.text.toString().toDoubleOrNull() - val rode = binding.etRodeOut.text.toString().toDoubleOrNull() - - if (depth != null && rode != null && depth >= 0.0 && rode > 0.0) { - val radius = anchorWatchState.calculateRecommendedWatchCircleRadius(depth, rode) - binding.tvSuggestedRadius.text = - getString(R.string.anchor_suggested_radius_fmt, radius) - } else { - binding.tvSuggestedRadius.text = getString(R.string.anchor_suggested_radius_empty) - } - } - - override fun onDestroyView() { - super.onDestroyView() - _binding = null - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/wind/ApparentWind.kt b/android-app/app/src/main/kotlin/com/example/androidapp/wind/ApparentWind.kt deleted file mode 100644 index 01656a3..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/wind/ApparentWind.kt +++ /dev/null @@ -1,3 +0,0 @@ -package com.example.androidapp.wind - -data class ApparentWind(val speedKt: Double, val angleDeg: Double) diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindCalculator.kt b/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindCalculator.kt deleted file mode 100644 index db32163..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindCalculator.kt +++ /dev/null @@ -1,20 +0,0 @@ -package com.example.androidapp.wind - -import kotlin.math.atan2 -import kotlin.math.cos -import kotlin.math.sin -import kotlin.math.sqrt - -class TrueWindCalculator { - fun update(apparent: ApparentWind, bsp: Double, hdgDeg: Double): TrueWindData { - val awaRad = Math.toRadians(apparent.angleDeg) - val awX = apparent.speedKt * cos(awaRad) - val awY = apparent.speedKt * sin(awaRad) - val twX = awX - bsp - val twY = awY - val tws = sqrt(twX * twX + twY * twY) - val twaDeg = Math.toDegrees(atan2(twY, twX)) - val twdDeg = ((hdgDeg + twaDeg) % 360 + 360) % 360 - return TrueWindData(speedKt = tws, directionDeg = twdDeg) - } -} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindData.kt b/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindData.kt deleted file mode 100644 index 78e9558..0000000 --- a/android-app/app/src/main/kotlin/com/example/androidapp/wind/TrueWindData.kt +++ /dev/null @@ -1,3 +0,0 @@ -package com.example.androidapp.wind - -data class TrueWindData(val speedKt: Double, val directionDeg: Double) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/AnchorWatchData.kt b/android-app/app/src/main/kotlin/org/terst/nav/AnchorWatchData.kt deleted file mode 100644 index 0c63662..0000000 --- a/android-app/app/src/main/kotlin/org/terst/nav/AnchorWatchData.kt +++ /dev/null @@ -1,57 +0,0 @@ -package org.terst.nav - -import android.location.Location -import kotlin.math.* - -data class AnchorWatchState( - val anchorLocation: Location? = null, - val watchCircleRadiusMeters: Double = DEFAULT_WATCH_CIRCLE_RADIUS_METERS, - val setTimeMillis: Long = 0L, - val isActive: Boolean = false -) { - companion object { - const val DEFAULT_WATCH_CIRCLE_RADIUS_METERS = 50.0 // Default 50 meters - - /** - * Calculates the recommended watch circle radius based on depth, freeboard, and rode out. - * Formula from docs/COMPONENT_DESIGN.md: Rode Out × cos(asin((Depth + Freeboard) / Rode Out)) - * - * @param depthMeters Depth from surface to seabed in meters. - * @param freeboardMeters Distance from surface to anchor attachment point on boat in meters. - * @param rodeOutMeters Length of chain/rode deployed in meters. - * @return Recommended watch circle radius in meters. Returns 0.0 if inputs are invalid. - */ - fun calculateRecommendedWatchCircleRadius( - depthMeters: Double, - freeboardMeters: Double, - rodeOutMeters: Double - ): Double { - if (rodeOutMeters <= 0 || depthMeters < 0 || freeboardMeters < 0) { - return 0.0 // Invalid inputs - } - - val totalVerticalDistance = depthMeters + freeboardMeters - - // Ensure we don't take asin of a value > 1 or < -1 - if (totalVerticalDistance > rodeOutMeters) { - // Rode is too short for the depth+freeboard, effectively boat is directly above anchor - // In this case, the watch circle radius is 0, or very small. - return 0.0 - } - - // angle = asin( (Depth + Freeboard) / Rode Out ) - val angle = asin(totalVerticalDistance / rodeOutMeters) - - // Watch circle radius = Rode Out * cos(angle) - return rodeOutMeters * cos(angle) - } - } - - fun isDragging(currentLocation: Location): Boolean { - anchorLocation ?: return false // Cannot drag if anchor not set - if (!isActive) return false // Not active, so not dragging - - val distance = anchorLocation.distanceTo(currentLocation) - return distance > watchCircleRadiusMeters - } -} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/LocationService.kt b/android-app/app/src/main/kotlin/org/terst/nav/LocationService.kt index 138fc6c..b18db8d 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/LocationService.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/LocationService.kt @@ -20,12 +20,18 @@ import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.SharedFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.update +import kotlinx.coroutines.flow.asStateFlow import org.terst.nav.nmea.NmeaParser import org.terst.nav.nmea.NmeaStreamManager import org.terst.nav.sensors.DepthData import org.terst.nav.sensors.HeadingData import org.terst.nav.sensors.WindData import org.terst.nav.gps.GpsPosition +import org.terst.nav.data.model.SensorData +import org.terst.nav.safety.AnchorWatchState +import org.terst.nav.wind.TrueWindCalculator +import org.terst.nav.wind.ApparentWind +import org.terst.nav.wind.TrueWindData import kotlinx.coroutines.flow.collectLatest import kotlinx.coroutines.tasks.await import kotlinx.coroutines.CoroutineScope @@ -34,22 +40,23 @@ import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.cancel import kotlinx.coroutines.launch -data class GpsData( - val latitude: Double, - val longitude: Double, - val speedOverGround: Float, // m/s - val courseOverGround: Float // degrees -) { - fun toLocation(): Location { - val location = Location("GpsData") - location.latitude = latitude - location.longitude = longitude - location.speed = speedOverGround - location.bearing = courseOverGround - return location - } -} - +/** Source of the currently active GPS fix. */ +enum class GpsSource { NONE, NMEA, ANDROID } + +/** + * Point-in-time snapshot of wind and current conditions. + */ +data class EnvironmentalSnapshot( + val windSpeedKt: Double?, + val windDirectionDeg: Double?, + val currentSpeedKt: Double?, + val currentDirectionDeg: Double? +) + +/** + * Aggregates real-time location and environmental sensor data for use throughout + * the navigation subsystem. + */ class LocationService : Service() { private lateinit var fusedLocationClient: FusedLocationProviderClient @@ -60,22 +67,30 @@ class LocationService : Service() { private lateinit var nmeaStreamManager: NmeaStreamManager private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob()) + private val windCalculator = TrueWindCalculator() + + // GPS sensor fusion state + private var lastNmeaPosition: GpsPosition? = null + private var lastAndroidPosition: GpsPosition? = null + private val nmeaStalenessThresholdMs: Long = 5_000L + private val nmeaExtendedThresholdMs: Long = 10_000L + private val NOTIFICATION_CHANNEL_ID = "location_service_channel" private val NOTIFICATION_ID = 123 - private var isAlarmTriggered = false // To prevent repeated alarm triggering + private var isAlarmTriggered = false override fun onCreate() { super.onCreate() Log.d("LocationService", "Service created") fusedLocationClient = LocationServices.getFusedLocationProviderClient(this) - anchorAlarmManager = AnchorAlarmManager(this) // Initialize with service context + anchorAlarmManager = AnchorAlarmManager(this) barometerSensorManager = BarometerSensorManager(this) nmeaParser = NmeaParser() nmeaStreamManager = NmeaStreamManager(nmeaParser, serviceScope) createNotificationChannel() - // Observe barometer status and update our public state + // Observe barometer status serviceScope.launch { barometerSensorManager.barometerStatus.collect { status -> _barometerStatus.value = status @@ -84,14 +99,17 @@ class LocationService : Service() { // Collect NMEA GPS positions serviceScope.launch { - nmeaStreamManager.nmeaGpsPosition.collectLatest { gpsPosition -> - _nmeaGpsPositionFlow.emit(gpsPosition) + nmeaStreamManager.nmeaGpsPosition.collectLatest { position -> + lastNmeaPosition = position + recomputeBestPosition() + _nmeaGpsPositionFlow.emit(position) } } // Collect NMEA Wind Data serviceScope.launch { nmeaStreamManager.nmeaWindData.collectLatest { windData -> + updateTrueWindFromNmea(windData) _nmeaWindDataFlow.emit(windData) } } @@ -110,26 +128,22 @@ class LocationService : Service() { } } - // Mock tidal current data generator - serviceScope.launch { - while (true) { - val currents = MockTidalCurrentGenerator.generateMockCurrents() - _tidalCurrentState.update { it.copy(currents = currents) } - kotlinx.coroutines.delay(60000) // Update every minute - } - } - locationCallback = object : LocationCallback() { override fun onLocationResult(locationResult: LocationResult) { locationResult.lastLocation?.let { location -> - val gpsData = GpsData( + val position = GpsPosition( latitude = location.latitude, longitude = location.longitude, - speedOverGround = location.speed, - courseOverGround = location.bearing + sog = location.speed * 1.94384, // m/s to knots + cog = location.bearing.toDouble(), + timestampMs = location.time, + accuracyMeters = if (location.hasAccuracy()) location.accuracy.toDouble() else null ) + lastAndroidPosition = position + recomputeBestPosition() + serviceScope.launch { - _locationFlow.emit(gpsData) // Emit to shared flow (Android system GPS) + _locationFlow.emit(position) } // Check for anchor drag if anchor watch is active @@ -139,32 +153,71 @@ class LocationService : Service() { } } - /** - * Checks if the current location is outside the anchor watch circle. - */ + private fun recomputeBestPosition() { + val now = System.currentTimeMillis() + val nmea = lastNmeaPosition + val android = lastAndroidPosition + + val nmeaAge = nmea?.let { now - it.timestampMs } + val nmeaFresh = nmeaAge != null && nmeaAge <= nmeaStalenessThresholdMs + val nmeaMarginallyStale = nmeaAge != null && + nmeaAge > nmeaStalenessThresholdMs && + nmeaAge <= nmeaExtendedThresholdMs + + val (best, source) = when { + nmeaFresh -> nmea!! to GpsSource.NMEA + + nmeaMarginallyStale && android != null -> + if (nmea!!.hasStrictlyBetterAccuracyThan(android)) nmea to GpsSource.NMEA + else android to GpsSource.ANDROID + + android != null -> android to GpsSource.ANDROID + nmea != null -> nmea to GpsSource.NMEA + else -> null to GpsSource.NONE + } + + _bestPosition.value = best + _activeGpsSource.value = source + } + + private fun GpsPosition.hasStrictlyBetterAccuracyThan(other: GpsPosition): Boolean { + val thisAccuracy = accuracyMeters ?: return false + val otherAccuracy = other.accuracyMeters ?: return true + return thisAccuracy < otherAccuracy + } + + private fun updateTrueWindFromNmea(wind: WindData) { + val sog = _bestPosition.value?.sog + val hdg = _nmeaHeadingDataFlow.replayCache.firstOrNull()?.headingDegreesTrue + + if (sog != null && hdg != null) { + _latestTrueWind.value = windCalculator.update( + apparent = ApparentWind(speedKt = wind.windSpeed, angleDeg = wind.windAngle), + bsp = sog, // Use SOG as proxy for BSP if BSP is not available + hdgDeg = hdg + ) + } + } + private fun checkAnchorDrag(location: Location) { _anchorWatchState.update { currentState -> if (currentState.isActive && currentState.anchorLocation != null) { val isDragging = currentState.isDragging(location) if (isDragging) { - Log.w("AnchorWatch", "!!! ANCHOR DRAG DETECTED !!! Distance: ${currentState.anchorLocation.distanceTo(location)}m, Radius: ${currentState.watchCircleRadiusMeters}m") + Log.w("AnchorWatch", "!!! ANCHOR DRAG DETECTED !!!") if (!isAlarmTriggered) { anchorAlarmManager.startAlarm() isAlarmTriggered = true } } else { - Log.d("AnchorWatch", "Anchor holding. Distance: ${currentState.anchorLocation.distanceTo(location)}m, Radius: ${currentState.watchCircleRadiusMeters}m") if (isAlarmTriggered) { anchorAlarmManager.stopAlarm() isAlarmTriggered = false } } - } else { - // If anchor watch is not active, ensure alarm is stopped - if (isAlarmTriggered) { - anchorAlarmManager.stopAlarm() - isAlarmTriggered = false - } + } else if (isAlarmTriggered) { + anchorAlarmManager.stopAlarm() + isAlarmTriggered = false } currentState } @@ -173,24 +226,21 @@ class LocationService : Service() { override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { when (intent?.action) { ACTION_START_FOREGROUND_SERVICE -> { - Log.d("LocationService", "Starting foreground service") startForeground(NOTIFICATION_ID, createNotification()) serviceScope.launch { - _currentPowerMode.emit(PowerMode.FULL) // Set initial power mode to FULL + _currentPowerMode.emit(PowerMode.FULL) startLocationUpdatesInternal(PowerMode.FULL) } barometerSensorManager.start() nmeaStreamManager.start(NMEA_GATEWAY_IP, NMEA_GATEWAY_PORT) } ACTION_STOP_FOREGROUND_SERVICE -> { - Log.d("LocationService", "Stopping foreground service") stopLocationUpdatesInternal() barometerSensorManager.stop() nmeaStreamManager.stop() stopSelf() } ACTION_START_ANCHOR_WATCH -> { - Log.d("LocationService", "Received ACTION_START_ANCHOR_WATCH") val radius = intent.getDoubleExtra(EXTRA_WATCH_RADIUS, AnchorWatchState.DEFAULT_WATCH_CIRCLE_RADIUS_METERS) serviceScope.launch { startAnchorWatch(radius) @@ -198,45 +248,34 @@ class LocationService : Service() { } } ACTION_STOP_ANCHOR_WATCH -> { - Log.d("LocationService", "Received ACTION_STOP_ANCHOR_WATCH") stopAnchorWatch() - setPowerMode(PowerMode.FULL) // Revert to full power mode after stopping anchor watch + setPowerMode(PowerMode.FULL) } ACTION_UPDATE_WATCH_RADIUS -> { - Log.d("LocationService", "Received ACTION_UPDATE_WATCH_RADIUS") val radius = intent.getDoubleExtra(EXTRA_WATCH_RADIUS, AnchorWatchState.DEFAULT_WATCH_CIRCLE_RADIUS_METERS) updateWatchCircleRadius(radius) } - ACTION_TOGGLE_TIDAL_VISIBILITY -> { - val isVisible = intent.getBooleanExtra(EXTRA_TIDAL_VISIBILITY, false) - _tidalCurrentState.update { it.copy(isVisible = isVisible) } - } } return START_NOT_STICKY } - override fun onBind(intent: Intent?): IBinder? { - return null // Not a bound service - } + override fun onBind(intent: Intent?): IBinder? = null override fun onDestroy() { super.onDestroy() - Log.d("LocationService", "Service destroyed") stopLocationUpdatesInternal() anchorAlarmManager.stopAlarm() barometerSensorManager.stop() - nmeaStreamManager.stop() // Stop NMEA stream when service is destroyed + nmeaStreamManager.stop() _anchorWatchState.value = AnchorWatchState(isActive = false) - isAlarmTriggered = false // Reset alarm trigger state - serviceScope.cancel() // Cancel the coroutine scope + isAlarmTriggered = false + serviceScope.cancel() } - @SuppressLint("MissingPermission") private fun startLocationUpdatesInternal(powerMode: PowerMode) { - Log.d("LocationService", "Requesting location updates with PowerMode: ${powerMode.name}, interval: ${powerMode.gpsUpdateIntervalMillis}ms") val locationRequest = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, powerMode.gpsUpdateIntervalMillis) - .setMinUpdateIntervalMillis(powerMode.gpsUpdateIntervalMillis / 2) // Half the interval for minUpdateInterval + .setMinUpdateIntervalMillis(powerMode.gpsUpdateIntervalMillis / 2) .build() fusedLocationClient.requestLocationUpdates( locationRequest, @@ -246,22 +285,15 @@ class LocationService : Service() { } private fun stopLocationUpdatesInternal() { - Log.d("LocationService", "Removing location updates") fusedLocationClient.removeLocationUpdates(locationCallback) } fun setPowerMode(powerMode: PowerMode) { serviceScope.launch { if (_currentPowerMode.value != powerMode) { - // Emit the new power mode first _currentPowerMode.emit(powerMode) - Log.d("LocationService", "Power mode changing to ${powerMode.name}. Restarting location updates.") - // Stop current updates if running stopLocationUpdatesInternal() - // Start new updates with the new power mode's interval startLocationUpdatesInternal(powerMode) - } else { - Log.d("LocationService", "Power mode already ${powerMode.name}. No change needed.") } } } @@ -278,25 +310,15 @@ class LocationService : Service() { private fun createNotification(): Notification { val notificationIntent = Intent(this, MainActivity::class.java) - val pendingIntent = PendingIntent.getActivity( - this, - 0, - notificationIntent, - PendingIntent.FLAG_IMMUTABLE - ) - + val pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE) return NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID) .setContentTitle("Sailing Companion") - .setContentText("Tracking your location in the background...") + .setContentText("Tracking your location...") .setSmallIcon(R.drawable.ic_anchor) .setContentIntent(pendingIntent) .build() } - /** - * Starts the anchor watch with the current location as the anchor point. - * @param radiusMeters The watch circle radius in meters. - */ @SuppressLint("MissingPermission") suspend fun startAnchorWatch(radiusMeters: Double = AnchorWatchState.DEFAULT_WATCH_CIRCLE_RADIUS_METERS) { val lastLocation = fusedLocationClient.lastLocation.await() @@ -307,29 +329,27 @@ class LocationService : Service() { setTimeMillis = System.currentTimeMillis(), isActive = true ) } - Log.i("AnchorWatch", "Anchor watch started at lat: ${location.latitude}, lon: ${location.longitude} with radius: ${radiusMeters}m") - } ?: run { - Log.e("AnchorWatch", "Could not start anchor watch: Last known location is null.") - // Handle error, e.g., show a toast to the user } } - /** - * Stops the anchor watch. - */ fun stopAnchorWatch() { _anchorWatchState.update { AnchorWatchState(isActive = false) } - Log.i("AnchorWatch", "Anchor watch stopped.") anchorAlarmManager.stopAlarm() isAlarmTriggered = false } - /** - * Updates the watch circle radius. - */ fun updateWatchCircleRadius(radiusMeters: Double) { _anchorWatchState.update { it.copy(watchCircleRadiusMeters = radiusMeters) } - Log.d("AnchorWatch", "Watch circle radius updated to ${radiusMeters}m.") + } + + fun snapshot(): EnvironmentalSnapshot { + val trueWind = _latestTrueWind.value + return EnvironmentalSnapshot( + windSpeedKt = trueWind?.speedKt, + windDirectionDeg = trueWind?.directionDeg, + currentSpeedKt = null, // TODO: Pull from latest forecast + currentDirectionDeg = null + ) } companion object { @@ -338,56 +358,42 @@ class LocationService : Service() { const val ACTION_START_ANCHOR_WATCH = "ACTION_START_ANCHOR_WATCH" const val ACTION_STOP_ANCHOR_WATCH = "ACTION_STOP_ANCHOR_WATCH" const val ACTION_UPDATE_WATCH_RADIUS = "ACTION_UPDATE_WATCH_RADIUS" - const val ACTION_TOGGLE_TIDAL_VISIBILITY = "ACTION_TOGGLE_TIDAL_VISIBILITY" const val EXTRA_WATCH_RADIUS = "extra_watch_radius" - const val EXTRA_TIDAL_VISIBILITY = "extra_tidal_visibility" - - // NMEA Gateway configuration (example values - these should ideally be configurable by the user) - private const val NMEA_GATEWAY_IP = "192.168.1.1" // Placeholder IP address - private const val NMEA_GATEWAY_PORT = 10110 // Default NMEA port - - // Publicly accessible flows - val locationFlow: SharedFlow - get() = _locationFlow - val anchorWatchState: StateFlow - get() = _anchorWatchState - val tidalCurrentState: StateFlow - get() = _tidalCurrentState - val barometerStatus: StateFlow - get() = _barometerStatus - - // NMEA Data Flows - val nmeaGpsPositionFlow: SharedFlow - get() = _nmeaGpsPositionFlow - val nmeaWindDataFlow: SharedFlow - get() = _nmeaWindDataFlow - val nmeaDepthDataFlow: SharedFlow - get() = _nmeaDepthDataFlow - val nmeaHeadingDataFlow: SharedFlow - get() = _nmeaHeadingDataFlow - - private val _locationFlow = MutableSharedFlow(replay = 1) + + private const val NMEA_GATEWAY_IP = "192.168.1.1" + private const val NMEA_GATEWAY_PORT = 10110 + + private val _locationFlow = MutableSharedFlow(replay = 1) + val locationFlow: SharedFlow get() = _locationFlow + + private val _bestPosition = MutableStateFlow(null) + val bestPosition: StateFlow = _bestPosition.asStateFlow() + + private val _activeGpsSource = MutableStateFlow(GpsSource.NONE) + val activeGpsSource: StateFlow = _activeGpsSource.asStateFlow() + private val _anchorWatchState = MutableStateFlow(AnchorWatchState()) - private val _tidalCurrentState = MutableStateFlow(TidalCurrentState()) + val anchorWatchState: StateFlow get() = _anchorWatchState + private val _barometerStatus = MutableStateFlow(BarometerStatus()) + val barometerStatus: StateFlow get() = _barometerStatus - // Private NMEA Data Flows - private val _nmeaGpsPositionFlow = MutableSharedFlow( - replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST - ) - private val _nmeaWindDataFlow = MutableSharedFlow( - replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST - ) - private val _nmeaDepthDataFlow = MutableSharedFlow( - replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST - ) - private val _nmeaHeadingDataFlow = MutableSharedFlow( - replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST - ) + private val _latestTrueWind = MutableStateFlow(null) + val latestTrueWind: StateFlow = _latestTrueWind.asStateFlow() + + private val _nmeaGpsPositionFlow = MutableSharedFlow(replay = 1) + val nmeaGpsPositionFlow: SharedFlow get() = _nmeaGpsPositionFlow + + private val _nmeaWindDataFlow = MutableSharedFlow(replay = 1) + val nmeaWindDataFlow: SharedFlow get() = _nmeaWindDataFlow + + private val _nmeaDepthDataFlow = MutableSharedFlow(replay = 1) + val nmeaDepthDataFlow: SharedFlow get() = _nmeaDepthDataFlow + + private val _nmeaHeadingDataFlow = MutableSharedFlow(replay = 1) + val nmeaHeadingDataFlow: SharedFlow get() = _nmeaHeadingDataFlow private val _currentPowerMode = MutableStateFlow(PowerMode.FULL) - val currentPowerMode: StateFlow - get() = _currentPowerMode + val currentPowerMode: StateFlow get() = _currentPowerMode } } - 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 3f09309..fd2cf61 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 @@ -39,6 +39,7 @@ import org.terst.nav.ui.doc.DocFragment import org.terst.nav.ui.safety.SafetyFragment import org.terst.nav.ui.voicelog.VoiceLogFragment import java.util.* +import org.terst.nav.safety.AnchorWatchState class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { @@ -46,7 +47,6 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { private var mobHandler: MobHandler? = null private var instrumentHandler: InstrumentHandler? = null private var mapHandler: MapHandler? = null - private var anchorWatchHandler: AnchorWatchHandler? = null private val loadedStyleFlow = MutableStateFlow(null) private lateinit var bottomSheetBehavior: BottomSheetBehavior @@ -186,7 +186,7 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { } override fun onConfigureAnchor() { - anchorWatchHandler?.toggleVisibility() + // Now handled via fragment navigation from SafetyFragment } private fun setupHandlers() { @@ -305,13 +305,12 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { lifecycleScope.launch { LocationService.locationFlow.collect { gpsData -> mapHandler?.centerOnLocation(gpsData.latitude, gpsData.longitude) - mapHandler?.updateUserPosition(gpsData.latitude, gpsData.longitude, gpsData.courseOverGround) - val sogKnots = gpsData.speedOverGround * 1.94384 - val cogDeg = gpsData.courseOverGround - viewModel.addGpsPoint(gpsData.latitude, gpsData.longitude, sogKnots, cogDeg.toDouble()) + mapHandler?.updateUserPosition(gpsData.latitude, gpsData.longitude, gpsData.cog.toFloat()) + + viewModel.addGpsPoint(gpsData.latitude, gpsData.longitude, gpsData.sog, gpsData.cog) instrumentHandler?.updateDisplay( - sog = "%.1f".format(Locale.getDefault(), sogKnots), - cog = "%.0f°".format(Locale.getDefault(), cogDeg) + sog = "%.1f".format(Locale.getDefault(), gpsData.sog), + cog = "%.0f°".format(Locale.getDefault(), gpsData.cog) ) if (!conditionsLoaded) { conditionsLoaded = true diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/SensorData.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/SensorData.kt new file mode 100644 index 0000000..fc1d79d --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/SensorData.kt @@ -0,0 +1,10 @@ +package org.terst.nav.data.model + +data class SensorData( + val latitude: Double? = null, + val longitude: Double? = null, + val headingTrueDeg: Double? = null, + val apparentWindSpeedKt: Double? = null, + val apparentWindAngleDeg: Double? = null, + val speedOverGroundKt: Double? = null +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/storage/GribFileManager.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/storage/GribFileManager.kt index e17e5ca..6a976f6 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/data/storage/GribFileManager.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/storage/GribFileManager.kt @@ -5,38 +5,20 @@ import org.terst.nav.data.model.GribRegion import java.time.Instant interface GribFileManager { - /** Save metadata for a newly-downloaded GRIB file. */ fun saveMetadata(file: GribFile) - /** Return all stored GRIB files for [region], newest first. */ fun listFiles(region: GribRegion): List - /** Return the most-recently-downloaded GRIB file for [region], or null if none. */ fun latestFile(region: GribRegion): GribFile? - /** Delete a specific GRIB file's metadata and from disk. Returns true if deleted. */ fun delete(file: GribFile): Boolean - /** Delete all GRIB files older than [before]. Returns count of deleted files. */ fun purgeOlderThan(before: Instant): Int - /** Total size in bytes of all stored GRIB files. */ fun totalSizeBytes(): Long } class InMemoryGribFileManager : GribFileManager { private val files = mutableListOf() - override fun saveMetadata(file: GribFile) { files.add(file) } - - override fun listFiles(region: GribRegion): List = - files.filter { it.region.name == region.name } - .sortedByDescending { it.downloadedAt } - + override fun listFiles(region: GribRegion): List = files.filter { it.region.name == region.name }.sortedByDescending { it.downloadedAt } override fun latestFile(region: GribRegion): GribFile? = listFiles(region).firstOrNull() - override fun delete(file: GribFile): Boolean = files.remove(file) - - override fun purgeOlderThan(before: Instant): Int { - val toRemove = files.filter { it.downloadedAt.isBefore(before) } - files.removeAll(toRemove) - return toRemove.size - } - + override fun purgeOlderThan(before: Instant): Int { val toRemove = files.filter { it.downloadedAt.isBefore(before) }; files.removeAll(toRemove); return toRemove.size } override fun totalSizeBytes(): Long = files.sumOf { it.sizeBytes } } diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/weather/GribStalenessChecker.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/weather/GribStalenessChecker.kt new file mode 100644 index 0000000..f39957b --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/weather/GribStalenessChecker.kt @@ -0,0 +1,36 @@ +package org.terst.nav.data.weather + +import org.terst.nav.data.model.GribFile +import org.terst.nav.data.storage.GribFileManager +import org.terst.nav.data.model.GribRegion +import java.time.Instant + +/** Outcome of a freshness check. */ +sealed class FreshnessResult { + /** Data is current; no user action needed. */ + object Fresh : FreshnessResult() + /** Data is stale; user should re-download. [message] is shown in the UI badge. */ + data class Stale(val file: GribFile, val message: String) : FreshnessResult() + /** No local GRIB data exists for this region. */ + object NoData : FreshnessResult() +} + +/** + * Checks whether locally-stored GRIB data for a region is fresh or stale. + * Per design doc §6.3: GRIB weather valid until model run + forecast hour; stale after. + */ +class GribStalenessChecker(private val manager: GribFileManager) { + + /** + * Check freshness of the most-recent GRIB file for [region] relative to [now]. + */ + fun check(region: GribRegion, now: Instant = Instant.now()): FreshnessResult { + val latest = manager.latestFile(region) ?: return FreshnessResult.NoData + return if (latest.isStale(now)) { + val hoursAgo = (now.epochSecond - latest.validUntil().epochSecond) / 3600 + FreshnessResult.Stale(latest, "Weather data outdated by ${hoursAgo}h — tap to refresh") + } else { + FreshnessResult.Fresh + } + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/weather/SatelliteGribDownloader.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/weather/SatelliteGribDownloader.kt new file mode 100644 index 0000000..875d971 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/data/weather/SatelliteGribDownloader.kt @@ -0,0 +1,134 @@ +package org.terst.nav.data.weather + +import org.terst.nav.data.model.GribFile +import org.terst.nav.data.model.GribParameter +import org.terst.nav.data.model.GribRegion +import org.terst.nav.data.model.SatelliteDownloadRequest +import org.terst.nav.data.storage.GribFileManager +import java.time.Instant +import kotlin.math.ceil +import kotlin.math.floor + +/** + * Downloads GRIB weather data over bandwidth-constrained satellite links (§9.1). + * + * Provides size and time estimates before fetching, and aborts if the download + * would exceed the configured size limit (default 2 MB — the upper bound stated + * in §9.1 for typical offshore GRIBs on satellite). + * + * The actual network fetch is supplied as a [fetcher] lambda so the class remains + * testable without network access. + */ +class SatelliteGribDownloader(private val fileManager: GribFileManager) { + + companion object { + /** Iridium data link speed in bits per second. */ + const val SATELLITE_BANDWIDTH_BPS = 2400L + + /** GRIB2 packed grid value: ~2 bytes per grid point after packing. */ + private const val BYTES_PER_GRID_POINT = 2L + + /** Per-message header overhead in GRIB2 format (section 0-4). */ + private const val HEADER_BYTES_PER_MESSAGE = 100L + + /** Forecast time step used for size estimation (3-hourly is standard GFS output). */ + private const val TIME_STEP_HOURS = 3 + + /** Default maximum download size; abort if estimate exceeds this. */ + const val DEFAULT_SIZE_LIMIT_BYTES = 2_000_000L + } + + /** + * Estimates the GRIB file size in bytes for [request]. + * + * Formula: (gridPoints × timeSteps × paramCount × bytesPerPoint) + headerOverhead + * where gridPoints = ceil(latSpan/resolution + 1) × ceil(lonSpan/resolution + 1). + */ + fun estimateSizeBytes(request: SatelliteDownloadRequest): Long { + val latPoints = floor((request.region.latMax - request.region.latMin) / request.resolutionDeg).toLong() + 1 + val lonPoints = floor((request.region.lonMax - request.region.lonMin) / request.resolutionDeg).toLong() + 1 + val gridPoints = latPoints * lonPoints + val timeSteps = ceil(request.forecastHours.toDouble() / TIME_STEP_HOURS).toLong() + val paramCount = request.parameters.size.toLong() + val dataBytes = gridPoints * timeSteps * paramCount * BYTES_PER_GRID_POINT + val headerBytes = paramCount * timeSteps * HEADER_BYTES_PER_MESSAGE + return dataBytes + headerBytes + } + + /** + * Estimates how many seconds the download will take at [bandwidthBps] bits/second. + */ + fun estimatedDownloadSeconds( + request: SatelliteDownloadRequest, + bandwidthBps: Long = SATELLITE_BANDWIDTH_BPS + ): Long = ceil(estimateSizeBytes(request) * 8.0 / bandwidthBps).toLong() + + /** + * Convenience builder: creates a [SatelliteDownloadRequest] using the minimal + * satellite parameter set (wind speed + direction + surface pressure only). + */ + fun buildMinimalRequest( + region: GribRegion, + forecastHours: Int, + resolutionDeg: Double = 1.0 + ): SatelliteDownloadRequest = SatelliteDownloadRequest( + region = region, + parameters = GribParameter.SATELLITE_MINIMAL, + forecastHours = forecastHours, + resolutionDeg = resolutionDeg + ) + + /** Result of a satellite GRIB download attempt. */ + sealed class DownloadResult { + /** Download succeeded; [file] metadata has been saved to [GribFileManager]. */ + data class Success(val file: GribFile) : DownloadResult() + /** The [fetcher] returned no data or an unexpected error occurred. */ + data class Failed(val reason: String) : DownloadResult() + /** + * Download was aborted before starting because the estimated size + * [estimatedBytes] exceeds the configured limit. + */ + data class Aborted(val reason: String, val estimatedBytes: Long) : DownloadResult() + } + + /** + * Downloads GRIB data for [request]. + * + * 1. Estimates size; returns [DownloadResult.Aborted] if > [sizeLimitBytes]. + * 2. Calls [fetcher] to retrieve raw bytes. + * 3. On success, saves metadata via [fileManager] and returns [DownloadResult.Success]. + * + * @param request The bandwidth-optimised download request. + * @param fetcher Supplies raw GRIB bytes for the request; returns null on failure. + * @param outputPath Local file path where the caller will persist the bytes. + * @param sizeLimitBytes Abort threshold (default [DEFAULT_SIZE_LIMIT_BYTES]). + * @param now Timestamp injected for testing. + */ + fun download( + request: SatelliteDownloadRequest, + fetcher: (SatelliteDownloadRequest) -> ByteArray?, + outputPath: String, + sizeLimitBytes: Long = DEFAULT_SIZE_LIMIT_BYTES, + now: Instant = Instant.now() + ): DownloadResult { + val estimated = estimateSizeBytes(request) + if (estimated > sizeLimitBytes) { + return DownloadResult.Aborted( + "Estimated size ${estimated / 1024}KB exceeds limit ${sizeLimitBytes / 1024}KB — " + + "reduce region, resolution, or forecast hours", + estimated + ) + } + val bytes = fetcher(request) ?: return DownloadResult.Failed("Fetcher returned no data") + val gribFile = GribFile( + region = request.region, + modelRunTime = now, + forecastHours = request.forecastHours, + downloadedAt = now, + filePath = outputPath, + sizeBytes = bytes.size.toLong() + ) + fileManager.saveMetadata(gribFile) + return DownloadResult.Success(gribFile) + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/gps/GpsPosition.kt b/android-app/app/src/main/kotlin/org/terst/nav/gps/GpsPosition.kt index 5faf30c..99cef2d 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/gps/GpsPosition.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/gps/GpsPosition.kt @@ -1,9 +1,20 @@ package org.terst.nav.gps +/** + * Represents a single GPS fix. + * + * @param latitude Degrees, positive = North, negative = South. + * @param longitude Degrees, positive = East, negative = West. + * @param sog Speed Over Ground in knots. + * @param cog Course Over Ground in degrees true (0-360). + * @param timestampMs Unix epoch milliseconds UTC. + * @param accuracyMeters Estimated horizontal accuracy (1-sigma) in meters; null if unknown. + */ data class GpsPosition( val latitude: Double, val longitude: Double, - val sog: Double, // knots - val cog: Double, // degrees true - val timestampMs: Long + val sog: Double, + val cog: Double, + val timestampMs: Long, + val accuracyMeters: Double? = null ) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookFormatter.kt b/android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookFormatter.kt new file mode 100644 index 0000000..67cfcce --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookFormatter.kt @@ -0,0 +1,81 @@ +package org.terst.nav.logbook + +import org.terst.nav.data.model.LogbookEntry +import java.util.Calendar +import java.util.TimeZone + +data class LogbookRow( + val time: String, + val position: String, + val sog: String, + val cog: String, + val wind: String, + val baro: String, + val depth: String, + val eventNotes: String +) + +data class LogbookPage( + val title: String, + val columns: List, + val rows: List +) + +object LogbookFormatter { + + val COLUMNS = listOf( + "Time (UTC)", "Position", "SOG", "COG", "Wind", "Baro", "Depth", "Event / Notes" + ) + + private val COMPASS_POINTS = arrayOf( + "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", + "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW" + ) + + fun formatTime(timestampMs: Long): String { + val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC")) + cal.timeInMillis = timestampMs + return "%02d:%02d".format( + cal.get(Calendar.HOUR_OF_DAY), + cal.get(Calendar.MINUTE) + ) + } + + fun formatPosition(lat: Double, lon: Double): String { + val latDir = if (lat >= 0) "N" else "S" + val lonDir = if (lon >= 0) "E" else "W" + val absLat = Math.abs(lat) + val absLon = Math.abs(lon) + val latDeg = absLat.toInt() + val lonDeg = absLon.toInt() + val latMin = (absLat - latDeg) * 60.0 + val lonMin = (absLon - lonDeg) * 60.0 + return "%d°%.1f%s %d°%.1f%s".format(latDeg, latMin, latDir, lonDeg, lonMin, lonDir) + } + + fun toCompassPoint(degrees: Double): String { + val normalized = ((degrees % 360.0) + 360.0) % 360.0 + val index = ((normalized + 11.25) / 22.5).toInt() % 16 + return COMPASS_POINTS[index] + } + + fun formatWind(knots: Double?, directionDeg: Double?): String { + if (knots == null) return "" + val knotsStr = "%.0fkt".format(knots) + return if (directionDeg == null) knotsStr else "$knotsStr ${toCompassPoint(directionDeg)}" + } + + fun toRow(entry: LogbookEntry): LogbookRow = LogbookRow( + time = formatTime(entry.timestampMs), + position = formatPosition(entry.lat, entry.lon), + sog = "%.1f".format(entry.sogKnots), + cog = "%.0f".format(entry.cogDegrees), + wind = formatWind(entry.windKnots, entry.windDirectionDeg), + baro = entry.baroHpa?.let { "%.0f".format(it) } ?: "", + depth = entry.depthMeters?.let { "%.0fm".format(it) } ?: "", + eventNotes = listOfNotNull(entry.event, entry.notes).joinToString(": ") + ) + + fun toPage(entries: List, title: String = "Trip Logbook"): LogbookPage = + LogbookPage(title = title, columns = COLUMNS, rows = entries.map { toRow(it) }) +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookPdfExporter.kt b/android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookPdfExporter.kt new file mode 100644 index 0000000..6417db9 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/logbook/LogbookPdfExporter.kt @@ -0,0 +1,137 @@ +package org.terst.nav.logbook + +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.Paint +import android.graphics.Typeface +import android.graphics.pdf.PdfDocument +import org.terst.nav.data.model.LogbookEntry +import java.io.OutputStream + +/** + * Renders trip logbook entries to a formatted PDF (landscape A4). + * Section 4.8 — Trip Logging and Electronic Logbook. + */ +object LogbookPdfExporter { + + // Landscape A4 in points (1 point = 1/72 inch) + private const val PAGE_WIDTH = 842 + private const val PAGE_HEIGHT = 595 + private const val MARGIN = 36f + private const val ROW_HEIGHT = 22f + private const val HEADER_HEIGHT = 36f + private const val TITLE_SIZE = 16f + private const val CELL_TEXT_SIZE = 9f + + // Column width fractions (must sum to 1.0) + private val COL_FRACTIONS = floatArrayOf( + 0.08f, // Time + 0.18f, // Position + 0.06f, // SOG + 0.06f, // COG + 0.10f, // Wind + 0.07f, // Baro + 0.07f, // Depth + 0.38f // Event / Notes + ) + + fun export( + entries: List, + outputStream: OutputStream, + title: String = "Trip Logbook" + ) { + val page = LogbookFormatter.toPage(entries, title) + val document = PdfDocument() + try { + val pageInfo = PdfDocument.PageInfo.Builder(PAGE_WIDTH, PAGE_HEIGHT, 1).create() + val pdfPage = document.startPage(pageInfo) + drawPage(pdfPage.canvas, page) + document.finishPage(pdfPage) + document.writeTo(outputStream) + } finally { + document.close() + } + } + + private fun drawPage(canvas: Canvas, page: LogbookPage) { + val usableWidth = PAGE_WIDTH - 2 * MARGIN + val colWidths = COL_FRACTIONS.map { it * usableWidth } + + val titlePaint = Paint().apply { + textSize = TITLE_SIZE + typeface = Typeface.DEFAULT_BOLD + color = Color.BLACK + } + val headerTextPaint = Paint().apply { + textSize = CELL_TEXT_SIZE + typeface = Typeface.DEFAULT_BOLD + color = Color.WHITE + } + val cellPaint = Paint().apply { + textSize = CELL_TEXT_SIZE + color = Color.BLACK + } + val linePaint = Paint().apply { + color = Color.LTGRAY + strokeWidth = 0.5f + } + val headerBgPaint = Paint().apply { + color = Color.rgb(41, 82, 123) + style = Paint.Style.FILL + } + val altBgPaint = Paint().apply { + color = Color.rgb(235, 242, 252) + style = Paint.Style.FILL + } + val borderPaint = Paint().apply { + color = Color.DKGRAY + strokeWidth = 1f + style = Paint.Style.STROKE + } + + var y = MARGIN + + // Title + canvas.drawText(page.title, MARGIN, y + TITLE_SIZE, titlePaint) + y += HEADER_HEIGHT + + val tableTop = y + + // Column header background + canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, headerBgPaint) + + // Column header text + var x = MARGIN + 3f + page.columns.forEachIndexed { i, col -> + canvas.drawText(col, x, y + ROW_HEIGHT - 6f, headerTextPaint) + x += colWidths[i] + } + y += ROW_HEIGHT + + // Data rows + page.rows.forEach { row -> + if (y + ROW_HEIGHT > PAGE_HEIGHT - MARGIN) return@forEach + + if (page.rows.indexOf(row) % 2 == 1) { + canvas.drawRect(MARGIN, y, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, altBgPaint) + } + + val cells = listOf( + row.time, row.position, row.sog, row.cog, + row.wind, row.baro, row.depth, row.eventNotes + ) + x = MARGIN + 3f + cells.forEachIndexed { i, cell -> + val maxChars = (colWidths[i] / (CELL_TEXT_SIZE * 0.55)).toInt().coerceAtLeast(4) + canvas.drawText(cell.take(maxChars), x, y + ROW_HEIGHT - 6f, cellPaint) + x += colWidths[i] + } + + canvas.drawLine(MARGIN, y + ROW_HEIGHT, PAGE_WIDTH - MARGIN, y + ROW_HEIGHT, linePaint) + y += ROW_HEIGHT + } + + // Table border + canvas.drawRect(MARGIN, tableTop, PAGE_WIDTH - MARGIN, y, borderPaint) + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/nmea/NmeaParser.kt b/android-app/app/src/main/kotlin/org/terst/nav/nmea/NmeaParser.kt index 453c758..6a470b8 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/nmea/NmeaParser.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/nmea/NmeaParser.kt @@ -273,8 +273,9 @@ class NmeaParser { val hours = timeStr.substring(0, 2).toInt() val minutes = timeStr.substring(2, 4).toInt() val seconds = timeStr.substring(4, 6).toInt() - val millis = if (timeStr.length > 7) { - (timeStr.substring(7).toDoubleOrNull()?.times(1000.0))?.toInt() ?: 0 + val millis = if (timeStr.contains('.')) { + val fracStr = timeStr.substringAfter('.') + ("0.$fracStr".toDoubleOrNull()?.times(1000.0))?.toInt() ?: 0 } else 0 cal.set(Calendar.HOUR_OF_DAY, hours) cal.set(Calendar.MINUTE, minutes) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneResult.kt b/android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneResult.kt new file mode 100644 index 0000000..13fb132 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneResult.kt @@ -0,0 +1,12 @@ +package org.terst.nav.routing + +/** + * The result of an isochrone weather routing computation. + * + * @param path Ordered list of [RoutePoint]s from the start to the destination. + * @param etaMs Estimated Time of Arrival as a UNIX timestamp in milliseconds. + */ +data class IsochroneResult( + val path: List, + val etaMs: Long +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneRouter.kt b/android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneRouter.kt new file mode 100644 index 0000000..8ac73cf --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/routing/IsochroneRouter.kt @@ -0,0 +1,178 @@ +package org.terst.nav.routing + +import org.terst.nav.data.model.BoatPolars +import org.terst.nav.data.model.WindForecast +import kotlin.math.asin +import kotlin.math.atan2 +import kotlin.math.cos +import kotlin.math.pow +import kotlin.math.sin +import kotlin.math.sqrt + +/** + * Isochrone-based weather routing engine (Section 3.4). + * + * Algorithm: + * 1. Start from a single point; expand a fan of headings at each time step. + * 2. For each candidate heading, compute BSP from [BoatPolars] at the local forecast wind. + * 3. Advance position by BSP × Δt using the spherical-Earth destination-point formula. + * 4. Check whether the destination has been reached (within [arrivalRadiusM]). + * 5. Prune candidates: for each angular sector around the start, keep only the point that + * advanced furthest (removes dominated points). + * 6. Repeat until the destination is reached or [maxSteps] is exhausted. + * 7. Backtrace parent pointers to produce the optimal path. + */ +object IsochroneRouter { + + private const val EARTH_RADIUS_M = 6_371_000.0 + internal const val NM_TO_M = 1_852.0 + private const val KT_TO_M_PER_S = NM_TO_M / 3600.0 + + const val DEFAULT_HEADING_STEP_DEG = 5.0 + const val DEFAULT_ARRIVAL_RADIUS_M = 1_852.0 // 1 NM + const val DEFAULT_PRUNE_SECTORS = 72 // 5° sectors + const val DEFAULT_MAX_STEPS = 200 + + /** + * Compute an optimised route from start to destination. + * + * @param startLat Start latitude (decimal degrees). + * @param startLon Start longitude (decimal degrees). + * @param destLat Destination latitude (decimal degrees). + * @param destLon Destination longitude (decimal degrees). + * @param startTimeMs Departure time as UNIX timestamp (ms). + * @param stepMs Time increment per isochrone step (ms). Typical: 1–3 hours. + * @param polars Boat polar table. + * @param windAt Function returning [WindForecast] for a given position and time. + * @param headingStepDeg Angular resolution of the heading fan (degrees). Default 5°. + * @param arrivalRadiusM Distance threshold to consider destination reached (metres). + * @param maxSteps Maximum number of isochrone expansions before giving up. + * @return [IsochroneResult] with the optimal path and ETA, or null if unreachable. + */ + fun route( + startLat: Double, + startLon: Double, + destLat: Double, + destLon: Double, + startTimeMs: Long, + stepMs: Long, + polars: BoatPolars, + windAt: (lat: Double, lon: Double, timeMs: Long) -> WindForecast, + headingStepDeg: Double = DEFAULT_HEADING_STEP_DEG, + arrivalRadiusM: Double = DEFAULT_ARRIVAL_RADIUS_M, + maxSteps: Int = DEFAULT_MAX_STEPS + ): IsochroneResult? { + val start = RoutePoint(startLat, startLon, startTimeMs) + var isochrone = listOf(start) + + repeat(maxSteps) { step -> + val nextTimeMs = startTimeMs + (step + 1).toLong() * stepMs + val candidates = mutableListOf() + + for (point in isochrone) { + var heading = 0.0 + while (heading < 360.0) { + val wind = windAt(point.lat, point.lon, point.timestampMs) + val twa = ((heading - wind.twdDeg + 360.0) % 360.0) + val bspKt = polars.bsp(twa, wind.twsKt) + if (bspKt > 0.0) { + val distM = bspKt * KT_TO_M_PER_S * (stepMs / 1000.0) + val (newLat, newLon) = destinationPoint(point.lat, point.lon, heading, distM) + val newPoint = RoutePoint(newLat, newLon, nextTimeMs, parent = point) + + if (haversineM(newLat, newLon, destLat, destLon) <= arrivalRadiusM) { + return IsochroneResult( + path = backtrace(newPoint), + etaMs = nextTimeMs + ) + } + candidates.add(newPoint) + } + heading += headingStepDeg + } + } + + if (candidates.isEmpty()) return null + isochrone = prune(candidates, startLat, startLon, DEFAULT_PRUNE_SECTORS) + } + + return null + } + + /** Walk parent pointers from destination back to start, then reverse. */ + internal fun backtrace(dest: RoutePoint): List { + val path = mutableListOf() + var current: RoutePoint? = dest + while (current != null) { + path.add(current) + current = current.parent + } + path.reverse() + return path + } + + /** + * Angular-sector pruning: divide the plane into [sectors] equal angular sectors around the + * start. Within each sector keep only the candidate that is furthest from the start. + */ + internal fun prune( + candidates: List, + startLat: Double, + startLon: Double, + sectors: Int + ): List { + val sectorSize = 360.0 / sectors + val best = mutableMapOf() + + for (point in candidates) { + val bearing = bearingDeg(startLat, startLon, point.lat, point.lon) + val sector = (bearing / sectorSize).toInt().coerceIn(0, sectors - 1) + val existing = best[sector] + if (existing == null || + haversineM(startLat, startLon, point.lat, point.lon) > + haversineM(startLat, startLon, existing.lat, existing.lon) + ) { + best[sector] = point + } + } + + return best.values.toList() + } + + /** Haversine great-circle distance in metres. */ + internal fun haversineM(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double { + val dLat = Math.toRadians(lat2 - lat1) + val dLon = Math.toRadians(lon2 - lon1) + val a = sin(dLat / 2).pow(2) + + cos(Math.toRadians(lat1)) * cos(Math.toRadians(lat2)) * sin(dLon / 2).pow(2) + return 2.0 * EARTH_RADIUS_M * asin(sqrt(a)) + } + + /** Initial bearing from point 1 to point 2 (degrees, 0 = North, clockwise). */ + internal fun bearingDeg(lat1Deg: Double, lon1Deg: Double, lat2Deg: Double, lon2Deg: Double): Double { + val lat1 = Math.toRadians(lat1Deg) + val lat2 = Math.toRadians(lat2Deg) + val dLon = Math.toRadians(lon2Deg - lon1Deg) + val y = sin(dLon) * cos(lat2) + val x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon) + return (Math.toDegrees(atan2(y, x)) + 360.0) % 360.0 + } + + /** Spherical-Earth destination-point given start, bearing, and distance. */ + internal fun destinationPoint( + lat1Deg: Double, + lon1Deg: Double, + bearingDeg: Double, + distM: Double + ): Pair { + val lat1 = Math.toRadians(lat1Deg) + val lon1 = Math.toRadians(lon1Deg) + val brng = Math.toRadians(bearingDeg) + val d = distM / EARTH_RADIUS_M + + val lat2 = asin(sin(lat1) * cos(d) + cos(lat1) * sin(d) * cos(brng)) + val lon2 = lon1 + atan2(sin(brng) * sin(d) * cos(lat1), cos(d) - sin(lat1) * sin(lat2)) + + return Pair(Math.toDegrees(lat2), Math.toDegrees(lon2)) + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/routing/RoutePoint.kt b/android-app/app/src/main/kotlin/org/terst/nav/routing/RoutePoint.kt new file mode 100644 index 0000000..a6562d9 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/routing/RoutePoint.kt @@ -0,0 +1,16 @@ +package org.terst.nav.routing + +/** + * A single point in the isochrone routing tree. + * + * @param lat Latitude (decimal degrees). + * @param lon Longitude (decimal degrees). + * @param timestampMs UNIX time in milliseconds when this position is reached. + * @param parent The previous [RoutePoint] (null for the start point). + */ +data class RoutePoint( + val lat: Double, + val lon: Double, + val timestampMs: Long, + val parent: RoutePoint? = null +) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/safety/AnchorWatchState.kt b/android-app/app/src/main/kotlin/org/terst/nav/safety/AnchorWatchState.kt new file mode 100644 index 0000000..9121ce6 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/safety/AnchorWatchState.kt @@ -0,0 +1,40 @@ +package org.terst.nav.safety + +import android.location.Location +import kotlin.math.* + +/** + * Holds state for the anchor watch and provides the suggested watch-circle radius. + */ +data class AnchorWatchState( + val anchorLocation: Location? = null, + val watchCircleRadiusMeters: Double = DEFAULT_WATCH_CIRCLE_RADIUS_METERS, + val setTimeMillis: Long = 0L, + val isActive: Boolean = false +) { + companion object { + const val DEFAULT_WATCH_CIRCLE_RADIUS_METERS = 50.0 + + /** + * Calculates the recommended watch circle radius based on depth, freeboard, and rode out. + */ + fun calculateRecommendedWatchCircleRadius( + depthMeters: Double, + freeboardMeters: Double, + rodeOutMeters: Double + ): Double { + if (rodeOutMeters <= 0 || depthMeters < 0 || freeboardMeters < 0) return 0.0 + val totalVerticalDistance = depthMeters + freeboardMeters + if (totalVerticalDistance > rodeOutMeters) return 0.0 + val angle = asin(totalVerticalDistance / rodeOutMeters) + return rodeOutMeters * cos(angle) + } + } + + fun isDragging(currentLocation: Location): Boolean { + anchorLocation ?: return false + if (!isActive) return false + val distance = anchorLocation.distanceTo(currentLocation) + return distance > watchCircleRadiusMeters + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/tide/HarmonicTideCalculator.kt b/android-app/app/src/main/kotlin/org/terst/nav/tide/HarmonicTideCalculator.kt new file mode 100644 index 0000000..b1e5652 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/tide/HarmonicTideCalculator.kt @@ -0,0 +1,88 @@ +package org.terst.nav.tide + +import com.example.androidapp.data.model.TidePrediction +import com.example.androidapp.data.model.TideStation +import kotlin.math.cos + +/** + * Computes harmonic tide predictions using the standard formula: + * h(t) = Z0 + Σ [ Hi × cos( ωi × (t − t0) − φi ) ] + * + * where: + * Z0 = datum offset (mean water level above chart datum, metres) + * Hi = amplitude of constituent i (metres) + * ωi = angular speed of constituent i (degrees / hour) + * t = hours elapsed since [EPOCH_MS] (2000-01-01 00:00 UTC) + * φi = phase lag (degrees) + */ +object HarmonicTideCalculator { + + /** Reference epoch: 2000-01-01 00:00:00 UTC in Unix milliseconds. */ + internal const val EPOCH_MS = 946_684_800_000L + + /** + * Predict the tide height at a single moment. + * + * @param station Tide station with harmonic constituents. + * @param timestampMs Unix epoch milliseconds for the desired time. + * @return Predicted height in metres above chart datum. + */ + fun predictHeight(station: TideStation, timestampMs: Long): Double { + val hoursFromEpoch = (timestampMs - EPOCH_MS) / 3_600_000.0 + var height = station.datumOffsetMeters + for (c in station.constituents) { + val angleDeg = c.speedDegPerHour * hoursFromEpoch - c.phaseDeg + height += c.amplitudeMeters * cos(Math.toRadians(angleDeg)) + } + return height + } + + /** + * Predict tide heights over a time range at regular intervals. + * + * @param station Tide station. + * @param fromMs Start of range (Unix milliseconds, inclusive). + * @param toMs End of range (Unix milliseconds, inclusive). + * @param intervalMs Time step in milliseconds (must be positive). + * @return List of [TidePrediction] ordered by ascending timestamp. + */ + fun predictRange( + station: TideStation, + fromMs: Long, + toMs: Long, + intervalMs: Long + ): List { + require(intervalMs > 0) { "intervalMs must be positive" } + require(fromMs <= toMs) { "fromMs must not exceed toMs" } + val predictions = mutableListOf() + var t = fromMs + while (t <= toMs) { + predictions += TidePrediction(t, predictHeight(station, t)) + t += intervalMs + } + return predictions + } + + /** + * Find high and low water events from a pre-computed prediction series. + * + * Detects local maxima (high water) and minima (low water) by comparing + * each interior sample with its immediate neighbours. + * + * @param predictions Ordered list of tide predictions (at least 3 points). + * @return Subset list containing only high/low turning points. + */ + fun findHighLow(predictions: List): List { + if (predictions.size < 3) return emptyList() + val result = mutableListOf() + for (i in 1 until predictions.size - 1) { + val prev = predictions[i - 1].heightMeters + val curr = predictions[i].heightMeters + val next = predictions[i + 1].heightMeters + val isMax = curr >= prev && curr >= next + val isMin = curr <= prev && curr <= next + if (isMax || isMin) result += predictions[i] + } + return result + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/AnchorWatchHandler.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/AnchorWatchHandler.kt deleted file mode 100644 index d55de90..0000000 --- a/android-app/app/src/main/kotlin/org/terst/nav/ui/AnchorWatchHandler.kt +++ /dev/null @@ -1,99 +0,0 @@ -package org.terst.nav.ui - -import android.content.Context -import android.content.Intent -import android.view.View -import android.widget.Button -import android.widget.TextView -import android.widget.Toast -import androidx.constraintlayout.widget.ConstraintLayout -import org.terst.nav.AnchorWatchState -import org.terst.nav.LocationService -import java.util.Locale - -/** - * Handles the Anchor Watch UI interactions and state updates. - */ -class AnchorWatchHandler( - private val context: Context, - private val container: ConstraintLayout, - private val statusText: TextView, - private val radiusText: TextView, - private val buttonDecrease: Button, - private val buttonIncrease: Button, - private val buttonSet: Button, - private val buttonStop: Button -) { - private var currentRadius = AnchorWatchState.DEFAULT_WATCH_CIRCLE_RADIUS_METERS - - init { - updateRadiusDisplay() - - buttonDecrease.setOnClickListener { - updateRadius((currentRadius - 5).coerceAtLeast(10.0)) - } - - buttonIncrease.setOnClickListener { - updateRadius((currentRadius + 5).coerceAtMost(200.0)) - } - - buttonSet.setOnClickListener { - startWatch() - } - - buttonStop.setOnClickListener { - stopWatch() - } - } - - private fun updateRadius(newRadius: Double) { - currentRadius = newRadius - updateRadiusDisplay() - val intent = Intent(context, LocationService::class.java).apply { - action = LocationService.ACTION_UPDATE_WATCH_RADIUS - putExtra(LocationService.EXTRA_WATCH_RADIUS, currentRadius) - } - context.startService(intent) - } - - private fun updateRadiusDisplay() { - radiusText.text = String.format(Locale.getDefault(), "Radius: %.1fm", currentRadius) - } - - private fun startWatch() { - val intent = Intent(context, LocationService::class.java).apply { - action = LocationService.ACTION_START_ANCHOR_WATCH - putExtra(LocationService.EXTRA_WATCH_RADIUS, currentRadius) - } - context.startService(intent) - Toast.makeText(context, "Anchor watch set!", Toast.LENGTH_SHORT).show() - } - - private fun stopWatch() { - val intent = Intent(context, LocationService::class.java).apply { - action = LocationService.ACTION_STOP_ANCHOR_WATCH - } - context.startService(intent) - Toast.makeText(context, "Anchor watch stopped.", Toast.LENGTH_SHORT).show() - } - - /** - * Updates the UI based on the current anchor watch state. - */ - fun updateUI(state: AnchorWatchState) { - statusText.text = if (state.isActive) { - "STATUS: ACTIVE" // Simple status for UI - } else { - "STATUS: INACTIVE" - } - currentRadius = state.watchCircleRadiusMeters - updateRadiusDisplay() - } - - /** - * Toggles the visibility of the anchor configuration container. - */ - fun toggleVisibility() { - container.visibility = if (container.visibility == View.VISIBLE) View.GONE else View.VISIBLE - } -} 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 4f08de7..bfefb6f 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 @@ -19,7 +19,7 @@ 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.safety.AnchorWatchState import org.terst.nav.TidalCurrentState import org.terst.nav.track.TrackPoint import kotlin.math.cos diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/anchorwatch/AnchorWatchHandler.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/anchorwatch/AnchorWatchHandler.kt new file mode 100644 index 0000000..d435f00 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/anchorwatch/AnchorWatchHandler.kt @@ -0,0 +1,58 @@ +package org.terst.nav.ui.anchorwatch + +import android.os.Bundle +import android.text.Editable +import android.text.TextWatcher +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import androidx.fragment.app.Fragment +import org.terst.nav.R +import org.terst.nav.databinding.FragmentAnchorWatchBinding +import org.terst.nav.safety.AnchorWatchState + +class AnchorWatchHandler : Fragment() { + + private var _binding: FragmentAnchorWatchBinding? = null + private val binding get() = _binding!! + + private val anchorWatchState = AnchorWatchState() + + override fun onCreateView( + inflater: LayoutInflater, container: ViewGroup?, + savedInstanceState: Bundle? + ): View { + _binding = FragmentAnchorWatchBinding.inflate(inflater, container, false) + return binding.root + } + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + super.onViewCreated(view, savedInstanceState) + + val watcher = object : TextWatcher { + override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit + override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit + override fun afterTextChanged(s: Editable?) = updateSuggestedRadius() + } + binding.etDepth.addTextChangedListener(watcher) + binding.etRodeOut.addTextChangedListener(watcher) + } + + private fun updateSuggestedRadius() { + val depth = binding.etDepth.text.toString().toDoubleOrNull() + val rode = binding.etRodeOut.text.toString().toDoubleOrNull() + + if (depth != null && rode != null && depth >= 0.0 && rode > 0.0) { + val radius = AnchorWatchState.calculateRecommendedWatchCircleRadius(depth, 2.0, rode) + binding.tvSuggestedRadius.text = + getString(R.string.anchor_suggested_radius_fmt, radius) + } else { + binding.tvSuggestedRadius.text = getString(R.string.anchor_suggested_radius_empty) + } + } + + override fun onDestroyView() { + super.onDestroyView() + _binding = null + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/wind/ApparentWind.kt b/android-app/app/src/main/kotlin/org/terst/nav/wind/ApparentWind.kt new file mode 100644 index 0000000..fd504cb --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/wind/ApparentWind.kt @@ -0,0 +1,3 @@ +package org.terst.nav.wind + +data class ApparentWind(val speedKt: Double, val angleDeg: Double) diff --git a/android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindCalculator.kt b/android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindCalculator.kt new file mode 100644 index 0000000..dc3117c --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindCalculator.kt @@ -0,0 +1,20 @@ +package org.terst.nav.wind + +import kotlin.math.atan2 +import kotlin.math.cos +import kotlin.math.sin +import kotlin.math.sqrt + +class TrueWindCalculator { + fun update(apparent: ApparentWind, bsp: Double, hdgDeg: Double): TrueWindData { + val awaRad = Math.toRadians(apparent.angleDeg) + val awX = apparent.speedKt * cos(awaRad) + val awY = apparent.speedKt * sin(awaRad) + val twX = awX - bsp + val twY = awY + val tws = sqrt(twX * twX + twY * twY) + val twaDeg = Math.toDegrees(atan2(twY, twX)) + val twdDeg = ((hdgDeg + twaDeg) % 360 + 360) % 360 + return TrueWindData(speedKt = tws, directionDeg = twdDeg) + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindData.kt b/android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindData.kt new file mode 100644 index 0000000..8c3ac56 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/wind/TrueWindData.kt @@ -0,0 +1,3 @@ +package org.terst.nav.wind + +data class TrueWindData(val speedKt: Double, val directionDeg: Double) diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt deleted file mode 100644 index 535e46a..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/GribStalenessCheckerTest.kt +++ /dev/null @@ -1,91 +0,0 @@ -package com.example.androidapp.data.weather - -import com.example.androidapp.data.model.GribFile -import com.example.androidapp.data.model.GribRegion -import com.example.androidapp.data.storage.InMemoryGribFileManager -import org.junit.Assert.* -import org.junit.Before -import org.junit.Test -import java.time.Instant - -class GribStalenessCheckerTest { - - private lateinit var manager: InMemoryGribFileManager - private lateinit var checker: GribStalenessChecker - private val region = GribRegion("test", 35.0, 40.0, -125.0, -120.0) - - @Before - fun setUp() { - manager = InMemoryGribFileManager() - checker = GribStalenessChecker(manager) - } - - private fun makeFile( - modelRunTime: Instant, - forecastHours: Int, - downloadedAt: Instant = modelRunTime - ) = GribFile( - region = region, - modelRunTime = modelRunTime, - forecastHours = forecastHours, - downloadedAt = downloadedAt, - filePath = "/tmp/test.grib", - sizeBytes = 1024L - ) - - @Test - fun `check_returnsFresh_whenFileIsNotStale`() { - val now = Instant.parse("2026-03-16T12:00:00Z") - // model run at 06:00, 24h forecast → valid until 06:00 next day, well beyond now - val file = makeFile( - modelRunTime = Instant.parse("2026-03-16T06:00:00Z"), - forecastHours = 24, - downloadedAt = Instant.parse("2026-03-16T07:00:00Z") - ) - manager.saveMetadata(file) - - val result = checker.check(region, now) - - assertTrue("Expected Fresh but got $result", result is FreshnessResult.Fresh) - } - - @Test - fun `check_returnsStale_whenFileIsExpired`() { - val now = Instant.parse("2026-03-16T20:00:00Z") - // model run at 06:00, 6h forecast → valid until 12:00; now is 8h after that - val file = makeFile( - modelRunTime = Instant.parse("2026-03-16T06:00:00Z"), - forecastHours = 6, - downloadedAt = Instant.parse("2026-03-16T07:00:00Z") - ) - manager.saveMetadata(file) - - val result = checker.check(region, now) - - assertTrue("Expected Stale but got $result", result is FreshnessResult.Stale) - val stale = result as FreshnessResult.Stale - assertTrue("Message should contain hours outdated", stale.message.contains("8h")) - assertEquals(file, stale.file) - } - - @Test - fun `check_returnsNoData_whenNoFilesForRegion`() { - val otherRegion = GribRegion("other", 50.0, 55.0, -10.0, 0.0) - val file = makeFile( - modelRunTime = Instant.parse("2026-03-16T06:00:00Z"), - forecastHours = 24 - ) - manager.saveMetadata(file) - - val result = checker.check(otherRegion, Instant.parse("2026-03-16T12:00:00Z")) - - assertEquals(FreshnessResult.NoData, result) - } - - @Test - fun `check_returnsNoData_whenManagerEmpty`() { - val result = checker.check(region, Instant.now()) - - assertEquals(FreshnessResult.NoData, result) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt deleted file mode 100644 index 4bf7985..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/data/weather/SatelliteGribDownloaderTest.kt +++ /dev/null @@ -1,180 +0,0 @@ -package com.example.androidapp.data.weather - -import com.example.androidapp.data.model.GribParameter -import com.example.androidapp.data.model.GribRegion -import com.example.androidapp.data.model.SatelliteDownloadRequest -import com.example.androidapp.data.storage.InMemoryGribFileManager -import org.junit.Assert.* -import org.junit.Before -import org.junit.Test -import java.time.Instant - -class SatelliteGribDownloaderTest { - - private lateinit var manager: InMemoryGribFileManager - private lateinit var downloader: SatelliteGribDownloader - - // 10°×10° region at 1°: 11×11 = 121 grid points - private val region10x10 = GribRegion("atlantic", 30.0, 40.0, -70.0, -60.0) - - @Before - fun setUp() { - manager = InMemoryGribFileManager() - downloader = SatelliteGribDownloader(manager) - } - - // ------------------------------------------------------------------ size estimation - - @Test - fun `estimateSizeBytes_scalesWithRegionArea`() { - // 10°×10° region: 11×11 = 121 grid points - val req10 = SatelliteDownloadRequest( - region = region10x10, - parameters = GribParameter.SATELLITE_MINIMAL, - forecastHours = 24 - ) - // 20°×20° region: 21×21 = 441 grid points — roughly 3.6× more grid points - val region20x20 = GribRegion("bigger", 20.0, 40.0, -80.0, -60.0) - val req20 = SatelliteDownloadRequest( - region = region20x20, - parameters = GribParameter.SATELLITE_MINIMAL, - forecastHours = 24 - ) - - val size10 = downloader.estimateSizeBytes(req10) - val size20 = downloader.estimateSizeBytes(req20) - - assertTrue("Larger region must produce larger estimate", size20 > size10) - } - - @Test - fun `estimateSizeBytes_scalesWithParameterCount`() { - val minimalReq = SatelliteDownloadRequest( - region = region10x10, - parameters = GribParameter.SATELLITE_MINIMAL, // 3 params - forecastHours = 24 - ) - val fullReq = SatelliteDownloadRequest( - region = region10x10, - parameters = GribParameter.values().toSet(), // all 7 params - forecastHours = 24 - ) - - val sizeMinimal = downloader.estimateSizeBytes(minimalReq) - val sizeFull = downloader.estimateSizeBytes(fullReq) - - assertTrue("More parameters must produce larger estimate", sizeFull > sizeMinimal) - } - - @Test - fun `estimateSizeBytes_coarserResolutionProducesSmallerFile`() { - val finReq = SatelliteDownloadRequest( - region = region10x10, - parameters = GribParameter.SATELLITE_MINIMAL, - forecastHours = 24, - resolutionDeg = 1.0 - ) - val coarseReq = SatelliteDownloadRequest( - region = region10x10, - parameters = GribParameter.SATELLITE_MINIMAL, - forecastHours = 24, - resolutionDeg = 2.0 - ) - - val sizeFine = downloader.estimateSizeBytes(finReq) - val sizeCoarse = downloader.estimateSizeBytes(coarseReq) - - assertTrue("Coarser resolution must produce smaller estimate", sizeCoarse < sizeFine) - } - - @Test - fun `estimatedDownloadSeconds_atIridiumBandwidth`() { - // 10°×10°, 3 params, 24h at 1° → known estimate - val req = SatelliteDownloadRequest( - region = region10x10, - parameters = GribParameter.SATELLITE_MINIMAL, - forecastHours = 24 - ) - val estBytes = downloader.estimateSizeBytes(req) - val expectedSeconds = Math.ceil(estBytes * 8.0 / SatelliteGribDownloader.SATELLITE_BANDWIDTH_BPS).toLong() - - val actualSeconds = downloader.estimatedDownloadSeconds(req) - - assertEquals(expectedSeconds, actualSeconds) - // Sanity: should be > 0 seconds and less than 10 minutes for a small region - assertTrue("Download estimate must be positive", actualSeconds > 0) - assertTrue("Small 10°×10° should complete in under 10 min at 2.4kbps", actualSeconds < 600) - } - - // ------------------------------------------------------------------ buildMinimalRequest - - @Test - fun `buildMinimalRequest_containsOnlyWindAndPressure`() { - val req = downloader.buildMinimalRequest(region10x10, 48) - - assertEquals(GribParameter.SATELLITE_MINIMAL, req.parameters) - assertTrue(req.parameters.contains(GribParameter.WIND_SPEED)) - assertTrue(req.parameters.contains(GribParameter.WIND_DIRECTION)) - assertTrue(req.parameters.contains(GribParameter.SURFACE_PRESSURE)) - assertFalse(req.parameters.contains(GribParameter.TEMPERATURE_2M)) - assertFalse(req.parameters.contains(GribParameter.PRECIPITATION)) - assertEquals(region10x10, req.region) - assertEquals(48, req.forecastHours) - } - - // ------------------------------------------------------------------ download() - - @Test - fun `download_abortsWhenEstimatedSizeExceedsLimit`() { - val req = downloader.buildMinimalRequest(region10x10, 24) - var fetcherCalled = false - - val result = downloader.download( - request = req, - fetcher = { fetcherCalled = true; ByteArray(100) }, - outputPath = "/tmp/test.grib", - sizeLimitBytes = 1L // ridiculously small limit - ) - - assertTrue("Should abort without calling fetcher", result is SatelliteGribDownloader.DownloadResult.Aborted) - assertFalse("Fetcher must not be called when aborting", fetcherCalled) - val aborted = result as SatelliteGribDownloader.DownloadResult.Aborted - assertTrue("Should report estimated bytes", aborted.estimatedBytes > 0) - } - - @Test - fun `download_returnsFailedWhenFetcherReturnsNull`() { - val req = downloader.buildMinimalRequest(region10x10, 24) - - val result = downloader.download( - request = req, - fetcher = { null }, - outputPath = "/tmp/test.grib" - ) - - assertTrue("Should fail when fetcher returns null", result is SatelliteGribDownloader.DownloadResult.Failed) - } - - @Test - fun `download_savesMetadataAndReturnsSuccessOnValidFetch`() { - val req = downloader.buildMinimalRequest(region10x10, 24) - val fakeBytes = ByteArray(8208) { 0x00 } - val now = Instant.parse("2026-03-16T12:00:00Z") - - val result = downloader.download( - request = req, - fetcher = { fakeBytes }, - outputPath = "/tmp/atlantic.grib", - now = now - ) - - assertTrue("Should succeed", result is SatelliteGribDownloader.DownloadResult.Success) - val success = result as SatelliteGribDownloader.DownloadResult.Success - assertEquals(region10x10, success.file.region) - assertEquals(24, success.file.forecastHours) - assertEquals(fakeBytes.size.toLong(), success.file.sizeBytes) - assertEquals("/tmp/atlantic.grib", success.file.filePath) - // Metadata must be persisted in the manager - assertNotNull(manager.latestFile(region10x10)) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt deleted file mode 100644 index 8b2753c..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/gps/GpsPositionTest.kt +++ /dev/null @@ -1,33 +0,0 @@ -package com.example.androidapp.gps - -import org.junit.Assert.* -import org.junit.Test - -class GpsPositionTest { - - @Test - fun `GpsPosition holds correct values`() { - val pos = GpsPosition( - latitude = 41.5, - longitude = -71.0, - sog = 5.2, - cog = 180.0, - timestampMs = 1_000L - ) - assertEquals(41.5, pos.latitude, 0.0) - assertEquals(-71.0, pos.longitude, 0.0) - assertEquals(5.2, pos.sog, 0.0) - assertEquals(180.0, pos.cog, 0.0) - assertEquals(1_000L, pos.timestampMs) - } - - @Test - fun `GpsPosition equality works as expected for data class`() { - val pos1 = GpsPosition(41.5, -71.0, 5.2, 180.0, 1_000L) - val pos2 = GpsPosition(41.5, -71.0, 5.2, 180.0, 1_000L) - val pos3 = GpsPosition(42.0, -70.0, 3.0, 90.0, 2_000L) - - assertEquals(pos1, pos2) - assertNotEquals(pos1, pos3) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt deleted file mode 100644 index 4eb9898..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/gps/LocationServiceTest.kt +++ /dev/null @@ -1,317 +0,0 @@ -package com.example.androidapp.gps - -import com.example.androidapp.data.model.SensorData -import kotlinx.coroutines.flow.first -import kotlinx.coroutines.runBlocking -import org.junit.Assert.* -import org.junit.Test - -class LocationServiceTest { - - private fun service() = LocationService() - - // ── snapshot with no data ───────────────────────────────────────────────── - - @Test - fun snapshot_noData_allFieldsNull() { - val snap = service().snapshot() - assertNull(snap.windSpeedKt) - assertNull(snap.windDirectionDeg) - assertNull(snap.currentSpeedKt) - assertNull(snap.currentDirectionDeg) - } - - // ── true-wind resolution ────────────────────────────────────────────────── - - @Test - fun updateSensorData_withFullReading_resolvesTrueWind() = runBlocking { - val svc = service() - // Head north (hdg = 0°), AWS = 10 kt coming from ahead (AWA = 0°), BSP = 5 kt - // → TW comes FROM ahead at 5 kt - svc.updateSensorData( - SensorData( - headingTrueDeg = 0.0, - apparentWindSpeedKt = 10.0, - apparentWindAngleDeg = 0.0, - speedOverGroundKt = 5.0 - ) - ) - val tw = svc.latestTrueWind.first() - assertNotNull(tw) - assertTrue("Expected TWS > 0", tw!!.speedKt > 0.0) - } - - @Test - fun updateSensorData_missingHeading_doesNotResolveTrueWind() = runBlocking { - val svc = service() - svc.updateSensorData( - SensorData( - apparentWindSpeedKt = 10.0, - apparentWindAngleDeg = 45.0, - speedOverGroundKt = 5.0 - // headingTrueDeg omitted - ) - ) - assertNull(svc.latestTrueWind.first()) - } - - // ── current conditions ──────────────────────────────────────────────────── - - @Test - fun updateCurrentConditions_reflectedInSnapshot() { - val svc = service() - svc.updateCurrentConditions(speedKt = 1.5, directionDeg = 135.0) - - val snap = svc.snapshot() - assertEquals(1.5, snap.currentSpeedKt!!, 0.001) - assertEquals(135.0, snap.currentDirectionDeg!!, 0.001) - } - - @Test - fun updateCurrentConditions_nullClears() { - val svc = service() - svc.updateCurrentConditions(speedKt = 2.0, directionDeg = 90.0) - svc.updateCurrentConditions(speedKt = null, directionDeg = null) - - val snap = svc.snapshot() - assertNull(snap.currentSpeedKt) - assertNull(snap.currentDirectionDeg) - } - - // ── combined snapshot ───────────────────────────────────────────────────── - - @Test - fun snapshot_afterFullUpdate_populatesAllFields() = runBlocking { - val svc = service() - - // Head east (hdg = 90°), wind from starboard bow, BSP proxy = 6 kt - svc.updateSensorData( - SensorData( - headingTrueDeg = 90.0, - apparentWindSpeedKt = 12.0, - apparentWindAngleDeg = 45.0, - speedOverGroundKt = 6.0 - ) - ) - svc.updateCurrentConditions(speedKt = 0.8, directionDeg = 270.0) - - val snap = svc.snapshot() - assertNotNull(snap.windSpeedKt) - assertNotNull(snap.windDirectionDeg) - assertEquals(0.8, snap.currentSpeedKt!!, 0.001) - assertEquals(270.0, snap.currentDirectionDeg!!, 0.001) - } - - // ── latestSensor flow ───────────────────────────────────────────────────── - - @Test - fun updateSensorData_updatesLatestSensorFlow() = runBlocking { - val svc = service() - assertNull(svc.latestSensor.first()) - - val data = SensorData(latitude = 41.5, longitude = -71.3) - svc.updateSensorData(data) - - assertEquals(data, svc.latestSensor.first()) - } - - // ── GPS sensor fusion ───────────────────────────────────────────────────── - - private fun fusionService( - nmeaStalenessThresholdMs: Long = 5_000L, - nmeaExtendedThresholdMs: Long = 10_000L, - clockMs: () -> Long = System::currentTimeMillis - ) = LocationService( - nmeaStalenessThresholdMs = nmeaStalenessThresholdMs, - nmeaExtendedThresholdMs = nmeaExtendedThresholdMs, - clockMs = clockMs - ) - - private fun pos(lat: Double, lon: Double, timestampMs: Long) = - GpsPosition(lat, lon, sog = 0.0, cog = 0.0, timestampMs = timestampMs) - - private fun posWithAccuracy(lat: Double, lon: Double, timestampMs: Long, accuracyMeters: Double) = - GpsPosition(lat, lon, sog = 0.0, cog = 0.0, timestampMs = timestampMs, accuracyMeters = accuracyMeters) - - @Test - fun noGpsData_bestPositionNullAndSourceNone() = runBlocking { - val svc = fusionService() - assertNull(svc.bestPosition.first()) - assertEquals(GpsSource.NONE, svc.activeGpsSource.first()) - } - - @Test - fun freshNmea_preferredOverAndroid() = runBlocking { - val now = 10_000L - val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) - - val nmeaFix = pos(41.0, -71.0, now) - val androidFix = pos(42.0, -72.0, now - 1_000L) - - svc.updateAndroidGps(androidFix) - svc.updateNmeaGps(nmeaFix) - - assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) - assertEquals(nmeaFix, svc.bestPosition.first()) - } - - @Test - fun staleNmea_androidFallback() = runBlocking { - val nmeaTime = 0L - val now = 10_000L // 10 s later — NMEA is stale (threshold 5 s) - val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) - - val nmeaFix = pos(41.0, -71.0, nmeaTime) - val androidFix = pos(42.0, -72.0, now) - - svc.updateNmeaGps(nmeaFix) - svc.updateAndroidGps(androidFix) - - assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) - assertEquals(androidFix, svc.bestPosition.first()) - } - - @Test - fun onlyNmeaAvailable_usedEvenWhenStale() = runBlocking { - val now = 60_000L // 60 s after fix — very stale - val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) - - val nmeaFix = pos(41.0, -71.0, 0L) - svc.updateNmeaGps(nmeaFix) - - assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) - assertEquals(nmeaFix, svc.bestPosition.first()) - } - - @Test - fun onlyAndroidAvailable_isUsed() = runBlocking { - val svc = fusionService() - val androidFix = pos(42.0, -72.0, System.currentTimeMillis()) - svc.updateAndroidGps(androidFix) - - assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) - assertEquals(androidFix, svc.bestPosition.first()) - } - - @Test - fun nmeaAtExactThreshold_isConsideredFresh() = runBlocking { - val fixTime = 0L - val now = 5_000L // exactly at threshold - val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) - - val nmeaFix = pos(41.0, -71.0, fixTime) - val androidFix = pos(42.0, -72.0, now) - - svc.updateNmeaGps(nmeaFix) - svc.updateAndroidGps(androidFix) - - assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) - } - - // ── fix-quality (accuracy) tie-breaking ────────────────────────────────── - - @Test - fun marginallyStaleNmea_betterAccuracy_preferredOverAndroid() = runBlocking { - // NMEA is 7 s old (> primary 5 s, ≤ extended 10 s) but has accuracy 3 m vs Android 15 m. - val nmeaTime = 0L - val now = 7_000L - val svc = fusionService( - nmeaStalenessThresholdMs = 5_000L, - nmeaExtendedThresholdMs = 10_000L, - clockMs = { now } - ) - - val nmeaFix = posWithAccuracy(41.0, -71.0, nmeaTime, accuracyMeters = 3.0) - val androidFix = posWithAccuracy(42.0, -72.0, now, accuracyMeters = 15.0) - - svc.updateNmeaGps(nmeaFix) - svc.updateAndroidGps(androidFix) - - assertEquals(GpsSource.NMEA, svc.activeGpsSource.first()) - assertEquals(nmeaFix, svc.bestPosition.first()) - } - - @Test - fun marginallyStaleNmea_worseAccuracy_fallsBackToAndroid() = runBlocking { - // NMEA is 7 s old with accuracy 15 m; Android has accuracy 3 m → Android wins. - val nmeaTime = 0L - val now = 7_000L - val svc = fusionService( - nmeaStalenessThresholdMs = 5_000L, - nmeaExtendedThresholdMs = 10_000L, - clockMs = { now } - ) - - val nmeaFix = posWithAccuracy(41.0, -71.0, nmeaTime, accuracyMeters = 15.0) - val androidFix = posWithAccuracy(42.0, -72.0, now, accuracyMeters = 3.0) - - svc.updateNmeaGps(nmeaFix) - svc.updateAndroidGps(androidFix) - - assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) - assertEquals(androidFix, svc.bestPosition.first()) - } - - @Test - fun marginallyStaleNmea_noAccuracyData_fallsBackToAndroid() = runBlocking { - // Neither source has accuracy metadata — conservative: prefer Android. - val nmeaTime = 0L - val now = 7_000L - val svc = fusionService( - nmeaStalenessThresholdMs = 5_000L, - nmeaExtendedThresholdMs = 10_000L, - clockMs = { now } - ) - - val nmeaFix = pos(41.0, -71.0, nmeaTime) - val androidFix = pos(42.0, -72.0, now) - - svc.updateNmeaGps(nmeaFix) - svc.updateAndroidGps(androidFix) - - assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) - } - - @Test - fun veryStaleNmea_beyondExtendedThreshold_androidPreferred() = runBlocking { - // NMEA is 15 s old (beyond extended 10 s); Android wins even if NMEA has better accuracy. - val nmeaTime = 0L - val now = 15_000L - val svc = fusionService( - nmeaStalenessThresholdMs = 5_000L, - nmeaExtendedThresholdMs = 10_000L, - clockMs = { now } - ) - - val nmeaFix = posWithAccuracy(41.0, -71.0, nmeaTime, accuracyMeters = 2.0) - val androidFix = posWithAccuracy(42.0, -72.0, now, accuracyMeters = 20.0) - - svc.updateNmeaGps(nmeaFix) - svc.updateAndroidGps(androidFix) - - assertEquals(GpsSource.ANDROID, svc.activeGpsSource.first()) - assertEquals(androidFix, svc.bestPosition.first()) - } - - @Test - fun nmeaRecovery_switchesBackFromAndroid() = runBlocking { - var now = 0L - val svc = fusionService(nmeaStalenessThresholdMs = 5_000L, clockMs = { now }) - - // Fresh NMEA - svc.updateNmeaGps(pos(41.0, -71.0, 0L)) - assertEquals(GpsSource.NMEA, svc.activeGpsSource.value) - - // NMEA goes stale; Android takes over - now = 10_000L - val androidFix = pos(42.0, -72.0, 10_000L) - svc.updateAndroidGps(androidFix) - assertEquals(GpsSource.ANDROID, svc.activeGpsSource.value) - - // NMEA recovers with a fresh fix - val freshNmea = pos(41.1, -71.1, 10_000L) - svc.updateNmeaGps(freshNmea) - assertEquals(GpsSource.NMEA, svc.activeGpsSource.value) - assertEquals(freshNmea, svc.bestPosition.value) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt deleted file mode 100644 index 30b421f..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/logbook/LogbookFormatterTest.kt +++ /dev/null @@ -1,178 +0,0 @@ -package com.example.androidapp.logbook - -import com.example.androidapp.data.model.LogbookEntry -import org.junit.Assert.* -import org.junit.Test - -class LogbookFormatterTest { - - // 2021-06-15 08:00:00 UTC = 1623744000000 ms - private val t0 = 1_623_744_000_000L - - private fun entry( - ts: Long = t0, - lat: Double = 41.39, - lon: Double = -71.202, - sog: Double = 6.2, - cog: Double = 225.0, - windKt: Double? = 15.0, - windDir: Double? = 225.0, - baro: Double? = 1018.0, - depth: Double? = 14.0, - event: String? = "Departed slip", - notes: String? = null - ) = LogbookEntry(ts, lat, lon, sog, cog, windKt, windDir, baro, depth, event, notes) - - // --- formatTime --- - - @Test - fun `formatTime returns HH_MM for UTC midnight`() { - // 2021-06-15 00:00:00 UTC - val ts = 1_623_715_200_000L - assertEquals("00:00", LogbookFormatter.formatTime(ts)) - } - - @Test - fun `formatTime returns correct UTC hour for known timestamp`() { - // t0 = 2021-06-15 08:00:00 UTC - assertEquals("08:00", LogbookFormatter.formatTime(t0)) - } - - @Test - fun `formatTime pads single-digit hour and minute`() { - // 2021-06-15 01:05:00 UTC = 1623715200000 + 65*60*1000 = 1623715200000 + 3900000 - val ts = 1_623_715_200_000L + 65 * 60_000L - assertEquals("01:05", LogbookFormatter.formatTime(ts)) - } - - // --- formatPosition --- - - @Test - fun `formatPosition north east`() { - // 41.39°N → 41°23.4N, 71.202°E → 71°12.1E - val result = LogbookFormatter.formatPosition(41.39, 71.202) - assertEquals("41°23.4N 71°12.1E", result) - } - - @Test - fun `formatPosition south west`() { - // -41.39°S → 41°23.4S, -71.202°W → 71°12.1W - val result = LogbookFormatter.formatPosition(-41.39, -71.202) - assertEquals("41°23.4S 71°12.1W", result) - } - - @Test - fun `formatPosition zero zero`() { - val result = LogbookFormatter.formatPosition(0.0, 0.0) - assertEquals("0°0.0N 0°0.0E", result) - } - - // --- formatWind --- - - @Test - fun `formatWind null knots returns empty string`() { - assertEquals("", LogbookFormatter.formatWind(null, null)) - } - - @Test - fun `formatWind with knots and null direction returns knots only`() { - assertEquals("15kt", LogbookFormatter.formatWind(15.0, null)) - } - - @Test - fun `formatWind 225 degrees is SW`() { - assertEquals("15kt SW", LogbookFormatter.formatWind(15.0, 225.0)) - } - - @Test - fun `formatWind 0 degrees is N`() { - assertEquals("10kt N", LogbookFormatter.formatWind(10.0, 0.0)) - } - - @Test - fun `formatWind 360 degrees is N`() { - assertEquals("10kt N", LogbookFormatter.formatWind(10.0, 360.0)) - } - - @Test - fun `formatWind 90 degrees is E`() { - assertEquals("8kt E", LogbookFormatter.formatWind(8.0, 90.0)) - } - - // --- toCompassPoint --- - - @Test - fun `toCompassPoint covers all 16 cardinal and intercardinal points`() { - val expected = listOf("N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", - "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW") - expected.forEachIndexed { i, dir -> - val degrees = i * 22.5 - assertEquals("degrees=$degrees", dir, LogbookFormatter.toCompassPoint(degrees)) - } - } - - // --- toRow --- - - @Test - fun `toRow formats all fields correctly`() { - val row = LogbookFormatter.toRow(entry()) - assertEquals("08:00", row.time) - assertEquals("41°23.4N 71°12.1W", row.position) - assertEquals("6.2", row.sog) - assertEquals("225", row.cog) - assertEquals("15kt SW", row.wind) - assertEquals("1018", row.baro) - assertEquals("14m", row.depth) - assertEquals("Departed slip", row.eventNotes) - } - - @Test - fun `toRow combines event and notes with colon`() { - val row = LogbookFormatter.toRow(entry(event = "Reef #1", notes = "Strong gusts")) - assertEquals("Reef #1: Strong gusts", row.eventNotes) - } - - @Test - fun `toRow with only notes has no colon prefix`() { - val row = LogbookFormatter.toRow(entry(event = null, notes = "Calm seas")) - assertEquals("Calm seas", row.eventNotes) - } - - @Test - fun `toRow with null optional fields uses empty strings`() { - val e = LogbookEntry(t0, 0.0, 0.0, 0.0, 0.0) - val row = LogbookFormatter.toRow(e) - assertEquals("", row.wind) - assertEquals("", row.baro) - assertEquals("", row.depth) - assertEquals("", row.eventNotes) - } - - // --- toPage --- - - @Test - fun `toPage returns page with default title and correct column count`() { - val page = LogbookFormatter.toPage(emptyList()) - assertEquals("Trip Logbook", page.title) - assertEquals(8, page.columns.size) - } - - @Test - fun `toPage maps entries to rows in order`() { - val entries = listOf( - entry(ts = t0, event = "First"), - entry(ts = t0 + 3_600_000L, event = "Second") - ) - val page = LogbookFormatter.toPage(entries, "Voyage Log") - assertEquals("Voyage Log", page.title) - assertEquals(2, page.rows.size) - assertEquals("First", page.rows[0].eventNotes) - assertEquals("Second", page.rows[1].eventNotes) - } - - @Test - fun `toPage empty entries produces empty rows`() { - val page = LogbookFormatter.toPage(emptyList()) - assertTrue(page.rows.isEmpty()) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt deleted file mode 100644 index b8a878a..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/nmea/NmeaParserTest.kt +++ /dev/null @@ -1,105 +0,0 @@ -package com.example.androidapp.nmea - -import org.junit.Assert.* -import org.junit.Before -import org.junit.Test - -class NmeaParserTest { - - private lateinit var parser: NmeaParser - - @Before - fun setUp() { - parser = NmeaParser() - } - - // $GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A - // lat: 48 + 7.038/60 = 48.1173°N, lon: 11 + 31.000/60 = 11.51667°E - // SOG 22.4 kn, COG 84.4° - - @Test - fun `valid RMC sentence parses latitude and longitude`() { - val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A" - val pos = parser.parseRmc(sentence) - assertNotNull(pos) - assertEquals(48.1173, pos!!.latitude, 0.0001) - assertEquals(11.51667, pos.longitude, 0.0001) - } - - @Test - fun `valid RMC sentence parses SOG and COG`() { - val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A" - val pos = parser.parseRmc(sentence) - assertNotNull(pos) - assertEquals(22.4, pos!!.sog, 0.001) - assertEquals(84.4, pos.cog, 0.001) - } - - @Test - fun `void status V returns null`() { - val sentence = "\$GPRMC,123519,V,4807.038,N,01131.000,E,,,230394,003.1,W" - assertNull(parser.parseRmc(sentence)) - } - - @Test - fun `malformed sentence with too few fields returns null`() { - assertNull(parser.parseRmc("\$GPRMC,123519,A")) - } - - @Test - fun `empty string returns null`() { - assertNull(parser.parseRmc("")) - } - - @Test - fun `non-RMC sentence returns null`() { - val sentence = "\$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,," - assertNull(parser.parseRmc(sentence)) - } - - @Test - fun `south latitude is negative`() { - // lat: -(42 + 50.5589/60) = -42.84265 - val sentence = "\$GPRMC,092204.999,A,4250.5589,S,14718.5084,E,0.00,89.68,211200,," - val pos = parser.parseRmc(sentence) - assertNotNull(pos) - assertTrue("South latitude must be negative", pos!!.latitude < 0) - assertEquals(-42.84265, pos.latitude, 0.0001) - } - - @Test - fun `west longitude is negative`() { - // lon: -(11 + 31.000/60) = -11.51667 - val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,W,022.4,084.4,230394,003.1,E" - val pos = parser.parseRmc(sentence) - assertNotNull(pos) - assertTrue("West longitude must be negative", pos!!.longitude < 0) - assertEquals(-11.51667, pos.longitude, 0.0001) - } - - @Test - fun `SOG and COG parse with decimal precision`() { - val sentence = "\$GPRMC,093456,A,3352.1234,N,11801.5678,W,12.345,270.5,140326,," - val pos = parser.parseRmc(sentence) - assertNotNull(pos) - assertEquals(12.345, pos!!.sog, 0.0001) - assertEquals(270.5, pos.cog, 0.0001) - } - - @Test - fun `empty SOG and COG fields default to zero`() { - val sentence = "\$GPRMC,123519,A,4807.038,N,01131.000,E,,,230394,003.1,W" - val pos = parser.parseRmc(sentence) - assertNotNull(pos) - assertEquals(0.0, pos!!.sog, 0.001) - assertEquals(0.0, pos.cog, 0.001) - } - - @Test - fun `GNRMC talker ID is also accepted`() { - val sentence = "\$GNRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W" - val pos = parser.parseRmc(sentence) - assertNotNull(pos) - assertEquals(48.1173, pos!!.latitude, 0.0001) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt deleted file mode 100644 index e5615e9..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/routing/IsochroneRouterTest.kt +++ /dev/null @@ -1,169 +0,0 @@ -package com.example.androidapp.routing - -import com.example.androidapp.data.model.BoatPolars -import com.example.androidapp.data.model.WindForecast -import org.junit.Assert.* -import org.junit.Test - -class IsochroneRouterTest { - - private val startTimeMs = 1_000_000_000L - private val oneHourMs = 3_600_000L - - // ── BoatPolars ──────────────────────────────────────────────────────────── - - @Test - fun `bsp returns exact value for exact twa and tws entry`() { - val polars = BoatPolars.DEFAULT - // At TWS=10, TWA=90 the table has 7.0 kt - assertEquals(7.0, polars.bsp(90.0, 10.0), 1e-9) - } - - @Test - fun `bsp interpolates between twa entries`() { - val polars = BoatPolars.DEFAULT - // At TWS=10: TWA=60 → 6.5, TWA=90 → 7.0; midpoint TWA=75 → 6.75 - assertEquals(6.75, polars.bsp(75.0, 10.0), 1e-9) - } - - @Test - fun `bsp interpolates between tws entries`() { - val polars = BoatPolars.DEFAULT - // At TWA=90: TWS=10 → 7.0, TWS=15 → 8.0; midpoint TWS=12.5 → 7.5 - assertEquals(7.5, polars.bsp(90.0, 12.5), 1e-9) - } - - @Test - fun `bsp mirrors port tack twa to starboard`() { - val polars = BoatPolars.DEFAULT - // TWA=270 should mirror to 360-270=90, giving same as TWA=90 - assertEquals(polars.bsp(90.0, 10.0), polars.bsp(270.0, 10.0), 1e-9) - } - - @Test - fun `bsp clamps tws below table minimum`() { - val polars = BoatPolars.DEFAULT - // TWS=0 clamps to minimum TWS=5 - assertEquals(polars.bsp(90.0, 5.0), polars.bsp(90.0, 0.0), 1e-9) - } - - @Test - fun `bsp clamps tws above table maximum`() { - val polars = BoatPolars.DEFAULT - // TWS=100 clamps to maximum TWS=20 - assertEquals(polars.bsp(90.0, 20.0), polars.bsp(90.0, 100.0), 1e-9) - } - - // ── IsochroneRouter geometry helpers ───────────────────────────────────── - - @Test - fun `haversineM returns zero for same point`() { - assertEquals(0.0, IsochroneRouter.haversineM(10.0, 20.0, 10.0, 20.0), 1e-3) - } - - @Test - fun `haversineM one degree of latitude is approximately 111_195 m`() { - val dist = IsochroneRouter.haversineM(0.0, 0.0, 1.0, 0.0) - assertEquals(111_195.0, dist, 50.0) - } - - @Test - fun `bearingDeg returns 0 for due north`() { - val bearing = IsochroneRouter.bearingDeg(0.0, 0.0, 1.0, 0.0) - assertEquals(0.0, bearing, 1e-6) - } - - @Test - fun `bearingDeg returns 90 for due east`() { - val bearing = IsochroneRouter.bearingDeg(0.0, 0.0, 0.0, 1.0) - assertEquals(90.0, bearing, 1e-4) - } - - @Test - fun `destinationPoint due north by 1 NM moves latitude by expected amount`() { - val (lat, lon) = IsochroneRouter.destinationPoint(0.0, 0.0, 0.0, IsochroneRouter.NM_TO_M) - assertTrue("latitude should increase", lat > 0.0) - assertEquals(0.0, lon, 1e-9) - // 1 NM ≈ 1/60 degree of latitude - assertEquals(1.0 / 60.0, lat, 1e-4) - } - - // ── Pruning ─────────────────────────────────────────────────────────────── - - @Test - fun `prune keeps only furthest point per sector`() { - // Two points both due north of origin at different distances - val close = RoutePoint(1.0, 0.0, startTimeMs) - val far = RoutePoint(2.0, 0.0, startTimeMs) - val result = IsochroneRouter.prune(listOf(close, far), 0.0, 0.0, 72) - assertEquals(1, result.size) - assertEquals(far, result[0]) - } - - @Test - fun `prune keeps points in different sectors separately`() { - // One point north, one point east — different sectors - val north = RoutePoint(1.0, 0.0, startTimeMs) - val east = RoutePoint(0.0, 1.0, startTimeMs) - val result = IsochroneRouter.prune(listOf(north, east), 0.0, 0.0, 72) - assertEquals(2, result.size) - } - - // ── Full routing ────────────────────────────────────────────────────────── - - @Test - fun `route finds path to destination with constant wind`() { - // Destination is ~5 NM due east of start; constant 10kt easterly (FROM east = 90°) - // A 10kt boat sailing downwind (TWA=180) = 6.0 kt; ~5 NM / 6 kt ≈ 50 min → 1 step - val destLat = 0.0 - val destLon = 0.0 + (5.0 / 60.0) // ~5 NM east - val constantWind = { _: Double, _: Double, _: Long -> - WindForecast(0.0, 0.0, startTimeMs, twsKt = 10.0, twdDeg = 90.0) - } - val result = IsochroneRouter.route( - startLat = 0.0, - startLon = 0.0, - destLat = destLat, - destLon = destLon, - startTimeMs = startTimeMs, - stepMs = oneHourMs, - polars = BoatPolars.DEFAULT, - windAt = constantWind, - arrivalRadiusM = 2_000.0 // 2 km arrival radius - ) - assertNotNull("Should find a route", result) - result!! - assertTrue("Path should have at least 2 points (start + arrival)", result.path.size >= 2) - assertEquals("Path should start at origin", 0.0, result.path.first().lat, 1e-6) - assertEquals("ETA should be after start", startTimeMs, result.etaMs - oneHourMs) - } - - @Test - fun `route returns null when polars produce zero speed`() { - val zeroPolar = BoatPolars(emptyMap()) - val result = IsochroneRouter.route( - startLat = 0.0, - startLon = 0.0, - destLat = 1.0, - destLon = 0.0, - startTimeMs = startTimeMs, - stepMs = oneHourMs, - polars = zeroPolar, - windAt = { _, _, _ -> WindForecast(0.0, 0.0, startTimeMs, 10.0, 0.0) }, - maxSteps = 3 - ) - assertNull("Should return null when no progress is possible", result) - } - - @Test - fun `backtrace returns path from start to arrival in order`() { - val p0 = RoutePoint(0.0, 0.0, 0L) - val p1 = RoutePoint(1.0, 0.0, 1L, parent = p0) - val p2 = RoutePoint(2.0, 0.0, 2L, parent = p1) - val path = IsochroneRouter.backtrace(p2) - assertEquals(3, path.size) - assertEquals(p0, path[0]) - assertEquals(p1, path[1]) - assertEquals(p2, path[2]) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt deleted file mode 100644 index 40f7df0..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/safety/AnchorWatchStateTest.kt +++ /dev/null @@ -1,32 +0,0 @@ -package com.example.androidapp.safety - -import org.junit.Assert.* -import org.junit.Test -import kotlin.math.sqrt - -class AnchorWatchStateTest { - - private val state = AnchorWatchState() - - @Test - fun calculateRecommendedWatchCircleRadius_validGeometry() { - // depth=6m, rode=50m → vertical=8m, radius=sqrt(50²-8²)=sqrt(2436) - val expected = sqrt(2436.0) - val actual = state.calculateRecommendedWatchCircleRadius(depthM = 6.0, rodeOutM = 50.0) - assertEquals(expected, actual, 0.001) - } - - @Test - fun calculateRecommendedWatchCircleRadius_rodeShorterThanVertical_fallsBackToRode() { - // depth=10m, rode=5m → vertical=12m > rode, fallback returns rode - val actual = state.calculateRecommendedWatchCircleRadius(depthM = 10.0, rodeOutM = 5.0) - assertEquals(5.0, actual, 0.001) - } - - @Test - fun calculateRecommendedWatchCircleRadius_rodeEqualsVertical_fallsBackToRode() { - // depth=8m, rode=10m → vertical=10m == rode, fallback returns rode - val actual = state.calculateRecommendedWatchCircleRadius(depthM = 8.0, rodeOutM = 10.0) - assertEquals(10.0, actual, 0.001) - } -} diff --git a/android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt b/android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt deleted file mode 100644 index 612ae34..0000000 --- a/android-app/app/src/test/kotlin/com/example/androidapp/tide/HarmonicTideCalculatorTest.kt +++ /dev/null @@ -1,135 +0,0 @@ -package com.example.androidapp.tide - -import com.example.androidapp.data.model.TideConstituent -import com.example.androidapp.data.model.TideStation -import org.junit.Assert.* -import org.junit.Test - -class HarmonicTideCalculatorTest { - - // Reference epoch: 2000-01-01 00:00:00 UTC = 946_684_800_000 ms - private val epochMs = HarmonicTideCalculator.EPOCH_MS - private val oneHourMs = 3_600_000L - - private fun stationWith( - speed: Double = 30.0, - amplitude: Double = 1.0, - phase: Double = 0.0, - datum: Double = 0.0 - ) = TideStation( - id = "test", name = "Test", lat = 0.0, lon = 0.0, - datumOffsetMeters = datum, - constituents = listOf(TideConstituent("S2", speed, amplitude, phase)) - ) - - @Test - fun `predictHeight at epoch gives datum plus amplitude for zero-phase constituent`() { - val station = stationWith(speed = 30.0, amplitude = 1.5, phase = 0.0, datum = 0.5) - val height = HarmonicTideCalculator.predictHeight(station, epochMs) - assertEquals(0.5 + 1.5, height, 1e-9) // cos(0°) = 1.0 - } - - @Test - fun `predictHeight at half period gives datum minus amplitude`() { - // speed = 30 deg/hr → half period = 6 hours → cos(180°) = -1.0 - val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 0.0, datum = 0.0) - val height = HarmonicTideCalculator.predictHeight(station, epochMs + 6 * oneHourMs) - assertEquals(-1.0, height, 1e-9) - } - - @Test - fun `predictHeight at quarter period is near zero`() { - // speed = 30 deg/hr → quarter period = 3 hours → cos(90°) ≈ 0.0 - val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 0.0, datum = 0.0) - val height = HarmonicTideCalculator.predictHeight(station, epochMs + 3 * oneHourMs) - assertEquals(0.0, height, 1e-9) - } - - @Test - fun `predictHeight applies phase offset correctly`() { - // phase = 90 → cos(0 - 90°) = cos(-90°) ≈ 0.0 at epoch - val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 90.0, datum = 0.0) - val height = HarmonicTideCalculator.predictHeight(station, epochMs) - assertEquals(0.0, height, 1e-9) - } - - @Test - fun `predictHeight sums multiple constituents at epoch`() { - val station = TideStation( - id = "test", name = "Test", lat = 0.0, lon = 0.0, - datumOffsetMeters = 2.0, - constituents = listOf( - TideConstituent("S2", 30.0, 1.0, 0.0), // +1.0 at epoch - TideConstituent("K1", 30.0, 0.5, 0.0) // +0.5 at epoch - ) - ) - val height = HarmonicTideCalculator.predictHeight(station, epochMs) - assertEquals(3.5, height, 1e-9) // 2.0 + 1.0 + 0.5 - } - - @Test - fun `predictHeight with empty constituents returns datum offset only`() { - val station = TideStation("t", "T", 0.0, 0.0, 3.14, emptyList()) - assertEquals(3.14, HarmonicTideCalculator.predictHeight(station, epochMs), 1e-9) - } - - @Test - fun `predictRange returns correct number of predictions`() { - val station = stationWith() - val predictions = HarmonicTideCalculator.predictRange( - station, epochMs, epochMs + 3 * oneHourMs, oneHourMs - ) - assertEquals(4, predictions.size) // t=0h, 1h, 2h, 3h - } - - @Test - fun `predictRange timestamps are evenly spaced`() { - val station = stationWith() - val predictions = HarmonicTideCalculator.predictRange( - station, epochMs, epochMs + 2 * oneHourMs, oneHourMs - ) - assertEquals(epochMs, predictions[0].timestampMs) - assertEquals(epochMs + oneHourMs, predictions[1].timestampMs) - assertEquals(epochMs + 2 * oneHourMs, predictions[2].timestampMs) - } - - @Test - fun `predictRange with equal from and to returns single prediction`() { - val station = stationWith() - val predictions = HarmonicTideCalculator.predictRange(station, epochMs, epochMs, oneHourMs) - assertEquals(1, predictions.size) - assertEquals(epochMs, predictions[0].timestampMs) - } - - @Test - fun `findHighLow returns empty list for fewer than 3 predictions`() { - val station = stationWith() - val predictions = HarmonicTideCalculator.predictRange( - station, epochMs, epochMs + oneHourMs, oneHourMs - ) - assertEquals(2, predictions.size) - assertTrue(HarmonicTideCalculator.findHighLow(predictions).isEmpty()) - } - - @Test - fun `findHighLow detects high and low water events`() { - // speed = 30 deg/hr, 3-hour samples over 24 hours - // Heights: 1.0, 0.0, -1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 1.0 - // Turning points at t=6h(low), t=12h(high), t=18h(low) - val station = stationWith(speed = 30.0, amplitude = 1.0, phase = 0.0, datum = 0.0) - val predictions = HarmonicTideCalculator.predictRange( - station, - epochMs, - epochMs + 24 * oneHourMs, - 3 * oneHourMs - ) - val highLow = HarmonicTideCalculator.findHighLow(predictions) - assertEquals(3, highLow.size) - assertEquals(epochMs + 6 * oneHourMs, highLow[0].timestampMs) - assertEquals(-1.0, highLow[0].heightMeters, 1e-9) - assertEquals(epochMs + 12 * oneHourMs, highLow[1].timestampMs) - assertEquals(1.0, highLow[1].heightMeters, 1e-9) - assertEquals(epochMs + 18 * oneHourMs, highLow[2].timestampMs) - assertEquals(-1.0, highLow[2].heightMeters, 1e-9) - } -} diff --git a/android-app/app/src/test/kotlin/org/terst/nav/data/repository/WeatherRepositoryTest.kt b/android-app/app/src/test/kotlin/org/terst/nav/data/repository/WeatherRepositoryTest.kt index 749630f..c455085 100644 --- a/android-app/app/src/test/kotlin/org/terst/nav/data/repository/WeatherRepositoryTest.kt +++ b/android-app/app/src/test/kotlin/org/terst/nav/data/repository/WeatherRepositoryTest.kt @@ -3,8 +3,7 @@ package org.terst.nav.data.repository import org.terst.nav.data.api.MarineApiService import org.terst.nav.data.api.WeatherApiService import org.terst.nav.data.model.* -import io.mockk.coEvery -import io.mockk.mockk +import io.mockk.* import kotlinx.coroutines.test.runTest import org.junit.Assert.* import org.junit.Before @@ -36,6 +35,9 @@ class WeatherRepositoryTest { time = listOf("2026-03-13T00:00", "2026-03-13T01:00"), waveHeight = listOf(1.2, 1.1), waveDirection = listOf(250.0, 255.0), + swellWaveHeight = emptyList(), + swellWaveDirection = emptyList(), + swellWavePeriod = emptyList(), oceanCurrentVelocity = listOf(0.3, 0.4), oceanCurrentDirection = listOf(180.0, 185.0) ) @@ -48,7 +50,7 @@ class WeatherRepositoryTest { @Test fun `fetchForecastItems maps weather response to ForecastItem list`() = runTest { - coEvery { weatherApi.getWeatherForecast(any(), any()) } returns weatherResponse + coEvery { weatherApi.getWeatherForecast(any(), any(), any(), any(), any()) } returns weatherResponse coEvery { marineApi.getMarineForecast(any(), any()) } returns marineResponse val result = repo.fetchForecastItems(37.5, -122.3) @@ -64,9 +66,26 @@ class WeatherRepositoryTest { assertEquals(1, items[0].weatherCode) } + @Test + fun `fetchCurrentConditions maps responses to MarineConditions`() = runTest { + coEvery { weatherApi.getWeatherForecast(any(), any(), any(), eq(1), any()) } returns weatherResponse + coEvery { marineApi.getMarineForecast(any(), any()) } returns marineResponse + + val result = repo.fetchCurrentConditions(37.5, -122.3) + + if (result.isFailure) { + fail("fetchCurrentConditions failed with: ${result.exceptionOrNull()}") + } + val cond = result.getOrThrow() + assertEquals(15.0, cond.windSpeedKt!!, 0.001) + assertEquals(1.2, cond.waveHeightM!!, 0.001) + assertEquals(0.3 * 1.94384, cond.currentSpeedKt!!, 0.001) + assertEquals(180.0, cond.currentDirDeg!!, 0.001) + } + @Test fun `fetchWindArrow returns WindArrow for first (current) hour`() = runTest { - coEvery { weatherApi.getWeatherForecast(any(), any()) } returns weatherResponse + coEvery { weatherApi.getWeatherForecast(any(), any(), any(), eq(1), any()) } returns weatherResponse coEvery { marineApi.getMarineForecast(any(), any()) } returns marineResponse val result = repo.fetchWindArrow(37.5, -122.3) @@ -81,7 +100,7 @@ class WeatherRepositoryTest { @Test fun `fetchForecastItems returns failure when weather API throws`() = runTest { - coEvery { weatherApi.getWeatherForecast(any(), any()) } throws RuntimeException("Network error") + coEvery { weatherApi.getWeatherForecast(any(), any(), any(), any(), any()) } throws RuntimeException("Network error") coEvery { marineApi.getMarineForecast(any(), any()) } returns marineResponse val result = repo.fetchForecastItems(37.5, -122.3) @@ -91,7 +110,7 @@ class WeatherRepositoryTest { @Test fun `fetchWindArrow returns failure when API throws`() = runTest { - coEvery { weatherApi.getWeatherForecast(any(), any()) } throws RuntimeException("Timeout") + coEvery { weatherApi.getWeatherForecast(any(), any(), any(), eq(1), any()) } throws RuntimeException("Timeout") coEvery { marineApi.getMarineForecast(any(), any()) } returns marineResponse val result = repo.fetchWindArrow(37.5, -122.3) -- cgit v1.2.3 From 8004e7e05a68a2409ad0fdfc067936f9e2329067 Mon Sep 17 00:00:00 2001 From: Peter Stone Date: Mon, 6 Apr 2026 05:25:04 +0000 Subject: feat(ui): add DirectionArrowView and WaveView custom views MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit DirectionArrowView: rotating notched-chevron compass indicator in SKY (grey) and OCEAN (blue) palettes, with bearing normalization. WaveView: animated swell + wind-chop canvas divider — sky/sea gradient fills, shimmer line, whitecap highlights; self-animates via postInvalidateOnAnimation. Co-Authored-By: Claude Sonnet 4.6 --- .../kotlin/org/terst/nav/ui/DirectionArrowView.kt | 69 ++++++++++ .../src/main/kotlin/org/terst/nav/ui/WaveView.kt | 150 +++++++++++++++++++++ .../org/terst/nav/ui/DirectionArrowViewTest.kt | 25 ++++ 3 files changed, 244 insertions(+) create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/ui/DirectionArrowView.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/ui/WaveView.kt create mode 100644 android-app/app/src/test/kotlin/org/terst/nav/ui/DirectionArrowViewTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/DirectionArrowView.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/DirectionArrowView.kt new file mode 100644 index 0000000..fa68b63 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/DirectionArrowView.kt @@ -0,0 +1,69 @@ +package org.terst.nav.ui + +import android.content.Context +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.Paint +import android.graphics.Path +import android.util.AttributeSet +import android.view.View + +/** Normalises a bearing in degrees to [0, 360). */ +fun normalizeBearing(deg: Float): Float = ((deg % 360f) + 360f) % 360f + +/** + * Small circular direction indicator — notched chevron pointing in [bearing] degrees + * (0 = north/up, clockwise). Two palettes: SKY (grey) and OCEAN (blue). + */ +class DirectionArrowView @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : View(context, attrs, defStyleAttr) { + + enum class ArrowStyle { SKY, OCEAN } + + var bearing: Float = 0f + set(value) { field = normalizeBearing(value); invalidate() } + + var arrowStyle: ArrowStyle = ArrowStyle.SKY + set(value) { + field = value + circlePaint.color = circleColor() + arrowPaint.color = arrowColor() + invalidate() + } + + private val circlePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + style = Paint.Style.STROKE; strokeWidth = 1.5f; color = circleColor() + } + private val arrowPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + style = Paint.Style.FILL; color = arrowColor() + } + private val arrowPath = Path() + + private fun circleColor() = when (arrowStyle) { + ArrowStyle.SKY -> Color.parseColor("#3A3640") + ArrowStyle.OCEAN -> Color.parseColor("#1E4A6E") + } + private fun arrowColor() = when (arrowStyle) { + ArrowStyle.SKY -> Color.parseColor("#9A94A0") + ArrowStyle.OCEAN -> Color.parseColor("#6FC3E8") + } + + override fun onDraw(canvas: Canvas) { + val cx = width / 2f; val cy = height / 2f + val r = (minOf(width, height) / 2f) - circlePaint.strokeWidth + canvas.drawCircle(cx, cy, r, circlePaint) + val tipY = cy - r * 0.72f; val baseY = cy + r * 0.50f + val notchY = cy + r * 0.22f; val halfW = r * 0.42f + arrowPath.reset() + arrowPath.moveTo(cx, tipY) + arrowPath.lineTo(cx - halfW, baseY) + arrowPath.lineTo(cx, notchY) + arrowPath.lineTo(cx + halfW, baseY) + arrowPath.close() + canvas.save(); canvas.rotate(bearing, cx, cy) + canvas.drawPath(arrowPath, arrowPaint); canvas.restore() + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/WaveView.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/WaveView.kt new file mode 100644 index 0000000..30aca06 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/WaveView.kt @@ -0,0 +1,150 @@ +package org.terst.nav.ui + +import android.content.Context +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.LinearGradient +import android.graphics.Paint +import android.graphics.Path +import android.graphics.Shader +import android.os.SystemClock +import android.util.AttributeSet +import android.view.View +import kotlin.math.sin + +/** + * Draws an animated ocean-horizon scene used as the divider between the + * instrument section and the forecast section. + * + * The primary wave is driven by swell height and period; a secondary + * high-frequency wave represents wind chop. Whitecaps appear at wind-wave + * crests. The view self-animates via [postInvalidateOnAnimation]. + * + * Set [swellHeightFt], [swellPeriodSec], and [windWaveHeightFt] to update + * the wave state when new forecast data arrives. + */ +class WaveView @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : View(context, attrs, defStyleAttr) { + + var swellHeightFt: Float = 3f + set(value) { field = value.coerceAtLeast(0f); invalidate() } + + var swellPeriodSec: Float = 10f + set(value) { field = value.coerceAtLeast(1f); invalidate() } + + var windWaveHeightFt: Float = 1.5f + set(value) { field = value.coerceAtLeast(0f); invalidate() } + + private var startTimeMs = -1L + + private val wavePath = Path() + + private val skyPaint = Paint() + private val seaPaint = Paint() + + private val shimmerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + style = Paint.Style.STROKE + strokeWidth = 1.5f + color = Color.argb(77, 111, 195, 232) + } + + private val whitecapPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + style = Paint.Style.STROKE + strokeWidth = 1.5f + strokeCap = Paint.Cap.ROUND + color = Color.argb(128, 255, 255, 255) + } + + override fun onAttachedToWindow() { + super.onAttachedToWindow() + startTimeMs = SystemClock.elapsedRealtime() + postInvalidateOnAnimation() + } + + override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) { + skyPaint.shader = LinearGradient( + 0f, 0f, 0f, h * 0.6f, + Color.parseColor("#1C1B1F"), + Color.parseColor("#162433"), + Shader.TileMode.CLAMP + ) + seaPaint.shader = LinearGradient( + 0f, h * 0.4f, 0f, h.toFloat(), + Color.parseColor("#0B3050"), + Color.parseColor("#0D2137"), + Shader.TileMode.CLAMP + ) + } + + override fun onDraw(canvas: Canvas) { + if (startTimeMs < 0) startTimeMs = SystemClock.elapsedRealtime() + val t = (SystemClock.elapsedRealtime() - startTimeMs) / 1000.0 // seconds + + val w = width.toFloat() + val h = height.toFloat() + + // Amplitudes scale with wave data, capped relative to view height + val swellAmp = (h * (swellHeightFt / 28f)).coerceIn(h * 0.04f, h * 0.22f) + val windAmp = (h * (windWaveHeightFt / 28f)).coerceIn(h * 0.02f, h * 0.10f) + val swellWlen = w * (swellPeriodSec / 14f) + val windWlen = swellWlen * 0.35f + val midY = h * 0.52f + + fun waveY(x: Float): Float = + (midY + + sin((x / swellWlen) * TWO_PI - t * 0.8) * swellAmp + + sin((x / windWlen) * TWO_PI - t * 1.8 + 1.2) * windAmp).toFloat() + + // ── Sky fill ────────────────────────────────────────────────── + wavePath.reset() + wavePath.moveTo(0f, 0f) + wavePath.lineTo(0f, waveY(0f)) + var x = 2f + while (x <= w) { wavePath.lineTo(x, waveY(x)); x += 2f } + wavePath.lineTo(w, 0f) + wavePath.close() + canvas.drawPath(wavePath, skyPaint) + + // ── Sea fill ────────────────────────────────────────────────── + wavePath.reset() + wavePath.moveTo(0f, h) + wavePath.lineTo(0f, waveY(0f)) + x = 2f + while (x <= w) { wavePath.lineTo(x, waveY(x)); x += 2f } + wavePath.lineTo(w, h) + wavePath.close() + canvas.drawPath(wavePath, seaPaint) + + // ── Shimmer line ────────────────────────────────────────────── + wavePath.reset() + wavePath.moveTo(0f, waveY(0f)) + x = 2f + while (x <= w) { wavePath.lineTo(x, waveY(x)); x += 2f } + canvas.drawPath(wavePath, shimmerPaint) + + // ── Whitecaps at wind-wave crests ───────────────────────────── + val capPath = Path() + x = windWlen * 0.5f + while (x <= w) { + val wv = sin((x / windWlen) * TWO_PI - t * 1.8 + 1.2) * windAmp + val wn = sin(((x + 3) / windWlen) * TWO_PI - t * 1.8 + 1.2) * windAmp + if (wv > windAmp * 0.55 && wv >= wn) { + val y = waveY(x) + capPath.reset() + capPath.moveTo(x - 7f, y + 1f) + capPath.quadTo(x, y - 2.5f, x + 8f, y + 1f) + canvas.drawPath(capPath, whitecapPaint) + } + x += windWlen * 0.9f + } + + postInvalidateOnAnimation() + } + + companion object { + private const val TWO_PI = Math.PI * 2.0 + } +} diff --git a/android-app/app/src/test/kotlin/org/terst/nav/ui/DirectionArrowViewTest.kt b/android-app/app/src/test/kotlin/org/terst/nav/ui/DirectionArrowViewTest.kt new file mode 100644 index 0000000..e26b67d --- /dev/null +++ b/android-app/app/src/test/kotlin/org/terst/nav/ui/DirectionArrowViewTest.kt @@ -0,0 +1,25 @@ +package org.terst.nav.ui + +import org.junit.Assert.assertEquals +import org.junit.Test + +class DirectionArrowViewTest { + + @Test + fun `bearing is normalised — values over 360 wrap`() { + assertEquals(10f, normalizeBearing(370f), 0.001f) + } + + @Test + fun `bearing is normalised — negative values wrap`() { + assertEquals(350f, normalizeBearing(-10f), 0.001f) + } + + @Test + fun `bearing is normalised — exactly 360 becomes 0`() { + assertEquals(0f, normalizeBearing(360f), 0.001f) + } +} + +// Top-level helper extracted from DirectionArrowView for testability +fun normalizeBearing(deg: Float): Float = ((deg % 360f) + 360f) % 360f -- cgit v1.2.3 From c8a1e81faec6663b258898c109db1f63e57b07eb Mon Sep 17 00:00:00 2001 From: Peter Stone Date: Mon, 6 Apr 2026 06:49:34 +0000 Subject: feat(ui): wire redesigned instrument sheet — InstrumentHandler rewrite + MainActivity MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit InstrumentHandler: direction arrows (SKY/OCEAN palettes), WaveView state, metres→feet conversion, bearing formatting, all helpers top-level for TDD. MainActivity: setupHandlers wires all new view refs; observeDataSources passes cogBearingDeg, twsBearingDeg, raw metres to handler; depth collector wired from nmeaDepthDataFlow. Co-Authored-By: Claude Sonnet 4.6 --- .../src/main/kotlin/org/terst/nav/MainActivity.kt | 78 ++++++---- .../kotlin/org/terst/nav/ui/InstrumentHandler.kt | 172 +++++++++++++++------ .../org/terst/nav/ui/InstrumentHandlerTest.kt | 39 +++++ 3 files changed, 217 insertions(+), 72 deletions(-) create mode 100644 android-app/app/src/test/kotlin/org/terst/nav/ui/InstrumentHandlerTest.kt (limited to 'android-app/app/src/test/kotlin') 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 023cb94..e5d3080 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 @@ -181,31 +181,42 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { private fun setupHandlers() { instrumentHandler = InstrumentHandler( - valueAws = findViewById(R.id.value_aws), - valueTws = findViewById(R.id.value_tws), - valueHdg = findViewById(R.id.value_hdg), - valueCog = findViewById(R.id.value_cog), - valueBsp = findViewById(R.id.value_bsp), - valueSog = findViewById(R.id.value_sog), + // Instrument TextViews + valueAws = findViewById(R.id.value_aws), + valueTws = findViewById(R.id.value_tws), + valueHdg = findViewById(R.id.value_hdg), + valueCog = findViewById(R.id.value_cog), + valueBsp = findViewById(R.id.value_bsp), + valueSog = findViewById(R.id.value_sog), valueDepth = findViewById(R.id.value_depth), - valueBaro = findViewById(R.id.value_baro), - valueCurrSpd = findViewById(R.id.value_curr_spd), - valueCurrDir = null, - valueWaveHt = findViewById(R.id.value_wave_ht), - valueWaveDir = null, - valueSwellHt = findViewById(R.id.value_swell_ht), - valueSwellPer = findViewById(R.id.value_swell_per) + valueBaro = findViewById(R.id.value_baro), + // Instrument arrows + arrowAws = findViewById(R.id.arrow_aws), + arrowTws = findViewById(R.id.arrow_tws), + arrowHdg = findViewById(R.id.arrow_hdg), + arrowCog = findViewById(R.id.arrow_cog), + // Forecast TextViews + valueCurrSpd = findViewById(R.id.value_curr_spd), + valueWaveHt = findViewById(R.id.value_wave_ht), + valueSwellHt = findViewById(R.id.value_swell_ht), + valueSwellPer = findViewById(R.id.value_swell_per), + // Forecast arrows + arrowCurr = findViewById(R.id.arrow_curr), + arrowWaves = findViewById(R.id.arrow_waves), + arrowSwell = findViewById(R.id.arrow_swell), + // Forecast bearing labels + bearingCurr = findViewById(R.id.bearing_curr), + bearingWaves = findViewById(R.id.bearing_waves), + bearingSwell = findViewById(R.id.bearing_swell), + // Wave view + waveView = findViewById(R.id.wave_divider) ) instrumentHandler?.updateDisplay( aws = "—", tws = "—", hdg = "—", cog = "—", bsp = "—", sog = "—", - depth = "—", baro = "—" - ) - instrumentHandler?.updateConditions( - currSpd = "—", currDir = "—", - waveHt = "—", waveDir = "—", - swellHt = "—", swellPer = "—" + baro = "—" ) + instrumentHandler?.updateConditions(currSpd = "—") } // Helper to convert dp to px @@ -296,11 +307,11 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { LocationService.locationFlow.collect { gpsData -> mapHandler?.centerOnLocation(gpsData.latitude, gpsData.longitude) mapHandler?.updateUserPosition(gpsData.latitude, gpsData.longitude, gpsData.cog.toFloat()) - viewModel.addGpsPoint(gpsData.latitude, gpsData.longitude, gpsData.sog, gpsData.cog) instrumentHandler?.updateDisplay( sog = "%.1f".format(Locale.getDefault(), gpsData.sog), - cog = "%.0f°".format(Locale.getDefault(), gpsData.cog) + cog = "%.0f°".format(Locale.getDefault(), gpsData.cog), + cogBearingDeg = gpsData.cog.toFloat() ) if (!conditionsLoaded) { conditionsLoaded = true @@ -319,16 +330,27 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener { viewModel.marineConditions.collect { c -> if (c == null) return@collect instrumentHandler?.updateDisplay( - tws = c.windSpeedKt?.let { "%.1f".format(Locale.getDefault(), it) } ?: "—" + tws = c.windSpeedKt?.let { "%.1f".format(Locale.getDefault(), it) }, + twsBearingDeg = c.windDirDeg?.toFloat() ) instrumentHandler?.updateConditions( - currSpd = c.currentSpeedKt?.let { "%.1f kn".format(Locale.getDefault(), it) } ?: "—", - currDir = c.currentDirDeg?.let { "%.0f°".format(Locale.getDefault(), it) } ?: "—", - waveHt = c.waveHeightM?.let { "%.1f m".format(Locale.getDefault(), it) } ?: "—", - waveDir = c.waveDirDeg?.let { "%.0f°".format(Locale.getDefault(), it) } ?: "—", - swellHt = c.swellHeightM?.let { "%.1f m".format(Locale.getDefault(), it) } ?: "—", - swellPer = c.swellPeriodS?.let { "%.0f s".format(Locale.getDefault(), it) } ?: "—" + currSpd = c.currentSpeedKt?.let { "%.1f".format(Locale.getDefault(), it) } ?: "—", + currDirDeg = c.currentDirDeg?.toFloat(), + waveHeightM = c.waveHeightM, + waveDirDeg = c.waveDirDeg?.toFloat(), + swellHeightM = c.swellHeightM, + swellDirDeg = c.swellDirDeg?.toFloat(), + swellPeriodS = c.swellPeriodS ) + val swellHtFt = c.swellHeightM?.let { (it * 3.28084f).toFloat() } ?: 3f + val windHtFt = c.waveHeightM?.let { (it * 3.28084f).toFloat() } ?: 1.5f + val swellPeriod = c.swellPeriodS?.toFloat() ?: 10f + instrumentHandler?.updateWaveState(swellHtFt, swellPeriod, windHtFt) + } + } + lifecycleScope.launch { + LocationService.nmeaDepthDataFlow.collect { depthData -> + instrumentHandler?.updateDisplay(depthM = depthData.depthMeters) } } lifecycleScope.launch { diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/InstrumentHandler.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/InstrumentHandler.kt index 370d8cf..84815ce 100644 --- a/android-app/app/src/main/kotlin/org/terst/nav/ui/InstrumentHandler.kt +++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/InstrumentHandler.kt @@ -1,66 +1,150 @@ package org.terst.nav.ui import android.widget.TextView +import java.util.Locale + +// ── Pure formatting helpers (top-level for testability) ────────────────────── + +private const val M_TO_FT = 3.28084 + +/** Converts metres to feet. */ +fun metresToFeet(metres: Double): Double = metres * M_TO_FT + +/** Formats a feet value to one decimal place. */ +fun formatFt(ft: Double, locale: Locale = Locale.getDefault()): String = + "%.1f".format(locale, ft) + +/** Formats a bearing to zero decimal places with a degree symbol. */ +fun formatBearing(deg: Double, locale: Locale = Locale.getDefault()): String = + "%.0f°".format(locale, deg) + +/** Formats a swell period with leading dot separator. */ +fun formatPeriod(sec: Double, locale: Locale = Locale.getDefault()): String = + "· %.0fs".format(locale, sec) + +// ── InstrumentHandler ──────────────────────────────────────────────────────── /** - * Handles the display of instrument data in the UI. + * Drives all text fields, direction arrows, and the wave view in the + * instrument bottom sheet. + * + * Forecast [DirectionArrowView] instances are initialised with OCEAN style. + * + * Units contract: + * - Speed values: pre-formatted strings in knots (caller's responsibility) + * - Height values: caller passes raw metres; this class converts to feet + * - Bearing values: raw degrees as Float, rotated into arrows and formatted + * into bearing TextViews by this class */ class InstrumentHandler( - private val valueAws: TextView, - private val valueTws: TextView, - private val valueHdg: TextView, - private val valueCog: TextView, - private val valueBsp: TextView, - private val valueSog: TextView, + // ── Instrument section TextViews ───────────────────────────────── + private val valueAws: TextView, + private val valueTws: TextView, + private val valueHdg: TextView, + private val valueCog: TextView, + private val valueBsp: TextView, + private val valueSog: TextView, private val valueDepth: TextView, - private val valueBaro: TextView, - private val valueCurrSpd: TextView, - private val valueCurrDir: TextView?, - private val valueWaveHt: TextView, - private val valueWaveDir: TextView?, - private val valueSwellHt: TextView, - private val valueSwellPer: TextView + private val valueBaro: TextView, + // ── Instrument section DirectionArrowViews ─────────────────────── + private val arrowAws: DirectionArrowView, + private val arrowTws: DirectionArrowView, + private val arrowHdg: DirectionArrowView, + private val arrowCog: DirectionArrowView, + // ── Forecast section TextViews ─────────────────────────────────── + private val valueCurrSpd: TextView, + private val valueWaveHt: TextView, + private val valueSwellHt: TextView, + private val valueSwellPer: TextView, + // ── Forecast section DirectionArrowViews ───────────────────────── + private val arrowCurr: DirectionArrowView, + private val arrowWaves: DirectionArrowView, + private val arrowSwell: DirectionArrowView, + // ── Forecast section bearing TextViews ─────────────────────────── + private val bearingCurr: TextView, + private val bearingWaves: TextView, + private val bearingSwell: TextView, + // ── Wave view ──────────────────────────────────────────────────── + private val waveView: WaveView ) { + init { + arrowCurr.arrowStyle = DirectionArrowView.ArrowStyle.OCEAN + arrowWaves.arrowStyle = DirectionArrowView.ArrowStyle.OCEAN + arrowSwell.arrowStyle = DirectionArrowView.ArrowStyle.OCEAN + } + /** - * Updates the text displays for the given instruments. Null arguments leave the current value unchanged. + * Updates instrument-section text and arrows. + * Null arguments leave the current value unchanged. + * [depthM] is raw metres — converted to feet internally. */ fun updateDisplay( - aws: String? = null, - tws: String? = null, - hdg: String? = null, - cog: String? = null, - bsp: String? = null, - sog: String? = null, - depth: String? = null, - baro: String? = null + aws: String? = null, awsBearingDeg: Float? = null, + tws: String? = null, twsBearingDeg: Float? = null, + hdg: String? = null, hdgBearingDeg: Float? = null, + cog: String? = null, cogBearingDeg: Float? = null, + bsp: String? = null, + sog: String? = null, + depthM: Double? = null, + baro: String? = null ) { - aws?.let { valueAws.text = it } - tws?.let { valueTws.text = it } - hdg?.let { valueHdg.text = it } - cog?.let { valueCog.text = it } - bsp?.let { valueBsp.text = it } - sog?.let { valueSog.text = it } - depth?.let { valueDepth.text = it } - baro?.let { valueBaro.text = it } + aws?.let { valueAws.text = it } + tws?.let { valueTws.text = it } + hdg?.let { valueHdg.text = it } + cog?.let { valueCog.text = it } + bsp?.let { valueBsp.text = it } + sog?.let { valueSog.text = it } + baro?.let { valueBaro.text = it } + depthM?.let { valueDepth.text = formatFt(metresToFeet(it)) } + + awsBearingDeg?.let { arrowAws.bearing = it } + twsBearingDeg?.let { arrowTws.bearing = it } + hdgBearingDeg?.let { arrowHdg.bearing = it } + cogBearingDeg?.let { arrowCog.bearing = it } } /** - * Updates the forecast conditions section (Curr, Wave, Swell). - * Null arguments leave the current value unchanged. + * Updates the forecast section. + * [waveHeightM] and [swellHeightM] are raw metres — converted to feet internally. */ fun updateConditions( - currSpd: String? = null, - currDir: String? = null, - waveHt: String? = null, - waveDir: String? = null, - swellHt: String? = null, - swellPer: String? = null + currSpd: String? = null, + currDirDeg: Float? = null, + waveHeightM: Double? = null, + waveDirDeg: Float? = null, + swellHeightM: Double? = null, + swellDirDeg: Float? = null, + swellPeriodS: Double? = null ) { currSpd?.let { valueCurrSpd.text = it } - currDir?.let { valueCurrDir?.text = it } - waveHt?.let { valueWaveHt.text = it } - waveDir?.let { valueWaveDir?.text = it } - swellHt?.let { valueSwellHt.text = it } - swellPer?.let { valueSwellPer.text = it } + currDirDeg?.let { + arrowCurr.bearing = it + bearingCurr.text = formatBearing(it.toDouble()) + } + waveHeightM?.let { valueWaveHt.text = formatFt(metresToFeet(it)) } + waveDirDeg?.let { + arrowWaves.bearing = it + bearingWaves.text = formatBearing(it.toDouble()) + } + swellHeightM?.let { valueSwellHt.text = formatFt(metresToFeet(it)) } + swellDirDeg?.let { + arrowSwell.bearing = it + bearingSwell.text = formatBearing(it.toDouble()) + } + swellPeriodS?.let { valueSwellPer.text = formatPeriod(it) } + } + + /** + * Updates the WaveView with current sea state. Call whenever new forecast data arrives. + * All inputs in feet. + */ + fun updateWaveState( + swellHeightFt: Float, + swellPeriodSec: Float, + windWaveHeightFt: Float + ) { + waveView.swellHeightFt = swellHeightFt + waveView.swellPeriodSec = swellPeriodSec + waveView.windWaveHeightFt = windWaveHeightFt } } diff --git a/android-app/app/src/test/kotlin/org/terst/nav/ui/InstrumentHandlerTest.kt b/android-app/app/src/test/kotlin/org/terst/nav/ui/InstrumentHandlerTest.kt new file mode 100644 index 0000000..a749ba2 --- /dev/null +++ b/android-app/app/src/test/kotlin/org/terst/nav/ui/InstrumentHandlerTest.kt @@ -0,0 +1,39 @@ +package org.terst.nav.ui + +import org.junit.Assert.assertEquals +import org.junit.Test +import java.util.Locale + +class InstrumentHandlerTest { + + @Test + fun `metresToFeet converts correctly`() { + assertEquals(3.28f, metresToFeet(1.0).toFloat(), 0.01f) + } + + @Test + fun `metresToFeet zero returns zero`() { + assertEquals(0f, metresToFeet(0.0).toFloat(), 0.001f) + } + + @Test + fun `formatFt formats to one decimal`() { + val result = formatFt(3.28084, Locale.US) + assertEquals("3.3", result) + } + + @Test + fun `formatBearing appends degree symbol`() { + assertEquals("275°", formatBearing(275.0, Locale.US)) + } + + @Test + fun `formatBearing rounds to zero decimals`() { + assertEquals("123°", formatBearing(123.4, Locale.US)) + } + + @Test + fun `formatPeriod appends s`() { + assertEquals("· 14s", formatPeriod(14.0, Locale.US)) + } +} -- cgit v1.2.3 From f9b8801eb52c48986eb0123e8758f7ab78736dec Mon Sep 17 00:00:00 2001 From: Peter Stone Date: Mon, 6 Apr 2026 09:41:32 +0000 Subject: feat(tracks): persist tracks as GPX in Documents/Nav/ — survives uninstall MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit GpxSerializer/GpxParser: full round-trip of all TrackPoint fields via GPX 1.1 + nav: extensions namespace. 13 unit tests. TrackStorage: MediaStore on API 29+ (no permission needed), direct file I/O on API 24-28 (WRITE_EXTERNAL_STORAGE maxSdkVersion=28). TrackRepository: stopTrack() is now suspend, writes GPX and returns TrackSummary (distance nm, duration, max/avg SOG, avg wind, avg wave). getPastTracks() lazy-loads from Documents/Nav/ on first call. Co-Authored-By: Claude Sonnet 4.6 --- android-app/app/src/main/AndroidManifest.xml | 3 + .../main/kotlin/org/terst/nav/NavApplication.kt | 3 +- .../main/kotlin/org/terst/nav/track/GpxParser.kt | 96 +++++++++++++++++ .../kotlin/org/terst/nav/track/GpxSerializer.kt | 62 +++++++++++ .../kotlin/org/terst/nav/track/TrackRepository.kt | 49 +++++++-- .../kotlin/org/terst/nav/track/TrackStorage.kt | 120 +++++++++++++++++++++ .../kotlin/org/terst/nav/track/TrackSummary.kt | 54 ++++++++++ .../main/kotlin/org/terst/nav/ui/MainViewModel.kt | 10 +- .../kotlin/org/terst/nav/track/GpxRoundTripTest.kt | 83 ++++++++++++++ .../kotlin/org/terst/nav/track/TrackSummaryTest.kt | 56 ++++++++++ 10 files changed, 524 insertions(+), 12 deletions(-) create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/track/GpxParser.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/track/GpxSerializer.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/track/TrackStorage.kt create mode 100644 android-app/app/src/main/kotlin/org/terst/nav/track/TrackSummary.kt create mode 100644 android-app/app/src/test/kotlin/org/terst/nav/track/GpxRoundTripTest.kt create mode 100644 android-app/app/src/test/kotlin/org/terst/nav/track/TrackSummaryTest.kt (limited to 'android-app/app/src/test/kotlin') diff --git a/android-app/app/src/main/AndroidManifest.xml b/android-app/app/src/main/AndroidManifest.xml index e2e311d..2f23e87 100644 --- a/android-app/app/src/main/AndroidManifest.xml +++ b/android-app/app/src/main/AndroidManifest.xml @@ -8,6 +8,9 @@ + + { + val points = mutableListOf() + val factory = XmlPullParserFactory.newInstance().apply { isNamespaceAware = true } + val xpp = factory.newPullParser() + xpp.setInput(input, "UTF-8") + + var lat = 0.0; var lon = 0.0; var timeMs = 0L + var sog = 0.0; var cog = 0.0 + var hdg: Double? = null; var bsp: Double? = null + var depth: Double? = null; var baro: Double? = null + var windSpd: Double? = null; var windAng: Double? = null + var trueWind = false; var airTemp: Double? = null + var waveHt: Double? = null; var currSpd: Double? = null; var currDir: Double? = null + var inExtensions = false; var currentTag = "" + + var event = xpp.eventType + while (event != XmlPullParser.END_DOCUMENT) { + when (event) { + XmlPullParser.START_TAG -> { + currentTag = xpp.name ?: "" + when (currentTag) { + "trkpt" -> { + lat = xpp.getAttributeValue(null, "lat")?.toDoubleOrNull() ?: 0.0 + lon = xpp.getAttributeValue(null, "lon")?.toDoubleOrNull() ?: 0.0 + // reset fields for this point + timeMs = 0L; sog = 0.0; cog = 0.0 + hdg = null; bsp = null; depth = null; baro = null + windSpd = null; windAng = null; trueWind = false + airTemp = null; waveHt = null; currSpd = null; currDir = null + } + "extensions" -> inExtensions = true + } + } + XmlPullParser.TEXT -> { + val text = xpp.text?.trim() ?: "" + if (text.isEmpty()) { event = xpp.next(); continue } + when { + currentTag == "time" -> timeMs = runCatching { + Instant.parse(text).toEpochMilli() + }.getOrDefault(0L) + inExtensions -> when (currentTag) { + "sog" -> sog = text.toDoubleOrNull() ?: sog + "cog" -> cog = text.toDoubleOrNull() ?: cog + "hdg" -> hdg = text.toDoubleOrNull() + "bsp" -> bsp = text.toDoubleOrNull() + "depth" -> depth = text.toDoubleOrNull() + "baro" -> baro = text.toDoubleOrNull() + "windSpd" -> windSpd = text.toDoubleOrNull() + "windAng" -> windAng = text.toDoubleOrNull() + "trueWind" -> trueWind = text == "true" + "airTemp" -> airTemp = text.toDoubleOrNull() + "waveHt" -> waveHt = text.toDoubleOrNull() + "currSpd" -> currSpd = text.toDoubleOrNull() + "currDir" -> currDir = text.toDoubleOrNull() + } + } + } + XmlPullParser.END_TAG -> { + val tag = xpp.name ?: "" + when (tag) { + "trkpt" -> points.add(TrackPoint( + lat = lat, lon = lon, + sogKnots = sog, cogDeg = cog, + headingDeg = hdg, waterSpeedKnots = bsp, + depthMeters = depth, baroHpa = baro, + windSpeedKnots = windSpd, windAngleDeg = windAng, + isTrueWind = trueWind, airTempC = airTemp, + waveHeightM = waveHt, currentSpeedKts = currSpd, + currentDirDeg = currDir, + timestampMs = if (timeMs > 0) timeMs else System.currentTimeMillis() + )) + "extensions" -> inExtensions = false + } + currentTag = "" + } + } + event = xpp.next() + } + return points + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/track/GpxSerializer.kt b/android-app/app/src/main/kotlin/org/terst/nav/track/GpxSerializer.kt new file mode 100644 index 0000000..e4b9448 --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/track/GpxSerializer.kt @@ -0,0 +1,62 @@ +package org.terst.nav.track + +import java.time.Instant +import java.time.ZoneOffset +import java.time.format.DateTimeFormatter + +/** + * Serializes a list of [TrackPoint]s to a GPX 1.1 XML string. + * + * Nav-specific fields (SOG, COG, depth, baro, wind) are stored in a + * `` block under the `nav:` namespace so the file remains + * valid GPX while preserving full fidelity for round-trip reload. + */ +object GpxSerializer { + + private val ISO8601 = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'") + .withZone(ZoneOffset.UTC) + + fun serialize(points: List, trackName: String): String = buildString { + appendLine("""""") + appendLine( + """""" + ) + appendLine(" ") + appendLine(" ${escapeXml(trackName)}") + appendLine(" ") + + for (pt in points) { + appendLine(""" """) + appendLine(" 0") + appendLine(" ") + appendLine(" ") + appendLine(" ${pt.sogKnots}") + appendLine(" ${pt.cogDeg}") + pt.headingDeg?.let { appendLine(" $it") } + pt.waterSpeedKnots?.let { appendLine(" $it") } + pt.depthMeters?.let { appendLine(" $it") } + pt.baroHpa?.let { appendLine(" $it") } + pt.windSpeedKnots?.let { appendLine(" $it") } + pt.windAngleDeg?.let { appendLine(" $it") } + if (pt.isTrueWind) { appendLine(" true") } + pt.airTempC?.let { appendLine(" $it") } + pt.waveHeightM?.let { appendLine(" $it") } + pt.currentSpeedKts?.let { appendLine(" $it") } + pt.currentDirDeg?.let { appendLine(" $it") } + appendLine(" ") + appendLine(" ") + } + + appendLine(" ") + appendLine(" ") + append("") + } + + private fun escapeXml(s: String) = s + .replace("&", "&") + .replace("<", "<") + .replace(">", ">") + .replace("\"", """) +} 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 index 85dd2dd..ed32497 100644 --- 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 @@ -1,23 +1,45 @@ package org.terst.nav.track -class TrackRepository { +import android.content.Context +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext + +class TrackRepository(context: Context) { + + private val storage = TrackStorage(context) var isRecording: Boolean = false private set private val activePoints = mutableListOf() - private val pastTracks = mutableListOf>() + private var trackStartMs = 0L + + // Loaded lazily from Documents/Nav/ on first access + private val _pastTracks = mutableListOf>() + private var pastTracksLoaded = false fun startTrack() { activePoints.clear() + trackStartMs = System.currentTimeMillis() isRecording = true } - fun stopTrack() { - if (isRecording && activePoints.isNotEmpty()) { - pastTracks.add(activePoints.toList()) - } + /** + * Stops the active track, computes a [TrackSummary], persists the track + * to shared storage, and returns the summary. Returns null if no points + * were recorded. + */ + suspend fun stopTrack(): TrackSummary? = withContext(Dispatchers.IO) { + if (!isRecording) return@withContext null isRecording = false + val points = activePoints.toList() + activePoints.clear() + if (points.isEmpty()) return@withContext null + + val summary = summarise(points) + _pastTracks.add(0, points) // prepend so most recent is first + storage.saveTrack(points, trackStartMs) + summary } fun addPoint(point: TrackPoint): Boolean { @@ -28,5 +50,18 @@ class TrackRepository { fun getPoints(): List = activePoints.toList() - fun getPastTracks(): List> = pastTracks.toList() + /** + * Returns all completed tracks, loading from Documents/Nav/ on first call. + * Subsequent calls return the in-memory list (storage is source of truth + * only at startup). + */ + suspend fun getPastTracks(): List> = withContext(Dispatchers.IO) { + if (!pastTracksLoaded) { + pastTracksLoaded = true + val stored = storage.loadAllTracks() + // Merge: put stored tracks behind any in-memory tracks from this session + _pastTracks.addAll(stored) + } + _pastTracks.toList() + } } diff --git a/android-app/app/src/main/kotlin/org/terst/nav/track/TrackStorage.kt b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackStorage.kt new file mode 100644 index 0000000..620431c --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackStorage.kt @@ -0,0 +1,120 @@ +package org.terst.nav.track + +import android.content.ContentValues +import android.content.Context +import android.os.Build +import android.os.Environment +import android.provider.MediaStore +import java.io.File +import java.time.Instant +import java.time.ZoneOffset +import java.time.format.DateTimeFormatter + +/** + * Persists completed tracks as GPX files in the shared Documents/Nav/ folder. + * + * Files written here survive app uninstall because they live in user-owned + * shared storage rather than app-private storage. + * + * API 29+: uses MediaStore (no permission required for Documents/). + * API < 29: writes directly to Environment.DIRECTORY_DOCUMENTS (requires + * WRITE_EXTERNAL_STORAGE permission declared in the manifest). + */ +class TrackStorage(private val context: Context) { + + private val fileTimestamp = DateTimeFormatter + .ofPattern("yyyy-MM-dd_HH-mm-ss") + .withZone(ZoneOffset.UTC) + + private val trackName = DateTimeFormatter + .ofPattern("yyyy-MM-dd HH:mm") + .withZone(ZoneOffset.UTC) + + /** Write a completed track to Documents/Nav/. Returns true on success. */ + fun saveTrack(points: List, startMs: Long): Boolean { + if (points.isEmpty()) return false + val name = trackName.format(Instant.ofEpochMilli(startMs)) + val fileName = "nav_${fileTimestamp.format(Instant.ofEpochMilli(startMs))}.gpx" + val gpx = GpxSerializer.serialize(points, name) + + return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { + saveViaMediaStore(fileName, gpx) + } else { + saveViaFile(fileName, gpx) + } + } + + /** Load all tracks previously saved to Documents/Nav/. */ + fun loadAllTracks(): List> { + return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { + loadViaMediaStore() + } else { + loadViaFile() + } + } + + // ── API 29+ ────────────────────────────────────────────────────────────── + + private fun saveViaMediaStore(fileName: String, gpx: String): Boolean { + val values = ContentValues().apply { + put(MediaStore.Files.FileColumns.DISPLAY_NAME, fileName) + put(MediaStore.Files.FileColumns.MIME_TYPE, "application/gpx+xml") + put(MediaStore.Files.FileColumns.RELATIVE_PATH, "Documents/Nav/") + } + val uri = context.contentResolver.insert( + MediaStore.Files.getContentUri("external"), values + ) ?: return false + + return runCatching { + context.contentResolver.openOutputStream(uri)?.use { it.write(gpx.toByteArray()) } + true + }.getOrDefault(false) + } + + private fun loadViaMediaStore(): List> { + val tracks = mutableListOf>() + val uri = MediaStore.Files.getContentUri("external") + val projection = arrayOf(MediaStore.Files.FileColumns._ID) + val selection = "${MediaStore.Files.FileColumns.RELATIVE_PATH} = ? " + + "AND ${MediaStore.Files.FileColumns.DISPLAY_NAME} LIKE ?" + val args = arrayOf("Documents/Nav/", "nav_%.gpx") + + context.contentResolver.query(uri, projection, selection, args, null)?.use { cursor -> + val idCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID) + while (cursor.moveToNext()) { + val fileUri = android.net.Uri.withAppendedPath(uri, cursor.getLong(idCol).toString()) + runCatching { + context.contentResolver.openInputStream(fileUri)?.use { stream -> + val points = GpxParser.parse(stream) + if (points.isNotEmpty()) tracks.add(points) + } + } + } + } + return tracks + } + + // ── API < 29 ───────────────────────────────────────────────────────────── + + private fun navDir(): File { + val docs = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS) + return File(docs, "Nav").also { it.mkdirs() } + } + + private fun saveViaFile(fileName: String, gpx: String): Boolean = runCatching { + File(navDir(), fileName).writeText(gpx) + true + }.getOrDefault(false) + + private fun loadViaFile(): List> { + val dir = navDir() + if (!dir.exists()) return emptyList() + return dir.listFiles { f -> f.name.startsWith("nav_") && f.name.endsWith(".gpx") } + ?.sortedBy { it.name } + ?.mapNotNull { file -> + runCatching { GpxParser.parse(file.inputStream()) } + .getOrNull() + ?.takeIf { it.isNotEmpty() } + } ?: emptyList() + } +} diff --git a/android-app/app/src/main/kotlin/org/terst/nav/track/TrackSummary.kt b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackSummary.kt new file mode 100644 index 0000000..3f2f3be --- /dev/null +++ b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackSummary.kt @@ -0,0 +1,54 @@ +package org.terst.nav.track + +import kotlin.math.* + +data class TrackSummary( + val distanceNm: Double, + val durationMs: Long, + val maxSogKt: Double, + val avgSogKt: Double, + val avgWindKt: Double?, // null if no wind data in track + val avgWaveHeightM: Double? // null if no wave data in track +) { + val durationMinutes: Long get() = durationMs / 60_000 +} + +/** Computes a [TrackSummary] from a completed list of [TrackPoint]s. */ +fun summarise(points: List): TrackSummary { + require(points.isNotEmpty()) + + var distanceNm = 0.0 + for (i in 1 until points.size) { + distanceNm += haversineNm(points[i - 1], points[i]) + } + + val durationMs = points.last().timestampMs - points.first().timestampMs + val maxSog = points.maxOf { it.sogKnots } + val avgSog = points.map { it.sogKnots }.average() + + val windReadings = points.mapNotNull { it.windSpeedKnots } + val avgWind = if (windReadings.isNotEmpty()) windReadings.average() else null + + val waveReadings = points.mapNotNull { it.waveHeightM } + val avgWave = if (waveReadings.isNotEmpty()) waveReadings.average() else null + + return TrackSummary( + distanceNm = distanceNm, + durationMs = durationMs, + maxSogKt = maxSog, + avgSogKt = avgSog, + avgWindKt = avgWind, + avgWaveHeightM = avgWave + ) +} + +private fun haversineNm(a: TrackPoint, b: TrackPoint): Double { + val r = 3440.065 // Earth radius in nautical miles + val dLat = Math.toRadians(b.lat - a.lat) + val dLon = Math.toRadians(b.lon - a.lon) + val sinDLat = sin(dLat / 2) + val sinDLon = sin(dLon / 2) + val h = sinDLat * sinDLat + + cos(Math.toRadians(a.lat)) * cos(Math.toRadians(b.lat)) * sinDLon * sinDLon + return 2 * r * asin(sqrt(h)) +} 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 2c56b06..c1707ab 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 @@ -67,10 +67,12 @@ class MainViewModel( } fun stopTrack() { - trackRepository.stopTrack() - _pastTracks.value = trackRepository.getPastTracks() - _trackPoints.value = emptyList() - _isRecording.value = false + viewModelScope.launch { + trackRepository.stopTrack() + _pastTracks.value = trackRepository.getPastTracks() + _trackPoints.value = emptyList() + _isRecording.value = false + } } fun addGpsPoint(lat: Double, lon: Double, sogKnots: Double, cogDeg: Double) { diff --git a/android-app/app/src/test/kotlin/org/terst/nav/track/GpxRoundTripTest.kt b/android-app/app/src/test/kotlin/org/terst/nav/track/GpxRoundTripTest.kt new file mode 100644 index 0000000..7ed7ec7 --- /dev/null +++ b/android-app/app/src/test/kotlin/org/terst/nav/track/GpxRoundTripTest.kt @@ -0,0 +1,83 @@ +package org.terst.nav.track + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class GpxRoundTripTest { + + private fun roundTrip(points: List): List { + val gpx = GpxSerializer.serialize(points, "Test Track") + return GpxParser.parse(gpx.byteInputStream()) + } + + @Test + fun `round-trip preserves lat and lon`() { + val pt = TrackPoint(lat = 37.8044, lon = -122.2712, sogKnots = 6.1, cogDeg = 247.0) + val result = roundTrip(listOf(pt)).first() + assertEquals(37.8044, result.lat, 0.00001) + assertEquals(-122.2712, result.lon, 0.00001) + } + + @Test + fun `round-trip preserves sog and cog`() { + val pt = TrackPoint(lat = 0.0, lon = 0.0, sogKnots = 5.3, cogDeg = 183.0) + val result = roundTrip(listOf(pt)).first() + assertEquals(5.3, result.sogKnots, 0.001) + assertEquals(183.0, result.cogDeg, 0.001) + } + + @Test + fun `round-trip preserves optional nav fields`() { + val pt = TrackPoint( + lat = 1.0, lon = 2.0, sogKnots = 4.0, cogDeg = 90.0, + depthMeters = 12.5, baroHpa = 1013.2, windSpeedKnots = 14.0, + windAngleDeg = 45.0, isTrueWind = true, waveHeightM = 1.2 + ) + val result = roundTrip(listOf(pt)).first() + assertEquals(12.5, result.depthMeters!!, 0.001) + assertEquals(1013.2, result.baroHpa!!, 0.001) + assertEquals(14.0, result.windSpeedKnots!!, 0.001) + assertEquals(45.0, result.windAngleDeg!!, 0.001) + assertTrue(result.isTrueWind) + assertEquals(1.2, result.waveHeightM!!, 0.001) + } + + @Test + fun `round-trip with null optional fields leaves them null`() { + val pt = TrackPoint(lat = 0.0, lon = 0.0, sogKnots = 0.0, cogDeg = 0.0) + val result = roundTrip(listOf(pt)).first() + assertNull(result.depthMeters) + assertNull(result.baroHpa) + assertNull(result.windSpeedKnots) + } + + @Test + fun `round-trip preserves multiple points in order`() { + val points = listOf( + TrackPoint(lat = 1.0, lon = 1.0, sogKnots = 1.0, cogDeg = 0.0, timestampMs = 1000L), + TrackPoint(lat = 2.0, lon = 2.0, sogKnots = 2.0, cogDeg = 90.0, timestampMs = 2000L), + TrackPoint(lat = 3.0, lon = 3.0, sogKnots = 3.0, cogDeg = 180.0, timestampMs = 3000L), + ) + val result = roundTrip(points) + assertEquals(3, result.size) + assertEquals(1.0, result[0].lat, 0.00001) + assertEquals(2.0, result[1].lat, 0.00001) + assertEquals(3.0, result[2].lat, 0.00001) + } + + @Test + fun `round-trip preserves timestamp`() { + val ts = 1712345678000L + val pt = TrackPoint(lat = 0.0, lon = 0.0, sogKnots = 0.0, cogDeg = 0.0, timestampMs = ts) + val result = roundTrip(listOf(pt)).first() + assertEquals(ts, result.timestampMs) + } + + @Test + fun `track name with special chars is escaped`() { + val gpx = GpxSerializer.serialize(emptyList(), "Track & \"Fun\" ") + assertTrue(gpx.contains("Track & "Fun" <test>")) + } +} diff --git a/android-app/app/src/test/kotlin/org/terst/nav/track/TrackSummaryTest.kt b/android-app/app/src/test/kotlin/org/terst/nav/track/TrackSummaryTest.kt new file mode 100644 index 0000000..2daaf45 --- /dev/null +++ b/android-app/app/src/test/kotlin/org/terst/nav/track/TrackSummaryTest.kt @@ -0,0 +1,56 @@ +package org.terst.nav.track + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class TrackSummaryTest { + + private fun pt(lat: Double, lon: Double, sog: Double = 5.0, ts: Long = 0L) = + TrackPoint(lat = lat, lon = lon, sogKnots = sog, cogDeg = 0.0, timestampMs = ts) + + @Test + fun `distance between two points one nm apart`() { + // 1 nautical mile north along the prime meridian ≈ 0.01667° latitude + val a = pt(0.0, 0.0, ts = 0L) + val b = pt(0.016667, 0.0, ts = 60_000L) + val s = summarise(listOf(a, b)) + assertEquals(1.0, s.distanceNm, 0.01) + } + + @Test + fun `duration is last minus first timestamp`() { + val points = listOf(pt(0.0, 0.0, ts = 1_000L), pt(0.0, 0.0, ts = 61_000L)) + assertEquals(60_000L, summarise(points).durationMs) + } + + @Test + fun `max sog picks highest value`() { + val points = listOf(pt(0.0, 0.0, sog = 4.0), pt(0.0, 0.0, sog = 9.2), pt(0.0, 0.0, sog = 6.0)) + assertEquals(9.2, summarise(points).maxSogKt, 0.001) + } + + @Test + fun `avg wind is null when no wind data`() { + val s = summarise(listOf(pt(0.0, 0.0))) + assertNull(s.avgWindKt) + } + + @Test + fun `avg wind averages available readings`() { + val points = listOf( + TrackPoint(0.0, 0.0, 5.0, 0.0, windSpeedKnots = 10.0), + TrackPoint(0.0, 0.0, 5.0, 0.0, windSpeedKnots = 20.0), + ) + assertEquals(15.0, summarise(points).avgWindKt!!, 0.001) + } + + @Test + fun `avg wave height averages available readings`() { + val points = listOf( + TrackPoint(0.0, 0.0, 5.0, 0.0, waveHeightM = 1.0), + TrackPoint(0.0, 0.0, 5.0, 0.0, waveHeightM = 3.0), + ) + assertEquals(2.0, summarise(points).avgWaveHeightM!!, 0.001) + } +} -- cgit v1.2.3