Colota - Android GPS Location tracker
feat(export): native trip serializer + full payload attribute set (#439)
Max Dietrichad7cff13edd5
diff --git a/apps/docs/docs/development/architecture.md b/apps/docs/docs/development/architecture.mdindex 182c3084..2f913aac 100644--- a/apps/docs/docs/development/architecture.md+++ b/apps/docs/docs/development/architecture.md@@ -272,7 +272,7 @@ For backups, two `internal` methods support the export/import flow without expos| `AutoExportAlarmReceiver` | Broadcast receiver fired by AlarmManager at the configured time - hands off to `AutoExportWorker` because the receiver's 10s budget can't run an export || `AutoExportScheduler` | Arms `AlarmManager.setAndAllowWhileIdle` for the next configured wall-clock time. Called on enable, after each worker run, after schedule edits and on boot || `AutoExportConfig` | Typed data class wrapping auto-export settings (interval, time-of-day, weekday, day-of-month, enabledAt) from the SQLite settings table with validation, `isExportDue()` and `nextExportTimestamp()` |-| `ExportConverters` | Native Kotlin export converters (CSV, GeoJSON, GPX, KML) with in-memory, streaming, and file-based (`exportToFile`) interfaces |+| `ExportConverters` | Native CSV/GeoJSON/GPX/KML serialization for both "Export all" (flat, streamed via `exportToFile`) and per-trip / multi-select export (trip-segmented via `convertTrips`, reached through the `exportTripsToFile` bridge). In-memory, streaming, and file-based interfaces || `ShortcutHandlerActivity` | Handles app shortcut intents (start/stop tracking) without showing UI - reads config from DB via `ServiceConfig.fromDatabase()` and dispatches to `LocationForegroundService` |## React Native Layer@@ -363,7 +363,7 @@ Supporting utilities in `mapUtils.ts`:| --- | --- || `logger` | Environment-aware logging - suppresses debug/info console output in production via `__DEV__`, always logs warn/error to console. All levels are always captured in a ring buffer (2000 entries) for the Logging screen || `geo` | Haversine distance, speed/distance/duration/time formatting with configurable unit system (metric/imperial) and time format (12h/24h), auto-detected from locale on first use |-| `exportConverters` | Converts location data to CSV, GeoJSON, GPX, and KML export formats (flat and trip-aware variants) |+| `exportConverters` | Export-format metadata (labels, icons, extensions, MIME types) for the export UI. Serialization itself is native - see `ExportConverters.kt` || `trips` | Trip segmentation via time-gap detection (15-min threshold) with distance computation, trip stats (avg speed, elevation gain/loss), and trip color assignment || `queueStatus` | Maps sync queue size to color indicators for the dashboard || `settingsValidation` | URL validation and security checks for endpoint configuration |diff --git a/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt b/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.ktindex fa39e85b..f2eca358 100644--- a/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt+++ b/apps/mobile/android/app/src/main/java/com/colota/bridge/LocationServiceModule.kt@@ -1018,6 +1018,22 @@ class LocationServiceModule(reactContext: ReactApplicationContext) :}}+ /**+ * Exports the given trips (each a `{index, color, startTs, endTs}`) as a+ * trip-segmented file written to cache. Rows are queried per trip by range.+ * Returns the file path (same contract as `writeFile`).+ */+ @ReactMethod+ fun exportTripsToFile(trips: ReadableArray, format: String, fileName: String, promise: Promise) = executeAsync(promise) {+ val tripExports = ArrayList<ExportConverters.TripExport>(trips.size())+ for (i in 0 until trips.size()) {+ val t = trips.getMap(i) ?: continue+ val rows = dbHelper.getLocationsByDateRange(t.getDouble("startTs").toLong(), t.getDouble("endTs").toLong())+ tripExports.add(ExportConverters.TripExport(t.getInt("index"), t.getString("color") ?: "#3B82F6", rows))+ }+ fileOps.writeFile(fileName, ExportConverters.convertTrips(format, tripExports))+ }+@ReactMethodfun getExportFiles(promise: Promise) = executeAsync(promise) {val config = AutoExportConfig.from(dbHelper)diff --git a/apps/mobile/android/app/src/main/java/com/colota/export/ExportConverters.kt b/apps/mobile/android/app/src/main/java/com/colota/export/ExportConverters.ktindex 2e4e1d72..69064e0d 100644--- a/apps/mobile/android/app/src/main/java/com/colota/export/ExportConverters.kt+++ b/apps/mobile/android/app/src/main/java/com/colota/export/ExportConverters.kt@@ -6,6 +6,7 @@package com.Colota.exportimport com.Colota.data.DatabaseHelper+import com.Colota.util.BatteryStatusimport java.io.BufferedReaderimport java.io.BufferedWriterimport java.io.File@@ -63,9 +64,18 @@ object ExportConverters {private fun jsonValue(value: Any?): String = when (value) {null -> "null"is String -> "\"${escapeJson(value)}\""+ is Double, is Float -> jsNum(value)else -> value.toString()}+ /** Human-readable battery-status label for exports; null if not recorded. */+ private fun batteryStatusLabel(v: Any?): String? = when (v) {+ is Long -> BatteryStatus.toDisplayString(v.toInt())+ is Int -> BatteryStatus.toDisplayString(v)+ is Double -> BatteryStatus.toDisplayString(v.toInt())+ else -> null+ }+private fun escapeJson(s: String): String = buildString(s.length) {for (c in s) {when (c) {@@ -88,7 +98,9 @@ object ExportConverters {val altitude: Any?,val accuracy: Any?,val speed: Any?,+ val bearing: Any?,val battery: Any?,+ val batteryStatus: Any?,) {companion object {fun from(row: Map<String, Any?>): ExportRow = ExportRow(@@ -98,7 +110,9 @@ object ExportConverters {altitude = row["altitude"],accuracy = row["accuracy"],speed = row["speed"],+ bearing = row["bearing"],battery = row["battery"],+ batteryStatus = row["battery_status"],)}}@@ -116,12 +130,13 @@ object ExportConverters {private object CsvFormat : FormatWriter(".csv", "text/csv") {override fun writeHeader(w: Writer) {- w.write("id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,battery\n")+ w.write("id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery,battery_status\n")}override fun writeRow(w: Writer, row: ExportRow, globalIndex: Int, kml: KmlCoordsCollector?) {w.write(listOf(- globalIndex, row.ts, isoTime(row.ts), row.lat, row.lon,- row.accuracy ?: 0, row.altitude ?: 0, row.speed ?: 0, row.battery ?: 0+ globalIndex, row.ts, isoTime(row.ts), jsNum(row.lat), jsNum(row.lon),+ numOrZero(row.accuracy), numOrZero(row.altitude), numOrZero(row.speed), numOrZero(row.bearing), numOrZero(row.battery),+ batteryStatusLabel(row.batteryStatus) ?: "").joinToString(","))w.write("\n")}@@ -138,14 +153,16 @@ object ExportConverters {"type": "Feature","geometry": {"type": "Point",- "coordinates": [${row.lon}, ${row.lat}]+ "coordinates": [${jsNum(row.lon)}, ${jsNum(row.lat)}]},"properties": {"id": $globalIndex,"accuracy": ${jsonValue(row.accuracy)},"altitude": ${jsonValue(row.altitude)},"speed": ${jsonValue(row.speed)},+ "bearing": ${jsonValue(row.bearing)},"battery": ${jsonValue(row.battery)},+ "battery_status": ${jsonValue(batteryStatusLabel(row.batteryStatus))},"time": "${isoTime(row.ts)}"}}""")@@ -172,12 +189,14 @@ object ExportConverters {val lat = String.format(Locale.US, "%.6f", row.lat)val lon = String.format(Locale.US, "%.6f", row.lon)w.write(""" <trkpt lat="$lat" lon="$lon">- <ele>${row.altitude ?: 0}</ele>+ <ele>${numOrZero(row.altitude)}</ele><time>${isoTime(row.ts)}</time><extensions>- <accuracy>${row.accuracy ?: 0}</accuracy>- <speed>${row.speed ?: 0}</speed>- <battery>${row.battery ?: 0}</battery>+ <accuracy>${numOrZero(row.accuracy)}</accuracy>+ <speed>${numOrZero(row.speed)}</speed>+ <bearing>${numOrZero(row.bearing)}</bearing>+ <battery>${numOrZero(row.battery)}</battery>+ <battery_status>${batteryStatusLabel(row.batteryStatus) ?: ""}</battery_status></extensions></trkpt>""")@@ -207,12 +226,20 @@ object ExportConverters {""")}override fun writeRow(w: Writer, row: ExportRow, globalIndex: Int, kml: KmlCoordsCollector?) {- kml?.add("${row.lon},${row.lat},${row.altitude ?: 0}")+ kml?.add("${jsNum(row.lon)},${jsNum(row.lat)},${numOrZero(row.altitude)}")w.write(""" <Placemark><TimeStamp><when>${isoTime(row.ts)}</when></TimeStamp>- <description>Accuracy: ${row.accuracy ?: 0}m, Speed: ${row.speed ?: 0}m/s</description>+ <description>Accuracy: ${numOrZero(row.accuracy)}m, Speed: ${numOrZero(row.speed)}m/s</description>+ <ExtendedData>+ <Data name="accuracy"><value>${numOrZero(row.accuracy)}</value></Data>+ <Data name="altitude"><value>${numOrZero(row.altitude)}</value></Data>+ <Data name="speed"><value>${numOrZero(row.speed)}</value></Data>+ <Data name="bearing"><value>${numOrZero(row.bearing)}</value></Data>+ <Data name="battery"><value>${numOrZero(row.battery)}</value></Data>+ <Data name="battery_status"><value>${batteryStatusLabel(row.batteryStatus) ?: ""}</value></Data>+ </ExtendedData><Point>- <coordinates>${row.lon},${row.lat},${row.altitude ?: 0}</coordinates>+ <coordinates>${jsNum(row.lon)},${jsNum(row.lat)},${numOrZero(row.altitude)}</coordinates></Point></Placemark>""")@@ -329,4 +356,190 @@ object ExportConverters {"csv", "geojson", "gpx", "kml" -> forFormat(format).mimeTypeelse -> "text/plain"}++ // Trip-segmented export (one track/folder per trip), separate from the flat+ // FormatWriter above. Ports the former JS TRIP_CONVERTERS; parity pinned by golden tests.++ /** color is a #RRGGBB hex supplied by JS (getTripColor), not computed here. */+ data class TripExport(val index: Int, val color: String, val rows: List<Map<String, Any?>>)++ /** Match JS number formatting: whole-valued doubles drop the trailing ".0". */+ private fun jsNum(v: Any): String = when (v) {+ is Double -> if (v.isFinite() && v == Math.floor(v) && kotlin.math.abs(v) < 1e15) v.toLong().toString() else v.toString()+ is Float -> jsNum(v.toDouble())+ else -> v.toString()+ }++ /** Numeric field with a `0` default for null (mirrors JS `?? 0` / `|| 0`). */+ private fun numOrZero(v: Any?): String = if (v == null) "0" else jsNum(v)++ /** GeoJSON property value: `null` stays `null` (JSON), otherwise JS-formatted number. */+ private fun jsonNum(v: Any?): String = if (v == null) "null" else jsNum(v)++ private fun asDouble(v: Any?): Double = when (v) {+ is Double -> v+ is Float -> v.toDouble()+ is Long -> v.toDouble()+ is Int -> v.toDouble()+ else -> 0.0+ }++ /** Hex RGB (#RRGGBB) -> KML ABGR (ffBBGGRR). */+ private fun hexToKmlColor(hex: String): String {+ val h = hex.removePrefix("#")+ if (h.length < 6) return "ff0000ff"+ return "ff${h.substring(4, 6)}${h.substring(2, 4)}${h.substring(0, 2)}"+ }++ private fun rowTs(row: Map<String, Any?>): Long =+ (row["timestamp"] as? Long) ?: (System.currentTimeMillis() / 1000)++ fun convertTrips(format: String, trips: List<TripExport>): String = when (format) {+ "csv" -> tripsToCsv(trips)+ "geojson" -> tripsToGeoJson(trips)+ "gpx" -> tripsToGpx(trips)+ "kml" -> tripsToKml(trips)+ else -> throw IllegalArgumentException("Unknown export format: $format")+ }++ private fun tripsToCsv(trips: List<TripExport>): String {+ val sb = StringBuilder("trip,id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery,battery_status\n")+ val rows = ArrayList<String>()+ for (trip in trips) {+ trip.rows.forEachIndexed { i, row ->+ val ts = rowTs(row)+ rows.add(+ listOf(+ trip.index.toString(), i.toString(), ts.toString(), isoTime(ts),+ numOrZero(row["latitude"]), numOrZero(row["longitude"]),+ numOrZero(row["accuracy"]), numOrZero(row["altitude"]),+ numOrZero(row["speed"]), numOrZero(row["bearing"]), numOrZero(row["battery"]),+ batteryStatusLabel(row["battery_status"]) ?: ""+ ).joinToString(",")+ )+ }+ }+ sb.append(rows.joinToString("\n"))+ return sb.toString()+ }++ private fun tripsToGeoJson(trips: List<TripExport>): String {+ val features = ArrayList<String>()+ for (trip in trips) {+ trip.rows.forEachIndexed { i, row ->+ val ts = rowTs(row)+ features.add(+ " {\n" ++ " \"type\": \"Feature\",\n" ++ " \"geometry\": {\n" ++ " \"type\": \"Point\",\n" ++ " \"coordinates\": [\n" ++ " ${numOrZero(row["longitude"])},\n" ++ " ${numOrZero(row["latitude"])}\n" ++ " ]\n" ++ " },\n" ++ " \"properties\": {\n" ++ " \"trip\": ${trip.index},\n" ++ " \"id\": $i,\n" ++ " \"accuracy\": ${jsonNum(row["accuracy"])},\n" ++ " \"altitude\": ${jsonNum(row["altitude"])},\n" ++ " \"speed\": ${jsonNum(row["speed"])},\n" ++ " \"bearing\": ${jsonNum(row["bearing"])},\n" ++ " \"battery\": ${jsonNum(row["battery"])},\n" ++ " \"battery_status\": ${jsonValue(batteryStatusLabel(row["battery_status"]))},\n" ++ " \"time\": \"${isoTime(ts)}\"\n" ++ " }\n" ++ " }"+ )+ }+ }+ val featuresBlock = if (features.isEmpty()) "[]" else "[\n${features.joinToString(",\n")}\n ]"+ return "{\n \"type\": \"FeatureCollection\",\n \"features\": $featuresBlock\n}"+ }++ private fun tripsToGpx(trips: List<TripExport>): String {+ val sb = StringBuilder()+ sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")+ sb.append("<gpx version=\"1.1\" creator=\"Colota\" xmlns=\"http://www.topografix.com/GPX/1/1\">\n")+ sb.append(" <metadata>\n")+ sb.append(" <name>Colota Trip Export</name>\n")+ sb.append(" <time>${isoTime(System.currentTimeMillis() / 1000)}</time>\n")+ sb.append(" </metadata>")+ for (trip in trips) {+ sb.append("\n <trk>\n <name>Trip ${trip.index}</name>\n <trkseg>")+ for (row in trip.rows) {+ val ts = rowTs(row)+ val lat = String.format(Locale.US, "%.6f", asDouble(row["latitude"]))+ val lon = String.format(Locale.US, "%.6f", asDouble(row["longitude"]))+ sb.append("\n <trkpt lat=\"$lat\" lon=\"$lon\">")+ sb.append("\n <ele>${numOrZero(row["altitude"])}</ele>")+ sb.append("\n <time>${isoTime(ts)}</time>")+ sb.append("\n <extensions>")+ sb.append("\n <accuracy>${numOrZero(row["accuracy"])}</accuracy>")+ sb.append("\n <speed>${numOrZero(row["speed"])}</speed>")+ sb.append("\n <bearing>${numOrZero(row["bearing"])}</bearing>")+ sb.append("\n <battery>${numOrZero(row["battery"])}</battery>")+ sb.append("\n <battery_status>${batteryStatusLabel(row["battery_status"]) ?: ""}</battery_status>")+ sb.append("\n </extensions>")+ sb.append("\n </trkpt>")+ }+ sb.append("\n </trkseg>\n </trk>")+ }+ sb.append("\n</gpx>")+ return sb.toString()+ }++ private fun tripsToKml(trips: List<TripExport>): String {+ val sb = StringBuilder()+ sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")+ sb.append("<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n")+ sb.append(" <Document>\n")+ sb.append(" <name>Colota Trip Export</name>\n")+ sb.append(" <description>Exported trips from Colota</description>")+ for (trip in trips) {+ val styleId = "tripStyle${trip.index}"+ val coords = trip.rows.joinToString("\n ") {+ "${numOrZero(it["longitude"])},${numOrZero(it["latitude"])},${numOrZero(it["altitude"])}"+ }+ sb.append("\n <Style id=\"$styleId\">")+ sb.append("\n <LineStyle>")+ sb.append("\n <color>${hexToKmlColor(trip.color)}</color>")+ sb.append("\n <width>4</width>")+ sb.append("\n </LineStyle>")+ sb.append("\n </Style>")+ sb.append("\n <Folder>")+ sb.append("\n <name>Trip ${trip.index}</name>")+ sb.append("\n <Placemark>")+ sb.append("\n <name>Trip ${trip.index} Path</name>")+ sb.append("\n <styleUrl>#$styleId</styleUrl>")+ sb.append("\n <LineString>")+ sb.append("\n <tessellate>1</tessellate>")+ sb.append("\n <coordinates>")+ sb.append("\n $coords")+ sb.append("\n </coordinates>")+ sb.append("\n </LineString>")+ sb.append("\n </Placemark>")+ for (row in trip.rows) {+ val ts = rowTs(row)+ sb.append("\n <Placemark>")+ sb.append("\n <TimeStamp><when>${isoTime(ts)}</when></TimeStamp>")+ sb.append("\n <description>Trip ${trip.index} - Accuracy: ${numOrZero(row["accuracy"])}m, Speed: ${numOrZero(row["speed"])}m/s</description>")+ sb.append("\n <ExtendedData>")+ sb.append("\n <Data name=\"accuracy\"><value>${numOrZero(row["accuracy"])}</value></Data>")+ sb.append("\n <Data name=\"altitude\"><value>${numOrZero(row["altitude"])}</value></Data>")+ sb.append("\n <Data name=\"speed\"><value>${numOrZero(row["speed"])}</value></Data>")+ sb.append("\n <Data name=\"bearing\"><value>${numOrZero(row["bearing"])}</value></Data>")+ sb.append("\n <Data name=\"battery\"><value>${numOrZero(row["battery"])}</value></Data>")+ sb.append("\n <Data name=\"battery_status\"><value>${batteryStatusLabel(row["battery_status"]) ?: ""}</value></Data>")+ sb.append("\n </ExtendedData>")+ sb.append("\n <Point>")+ sb.append("\n <coordinates>${numOrZero(row["longitude"])},${numOrZero(row["latitude"])},${numOrZero(row["altitude"])}</coordinates>")+ sb.append("\n </Point>")+ sb.append("\n </Placemark>")+ }+ sb.append("\n </Folder>")+ }+ sb.append("\n </Document>\n</kml>")+ return sb.toString()+ }}diff --git a/apps/mobile/android/app/src/test/java/com/Colota/export/ExportConvertersTest.kt b/apps/mobile/android/app/src/test/java/com/Colota/export/ExportConvertersTest.ktindex b4a54d1c..cfcf06ac 100644--- a/apps/mobile/android/app/src/test/java/com/Colota/export/ExportConvertersTest.kt+++ b/apps/mobile/android/app/src/test/java/com/Colota/export/ExportConvertersTest.kt@@ -11,9 +11,11 @@ class ExportConvertersTest {@get:Ruleval tempFolder = TemporaryFolder()+ // Doubles for REAL columns / Long for INTEGER columns, mirroring real DB cursor types+ // so the tests exercise the JS-style number formatting (whole doubles drop ".0").private val sampleRows: List<Map<String, Any?>> = listOf(- mapOf("latitude" to 52.52, "longitude" to 13.405, "accuracy" to 10, "altitude" to 34, "speed" to 1.2, "battery" to 85, "timestamp" to 1700000000L),- mapOf("latitude" to 48.8566, "longitude" to 2.3522, "accuracy" to 15, "altitude" to 40, "speed" to 0.5, "battery" to 72, "timestamp" to 1700003600L)+ mapOf("latitude" to 52.52, "longitude" to 13.405, "accuracy" to 10.0, "altitude" to 34.0, "speed" to 1.2, "bearing" to 180.0, "battery" to 85L, "battery_status" to 2L, "timestamp" to 1700000000L),+ mapOf("latitude" to 48.8566, "longitude" to 2.3522, "accuracy" to 15.0, "altitude" to 40.0, "speed" to 0.5, "bearing" to 90.0, "battery" to 72L, "battery_status" to 1L, "timestamp" to 1700003600L))// --- extensionFor ---@@ -66,7 +68,7 @@ class ExportConvertersTest {fun `convert CSV contains header row`() {val csv = ExportConverters.convert("csv", sampleRows)val lines = csv.lines()- assertEquals("id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,battery", lines[0])+ assertEquals("id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery,battery_status", lines[0])}@Test@@ -189,6 +191,28 @@ class ExportConvertersTest {assertTrue(json.contains("line1\\nline2\\ttab"))}+ // --- Number formatting (jsNum parity) ---++ @Test+ fun `whole doubles strip trailing dot-zero and fractional values round-trip`() {+ // Whole doubles must strip ".0" exactly (deterministic). Fractional values only need to+ // round-trip; byte-identity with JS for arbitrary doubles is best-effort (Double.toString,+ // not separately verified on ART).+ val csv = ExportConverters.convert("csv", listOf(mapOf<String, Any?>(+ "latitude" to 48.137154123, "longitude" to 11.5761249, "timestamp" to 1700000000L,+ "accuracy" to 5.0, "altitude" to 100.0, "speed" to 12.0, "bearing" to 359.9,+ "battery" to 80L, "battery_status" to 2L+ )))+ val cols = csv.lines()[1].split(",")+ // id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery,battery_status+ assertEquals("5", cols[5]) // accuracy 5.0 -> no ".0"+ assertEquals("100", cols[6]) // altitude 100.0 -> no ".0"+ assertEquals("12", cols[7]) // speed 12.0 -> no ".0"+ assertEquals(48.137154123, cols[3].toDouble(), 0.0) // messy lat round-trips+ assertEquals(11.5761249, cols[4].toDouble(), 0.0) // messy lon round-trips+ assertEquals(359.9, cols[8].toDouble(), 0.0) // fractional bearing round-trips+ }+// --- Null handling ---@Test@@ -226,7 +250,7 @@ class ExportConvertersTest {fun `streaming CSV produces header and data rows`() {val result = streamToString("csv", sampleRows)val lines = result.lines().filter { it.isNotBlank() }- assertEquals("id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,battery", lines[0])+ assertEquals("id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery,battery_status", lines[0])assertEquals(3, lines.size)assertTrue(lines[1].startsWith("0,1700000000,"))assertTrue(lines[1].contains("52.52"))@@ -313,4 +337,89 @@ class ExportConvertersTest {fun `writeHeader throws for unknown format`() {ExportConverters.writeHeader(StringWriter(), "xml")}++ @Test+ fun `convert includes bearing and battery_status across formats`() {+ val csv = ExportConverters.convert("csv", sampleRows)+ assertTrue(csv.lines()[1].endsWith(",Charging")) // battery_status label, last column+ val gj = ExportConverters.convert("geojson", sampleRows)+ assertTrue(gj.contains("\"bearing\": 180")) // whole double -> no trailing ".0"+ assertTrue(gj.contains("\"battery_status\": \"Charging\""))+ val gpx = ExportConverters.convert("gpx", sampleRows)+ assertTrue(gpx.contains("<bearing>180</bearing>"))+ assertTrue(gpx.contains("<battery_status>Charging</battery_status>"))+ val kml = ExportConverters.convert("kml", sampleRows)+ assertTrue(kml.contains("<Data name=\"bearing\"><value>180</value></Data>"))+ assertTrue(kml.contains("<Data name=\"battery_status\"><value>Charging</value></Data>"))+ }++ // Golden files in src/test/resources/golden/export/ pin the trip output. Structure/formatting+ // was captured from the JS serializer before the port; battery_status and KML <ExtendedData>+ // were added by hand afterwards (PR F) - the JS never emitted those. So: JS-derived-then-+ // extended, not raw JS output. convertTrips must reproduce them.++ /** Mirrors the original JS golden-capture fixture, plus battery_status. */+ private val tripFixture = listOf(+ ExportConverters.TripExport(1, "#3B82F6", listOf(+ mapOf("latitude" to 48.137154, "longitude" to 11.576124, "timestamp" to 1700000000L, "accuracy" to 8.5, "altitude" to 520.2, "speed" to 1.4, "bearing" to 270.5, "battery" to 91L, "battery_status" to 2L),+ mapOf("latitude" to 48.138001, "longitude" to 11.577003, "timestamp" to 1700000060L, "accuracy" to 12.0, "altitude" to 525.0, "speed" to 2.0, "bearing" to 275.0, "battery" to 90L, "battery_status" to 3L)+ )),+ ExportConverters.TripExport(2, "#10B981", listOf(+ mapOf("latitude" to 48.14, "longitude" to 11.58, "timestamp" to 1700001000L, "accuracy" to 5.0, "altitude" to 530.0, "speed" to 3.0, "bearing" to 10.0, "battery" to 88L, "battery_status" to 1L),+ mapOf("latitude" to 48.1405, "longitude" to 11.5811, "timestamp" to 1700001060L, "accuracy" to 6.2, "altitude" to 0.0, "speed" to 0.0, "bearing" to 0.0, "battery" to 87L, "battery_status" to 0L)+ ))+ )++ private fun golden(name: String): String =+ javaClass.getResource("/golden/export/$name")!!.readText()++ /** Normalize CRLF and the non-deterministic GPX <metadata> export time. */+ private fun norm(s: String): String =+ s.replace("\r\n", "\n").replace(Regex("(?s)(<metadata>.*?<time>).*?(</time>)"), "$1NORM$2")++ @Test+ fun `convertTrips csv matches JS golden`() {+ assertEquals(norm(golden("trip.csv")), norm(ExportConverters.convertTrips("csv", tripFixture)))+ }++ @Test+ fun `convertTrips geojson matches JS golden`() {+ assertEquals(norm(golden("trip.geojson")), norm(ExportConverters.convertTrips("geojson", tripFixture)))+ }++ @Test+ fun `convertTrips gpx matches JS golden`() {+ assertEquals(norm(golden("trip.gpx")), norm(ExportConverters.convertTrips("gpx", tripFixture)))+ }++ @Test+ fun `convertTrips kml matches JS golden`() {+ assertEquals(norm(golden("trip.kml")), norm(ExportConverters.convertTrips("kml", tripFixture)))+ }++ // --- Trip-export edge cases (no trips / empty trip) ---++ @Test+ fun `convertTrips with no trips produces valid empty output`() {+ assertEquals(+ "trip,id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery,battery_status",+ ExportConverters.convertTrips("csv", emptyList()).trim()+ )+ assertTrue(ExportConverters.convertTrips("geojson", emptyList()).contains("\"features\": []"))+ val gpx = ExportConverters.convertTrips("gpx", emptyList())+ assertTrue(gpx.startsWith("<?xml") && gpx.trimEnd().endsWith("</gpx>"))+ assertTrue(ExportConverters.convertTrips("kml", emptyList()).trimEnd().endsWith("</kml>"))+ }++ @Test+ fun `convertTrips with an empty trip emits no points and stays well-formed`() {+ val trips = listOf(ExportConverters.TripExport(1, "#3B82F6", emptyList()))+ assertEquals(1, ExportConverters.convertTrips("csv", trips).lines().filter { it.isNotBlank() }.size)+ assertTrue(ExportConverters.convertTrips("geojson", trips).contains("\"features\": []"))+ // GPX/KML still open the trip's track/folder with no points inside; just verify it stays well-formed+ val gpx = ExportConverters.convertTrips("gpx", trips)+ assertTrue(gpx.contains("<name>Trip 1</name>") && gpx.trimEnd().endsWith("</gpx>"))+ val kml = ExportConverters.convertTrips("kml", trips)+ assertTrue(kml.contains("<name>Trip 1</name>") && kml.trimEnd().endsWith("</kml>"))+ }}diff --git a/apps/mobile/android/app/src/test/resources/golden/export/trip.csv b/apps/mobile/android/app/src/test/resources/golden/export/trip.csvnew file mode 100644index 00000000..d10ceb58--- /dev/null+++ b/apps/mobile/android/app/src/test/resources/golden/export/trip.csv@@ -0,0 +1,5 @@+trip,id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery,battery_status+1,0,1700000000,2023-11-14T22:13:20.000Z,48.137154,11.576124,8.5,520.2,1.4,270.5,91,Charging+1,1,1700000060,2023-11-14T22:14:20.000Z,48.138001,11.577003,12,525,2,275,90,Full+2,0,1700001000,2023-11-14T22:30:00.000Z,48.14,11.58,5,530,3,10,88,Unplugged/Discharging+2,1,1700001060,2023-11-14T22:31:00.000Z,48.1405,11.5811,6.2,0,0,0,87,Unknown\ No newline at end of filediff --git a/apps/mobile/android/app/src/test/resources/golden/export/trip.geojson b/apps/mobile/android/app/src/test/resources/golden/export/trip.geojsonnew file mode 100644index 00000000..89803ce5--- /dev/null+++ b/apps/mobile/android/app/src/test/resources/golden/export/trip.geojson@@ -0,0 +1,89 @@+{+ "type": "FeatureCollection",+ "features": [+ {+ "type": "Feature",+ "geometry": {+ "type": "Point",+ "coordinates": [+ 11.576124,+ 48.137154+ ]+ },+ "properties": {+ "trip": 1,+ "id": 0,+ "accuracy": 8.5,+ "altitude": 520.2,+ "speed": 1.4,+ "bearing": 270.5,+ "battery": 91,+ "battery_status": "Charging",+ "time": "2023-11-14T22:13:20.000Z"+ }+ },+ {+ "type": "Feature",+ "geometry": {+ "type": "Point",+ "coordinates": [+ 11.577003,+ 48.138001+ ]+ },+ "properties": {+ "trip": 1,+ "id": 1,+ "accuracy": 12,+ "altitude": 525,+ "speed": 2,+ "bearing": 275,+ "battery": 90,+ "battery_status": "Full",+ "time": "2023-11-14T22:14:20.000Z"+ }+ },+ {+ "type": "Feature",+ "geometry": {+ "type": "Point",+ "coordinates": [+ 11.58,+ 48.14+ ]+ },+ "properties": {+ "trip": 2,+ "id": 0,+ "accuracy": 5,+ "altitude": 530,+ "speed": 3,+ "bearing": 10,+ "battery": 88,+ "battery_status": "Unplugged/Discharging",+ "time": "2023-11-14T22:30:00.000Z"+ }+ },+ {+ "type": "Feature",+ "geometry": {+ "type": "Point",+ "coordinates": [+ 11.5811,+ 48.1405+ ]+ },+ "properties": {+ "trip": 2,+ "id": 1,+ "accuracy": 6.2,+ "altitude": 0,+ "speed": 0,+ "bearing": 0,+ "battery": 87,+ "battery_status": "Unknown",+ "time": "2023-11-14T22:31:00.000Z"+ }+ }+ ]+}\ No newline at end of filediff --git a/apps/mobile/android/app/src/test/resources/golden/export/trip.gpx b/apps/mobile/android/app/src/test/resources/golden/export/trip.gpxnew file mode 100644index 00000000..22bd722d--- /dev/null+++ b/apps/mobile/android/app/src/test/resources/golden/export/trip.gpx@@ -0,0 +1,61 @@+<?xml version="1.0" encoding="UTF-8"?>+<gpx version="1.1" creator="Colota" xmlns="http://www.topografix.com/GPX/1/1">+ <metadata>+ <name>Colota Trip Export</name>+ <time>2026-06-02T05:32:06.221Z</time>+ </metadata>+ <trk>+ <name>Trip 1</name>+ <trkseg>+ <trkpt lat="48.137154" lon="11.576124">+ <ele>520.2</ele>+ <time>2023-11-14T22:13:20.000Z</time>+ <extensions>+ <accuracy>8.5</accuracy>+ <speed>1.4</speed>+ <bearing>270.5</bearing>+ <battery>91</battery>+ <battery_status>Charging</battery_status>+ </extensions>+ </trkpt>+ <trkpt lat="48.138001" lon="11.577003">+ <ele>525</ele>+ <time>2023-11-14T22:14:20.000Z</time>+ <extensions>+ <accuracy>12</accuracy>+ <speed>2</speed>+ <bearing>275</bearing>+ <battery>90</battery>+ <battery_status>Full</battery_status>+ </extensions>+ </trkpt>+ </trkseg>+ </trk>+ <trk>+ <name>Trip 2</name>+ <trkseg>+ <trkpt lat="48.140000" lon="11.580000">+ <ele>530</ele>+ <time>2023-11-14T22:30:00.000Z</time>+ <extensions>+ <accuracy>5</accuracy>+ <speed>3</speed>+ <bearing>10</bearing>+ <battery>88</battery>+ <battery_status>Unplugged/Discharging</battery_status>+ </extensions>+ </trkpt>+ <trkpt lat="48.140500" lon="11.581100">+ <ele>0</ele>+ <time>2023-11-14T22:31:00.000Z</time>+ <extensions>+ <accuracy>6.2</accuracy>+ <speed>0</speed>+ <bearing>0</bearing>+ <battery>87</battery>+ <battery_status>Unknown</battery_status>+ </extensions>+ </trkpt>+ </trkseg>+ </trk>+</gpx>\ No newline at end of filediff --git a/apps/mobile/android/app/src/test/resources/golden/export/trip.kml b/apps/mobile/android/app/src/test/resources/golden/export/trip.kmlnew file mode 100644index 00000000..fa47d824--- /dev/null+++ b/apps/mobile/android/app/src/test/resources/golden/export/trip.kml@@ -0,0 +1,107 @@+<?xml version="1.0" encoding="UTF-8"?>+<kml xmlns="http://www.opengis.net/kml/2.2">+ <Document>+ <name>Colota Trip Export</name>+ <description>Exported trips from Colota</description>+ <Style id="tripStyle1">+ <LineStyle>+ <color>ffF6823B</color>+ <width>4</width>+ </LineStyle>+ </Style>+ <Folder>+ <name>Trip 1</name>+ <Placemark>+ <name>Trip 1 Path</name>+ <styleUrl>#tripStyle1</styleUrl>+ <LineString>+ <tessellate>1</tessellate>+ <coordinates>+ 11.576124,48.137154,520.2+ 11.577003,48.138001,525+ </coordinates>+ </LineString>+ </Placemark>+ <Placemark>+ <TimeStamp><when>2023-11-14T22:13:20.000Z</when></TimeStamp>+ <description>Trip 1 - Accuracy: 8.5m, Speed: 1.4m/s</description>+ <ExtendedData>+ <Data name="accuracy"><value>8.5</value></Data>+ <Data name="altitude"><value>520.2</value></Data>+ <Data name="speed"><value>1.4</value></Data>+ <Data name="bearing"><value>270.5</value></Data>+ <Data name="battery"><value>91</value></Data>+ <Data name="battery_status"><value>Charging</value></Data>+ </ExtendedData>+ <Point>+ <coordinates>11.576124,48.137154,520.2</coordinates>+ </Point>+ </Placemark>+ <Placemark>+ <TimeStamp><when>2023-11-14T22:14:20.000Z</when></TimeStamp>+ <description>Trip 1 - Accuracy: 12m, Speed: 2m/s</description>+ <ExtendedData>+ <Data name="accuracy"><value>12</value></Data>+ <Data name="altitude"><value>525</value></Data>+ <Data name="speed"><value>2</value></Data>+ <Data name="bearing"><value>275</value></Data>+ <Data name="battery"><value>90</value></Data>+ <Data name="battery_status"><value>Full</value></Data>+ </ExtendedData>+ <Point>+ <coordinates>11.577003,48.138001,525</coordinates>+ </Point>+ </Placemark>+ </Folder>+ <Style id="tripStyle2">+ <LineStyle>+ <color>ff81B910</color>+ <width>4</width>+ </LineStyle>+ </Style>+ <Folder>+ <name>Trip 2</name>+ <Placemark>+ <name>Trip 2 Path</name>+ <styleUrl>#tripStyle2</styleUrl>+ <LineString>+ <tessellate>1</tessellate>+ <coordinates>+ 11.58,48.14,530+ 11.5811,48.1405,0+ </coordinates>+ </LineString>+ </Placemark>+ <Placemark>+ <TimeStamp><when>2023-11-14T22:30:00.000Z</when></TimeStamp>+ <description>Trip 2 - Accuracy: 5m, Speed: 3m/s</description>+ <ExtendedData>+ <Data name="accuracy"><value>5</value></Data>+ <Data name="altitude"><value>530</value></Data>+ <Data name="speed"><value>3</value></Data>+ <Data name="bearing"><value>10</value></Data>+ <Data name="battery"><value>88</value></Data>+ <Data name="battery_status"><value>Unplugged/Discharging</value></Data>+ </ExtendedData>+ <Point>+ <coordinates>11.58,48.14,530</coordinates>+ </Point>+ </Placemark>+ <Placemark>+ <TimeStamp><when>2023-11-14T22:31:00.000Z</when></TimeStamp>+ <description>Trip 2 - Accuracy: 6.2m, Speed: 0m/s</description>+ <ExtendedData>+ <Data name="accuracy"><value>6.2</value></Data>+ <Data name="altitude"><value>0</value></Data>+ <Data name="speed"><value>0</value></Data>+ <Data name="bearing"><value>0</value></Data>+ <Data name="battery"><value>87</value></Data>+ <Data name="battery_status"><value>Unknown</value></Data>+ </ExtendedData>+ <Point>+ <coordinates>11.5811,48.1405,0</coordinates>+ </Point>+ </Placemark>+ </Folder>+ </Document>+</kml>\ No newline at end of filediff --git a/apps/mobile/src/screens/LocationInspectorScreen.tsx b/apps/mobile/src/screens/LocationInspectorScreen.tsxindex 6f24e1f2..54d6161e 100644--- a/apps/mobile/src/screens/LocationInspectorScreen.tsx+++ b/apps/mobile/src/screens/LocationInspectorScreen.tsx@@ -20,8 +20,8 @@ import { TripList } from "../components/features/inspector/TripList"import { LocationTable } from "../components/features/inspector/LocationTable"import { formatDistance } from "../utils/geo"import { pad2 } from "../utils/format"-import { segmentTrips } from "../utils/trips"-import { TRIP_CONVERTERS, EXPORT_FORMATS, type ExportFormat } from "../utils/exportConverters"+import { segmentTrips, getTripColor } from "../utils/trips"+import { EXPORT_FORMATS, type ExportFormat } from "../utils/exportConverters"import { showAlert, showConfirm } from "../services/modalService"import type { RootScreenProps } from "../types/navigation"@@ -172,14 +172,22 @@ export function LocationHistoryScreen({ navigation, route }: RootScreenProps<"Loasync (format: ExportFormat, tripsToExport: Trip[]) => {if (tripsToExport.length === 0) returntry {- const content = TRIP_CONVERTERS[format](tripsToExport)const dateStr = mapDate.toISOString().slice(0, 10)const isSingle = tripsToExport.length === 1const label = isSingle ? `Trip ${tripsToExport[0].index}` : "Trips"const fileName = `colota_${isSingle ? `trip${tripsToExport[0].index}` : "trips"}_${dateStr}${EXPORT_FORMATS[format].extension}`- const filePath = await NativeLocationService.writeFile(fileName, content)+ const filePath = await NativeLocationService.exportTripsToFile(+ tripsToExport.map((t) => ({+ index: t.index,+ color: getTripColor(t.index),+ startTs: t.startTime,+ endTs: t.endTime+ })),+ format,+ fileName+ )await NativeLocationService.shareFile(filePath, EXPORT_FORMATS[format].mimeType, `Colota ${label} - ${dateStr}`)} catch (error) {logger.error("[LocationHistory] Trip export failed:", error)diff --git a/apps/mobile/src/screens/TripDetailScreen.tsx b/apps/mobile/src/screens/TripDetailScreen.tsxindex 07dfeec8..5a89ac3d 100644--- a/apps/mobile/src/screens/TripDetailScreen.tsx+++ b/apps/mobile/src/screens/TripDetailScreen.tsx@@ -26,7 +26,7 @@ import { TrackMap } from "../components/features/inspector/TrackMap"import { InteractiveLineChart } from "../components/features/inspector/InteractiveLineChart"import { getTripColor, computeTripStats } from "../utils/trips"import { formatDate, formatDistance, formatDuration, formatSpeed, formatTime } from "../utils/geo"-import { TRIP_CONVERTERS, EXPORT_FORMATS, EXPORT_FORMAT_KEYS, type ExportFormat } from "../utils/exportConverters"+import { EXPORT_FORMATS, EXPORT_FORMAT_KEYS, type ExportFormat } from "../utils/exportConverters"import { HIT_SLOP_LG } from "../constants"import { showAlert, showConfirm } from "../services/modalService"import { logger } from "../utils/logger"@@ -86,10 +86,13 @@ export function TripDetailScreen({ route, navigation }: RootScreenProps<"Trip Deconst handleExport = useCallback(async (format: ExportFormat) => {try {- const content = TRIP_CONVERTERS[format]([trip])const dateStr = new Date(trip.startTime * 1000).toISOString().slice(0, 10)const fileName = `colota_trip${trip.index}_${dateStr}${EXPORT_FORMATS[format].extension}`- const filePath = await NativeLocationService.writeFile(fileName, content)+ const filePath = await NativeLocationService.exportTripsToFile(+ [{ index: trip.index, color: getTripColor(trip.index), startTs: trip.startTime, endTs: trip.endTime }],+ format,+ fileName+ )await NativeLocationService.shareFile(filePath,EXPORT_FORMATS[format].mimeType,diff --git a/apps/mobile/src/screens/__tests__/LocationHistoryScreen.test.tsx b/apps/mobile/src/screens/__tests__/LocationHistoryScreen.test.tsxindex 9c618db1..a3e396d2 100644--- a/apps/mobile/src/screens/__tests__/LocationHistoryScreen.test.tsx+++ b/apps/mobile/src/screens/__tests__/LocationHistoryScreen.test.tsx@@ -9,14 +9,15 @@ jest.mock("../../services/NativeLocationService", () => ({getDaysWithData: jest.fn().mockResolvedValue([]),getDailyStats: jest.fn().mockResolvedValue([]),getLocationsByDateRange: jest.fn().mockResolvedValue([]),- writeFile: jest.fn(),+ exportTripsToFile: jest.fn().mockResolvedValue("/tmp/export"),shareFile: jest.fn(),deleteLocationsInRange: jest.fn().mockResolvedValue(0)}}))jest.mock("../../utils/trips", () => ({- segmentTrips: jest.fn().mockReturnValue([])+ segmentTrips: jest.fn().mockReturnValue([]),+ getTripColor: jest.fn().mockReturnValue("#3B82F6")}))jest.mock("../../utils/geo", () => ({@@ -24,7 +25,6 @@ jest.mock("../../utils/geo", () => ({}))jest.mock("../../utils/exportConverters", () => ({- TRIP_CONVERTERS: {},EXPORT_FORMATS: {}}))diff --git a/apps/mobile/src/services/NativeLocationService.ts b/apps/mobile/src/services/NativeLocationService.tsindex 50e926f4..d43a35ec 100644--- a/apps/mobile/src/services/NativeLocationService.ts+++ b/apps/mobile/src/services/NativeLocationService.ts@@ -846,6 +846,19 @@ class NativeLocationService {return LocationServiceModule.exportToFile(format)}+ /**+ * Exports the given trips as a trip-segmented file (CSV/GeoJSON/GPX/KML).+ * Rows are queried natively per trip range. Returns the written file path.+ */+ static async exportTripsToFile(+ trips: { index: number; color: string; startTs: number; endTs: number }[],+ format: string,+ fileName: string+ ): Promise<string> {+ this.ensureModule()+ return LocationServiceModule.exportTripsToFile(trips, format, fileName)+ }+// ============================================================================// SECURE STORAGE (Auth & Headers)// ============================================================================diff --git a/apps/mobile/src/utils/__tests__/exportConverters.test.ts b/apps/mobile/src/utils/__tests__/exportConverters.test.tsindex 95541407..a8e32703 100644--- a/apps/mobile/src/utils/__tests__/exportConverters.test.ts+++ b/apps/mobile/src/utils/__tests__/exportConverters.test.ts@@ -1,34 +1,10 @@import { formatBytes } from "../format"-import {- convertTripsToCSV,- convertTripsToGeoJSON,- convertTripsToGPX,- convertTripsToKML,- TRIP_CONVERTERS-} from "../exportConverters"+import { EXPORT_FORMAT_KEYS, EXPORT_FORMATS } from "../exportConverters"import { FILE_FORMATS } from "../fileFormats"-const sampleTrips = [- {- index: 1,- locations: [- { latitude: 48.137154, longitude: 11.576124, accuracy: 10, altitude: 520, speed: 1.5, timestamp: 1700000000 },- { latitude: 48.138, longitude: 11.577, accuracy: 8, altitude: 525, speed: 2.0, timestamp: 1700000005 }- ],- startTime: 1700000000,- endTime: 1700000005,- distance: 120,- locationCount: 2- },- {- index: 2,- locations: [{ latitude: 48.14, longitude: 11.58, accuracy: 12, altitude: 530, speed: 3.0, timestamp: 1700001000 }],- startTime: 1700001000,- endTime: 1700001000,- distance: 0,- locationCount: 1- }-]+// Trip serialization moved to native ExportConverters.kt; parity is covered by+// the golden-fixture tests in ExportConvertersTest.kt. This file now only covers+// the byte formatter and the export-format metadata registry.describe("formatBytes", () => {it("formats bytes", () => {@@ -48,154 +24,16 @@ describe("formatBytes", () => {})})-describe("convertTripsToCSV", () => {- it("includes trip column in header", () => {- const csv = convertTripsToCSV([])- expect(csv).toContain("trip,id,timestamp")- })-- it("includes trip index per row", () => {- const csv = convertTripsToCSV(sampleTrips)- const lines = csv.split("\n")- expect(lines[1]).toMatch(/^1,/) // trip 1- expect(lines[3]).toMatch(/^2,/) // trip 2- })-- it("flattens all trip locations into rows", () => {- const csv = convertTripsToCSV(sampleTrips)- const lines = csv.split("\n")- expect(lines).toHaveLength(4) // header + 3 locations- })-- it("uses Unix seconds for timestamps", () => {- const csv = convertTripsToCSV(sampleTrips)- expect(csv).toContain("1700000000")- })-})--describe("convertTripsToGeoJSON", () => {- it("returns valid FeatureCollection", () => {- const result = JSON.parse(convertTripsToGeoJSON(sampleTrips))- expect(result.type).toBe("FeatureCollection")- expect(result.features).toHaveLength(3)- })-- it("includes trip index in properties", () => {- const result = JSON.parse(convertTripsToGeoJSON(sampleTrips))- expect(result.features[0].properties.trip).toBe(1)- expect(result.features[2].properties.trip).toBe(2)- })-- it("uses [lon, lat] coordinate order", () => {- const result = JSON.parse(convertTripsToGeoJSON(sampleTrips))- const coords = result.features[0].geometry.coordinates- expect(coords[0]).toBe(11.576124)- expect(coords[1]).toBe(48.137154)- })-})--describe("convertTripsToGPX", () => {- it("creates separate trk elements per trip", () => {- const gpx = convertTripsToGPX(sampleTrips)- expect(gpx).toContain("<name>Trip 1</name>")- expect(gpx).toContain("<name>Trip 2</name>")- const trkCount = (gpx.match(/<trk>/g) || []).length- expect(trkCount).toBe(2)- })-- it("includes trackpoints with lat/lon", () => {- const gpx = convertTripsToGPX(sampleTrips)- expect(gpx).toContain('lat="48.137154"')- expect(gpx).toContain('lon="11.576124"')- })-- it("includes elevation and extensions", () => {- const gpx = convertTripsToGPX(sampleTrips)- expect(gpx).toContain("<ele>520</ele>")- expect(gpx).toContain("<accuracy>10</accuracy>")- })-})--describe("convertTripsToKML", () => {- it("creates separate folders per trip", () => {- const kml = convertTripsToKML(sampleTrips)- expect(kml).toContain("<name>Trip 1</name>")- expect(kml).toContain("<name>Trip 2</name>")- const folderCount = (kml.match(/<Folder>/g) || []).length- expect(folderCount).toBe(2)- })-- it("uses per-trip colors", () => {- const kml = convertTripsToKML(sampleTrips)- // Trip 1: #3B82F6 -> ABGR ffF6823B- expect(kml).toContain("ffF6823B")- // Trip 2: #10B981 -> ABGR ff81B910- expect(kml).toContain("ff81B910")- })-- it("includes LineString coordinates per trip", () => {- const kml = convertTripsToKML(sampleTrips)- expect(kml).toContain("11.576124,48.137154,520")- expect(kml).toContain("11.58,48.14,530")- })-- it("includes Placemarks with trip labels", () => {- const kml = convertTripsToKML(sampleTrips)- expect(kml).toContain("Trip 1")- expect(kml).toContain("Trip 2")- expect(kml).toContain("<TimeStamp>")- })-})--describe("FILE_FORMATS registry", () => {+describe("export format registry", () => {it("exportable formats are fully wired for export", () => {- const exportable = Object.entries(FILE_FORMATS).filter(([, f]) => f.exportable)- expect(exportable.map(([key]) => key).sort()).toEqual(Object.keys(TRIP_CONVERTERS).sort())- const incomplete = exportable.filter(([, f]) => !f.mimeType || !f.subtitle).map(([key]) => key)- expect(incomplete).toEqual([])- })-})--describe("exporters emit every location field", () => {- const trip = [- {- index: 1,- locations: [- {- latitude: 48.1,- longitude: 11.5,- accuracy: 7,- altitude: 333,- speed: 4,- bearing: 90,- battery: 55,- timestamp: 1700000000- }- ],- startTime: 1700000000,- endTime: 1700000000,- distance: 0,- locationCount: 1- }- ]-- it("GeoJSON properties carry every field", () => {- const props = JSON.parse(convertTripsToGeoJSON(trip)).features[0].properties- expect(props).toMatchObject({ accuracy: 7, altitude: 333, speed: 4, bearing: 90, battery: 55 })- })-- it("GPX extensions carry every field", () => {- const gpx = convertTripsToGPX(trip)- expect(gpx).toContain("<ele>333</ele>")- expect(gpx).toContain("<accuracy>7</accuracy>")- expect(gpx).toContain("<speed>4</speed>")- expect(gpx).toContain("<bearing>90</bearing>")- expect(gpx).toContain("<battery>55</battery>")- })-- it("CSV columns carry every field", () => {- const lines = convertTripsToCSV(trip).split("\n")- expect(lines[0]).toBe("trip,id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery")- expect(lines[1]).toContain("7,333,4,90,55")+ const exportable = Object.entries(FILE_FORMATS)+ .filter(([, f]) => f.exportable)+ .map(([key]) => key)+ .sort()+ expect(exportable).toEqual([...EXPORT_FORMAT_KEYS].sort())+ EXPORT_FORMAT_KEYS.forEach((key) => {+ expect(EXPORT_FORMATS[key].mimeType).toBeTruthy()+ expect(EXPORT_FORMATS[key].subtitle).toBeTruthy()+ })})})diff --git a/apps/mobile/src/utils/exportConverters.ts b/apps/mobile/src/utils/exportConverters.tsindex 37875263..e11ec952 100644--- a/apps/mobile/src/utils/exportConverters.ts+++ b/apps/mobile/src/utils/exportConverters.ts@@ -4,173 +4,11 @@*/import { type LucideIcon } from "lucide-react-native"-import { Trip } from "../types/global"-import { getTripColor } from "./trips"import { FILE_FORMATS, IMPORT_FORMAT_ORDER } from "./fileFormats"-/** Convert hex RGB (#RRGGBB) to KML's ABGR format (ffBBGGRR) */-function hexToKmlColor(hex: string): string {- const h = hex.replace("#", "")- return `ff${h.slice(4, 6)}${h.slice(2, 4)}${h.slice(0, 2)}`-}--// ============================================================================-// TRIP-AWARE CONVERTERS (timestamps in Unix seconds)-// ============================================================================--export const convertTripsToCSV = (trips: Trip[]): string => {- const headers = "trip,id,timestamp,iso_time,latitude,longitude,accuracy,altitude,speed,bearing,battery\n"- const rows = trips- .flatMap((trip) =>- trip.locations.map((item, i) => {- const ts = item.timestamp ?? Math.floor(Date.now() / 1000)- const isoTime = new Date(ts * 1000).toISOString()- return [- trip.index,- i,- ts,- isoTime,- item.latitude,- item.longitude,- item.accuracy ?? 0,- item.altitude ?? 0,- item.speed ?? 0,- item.bearing ?? 0,- item.battery ?? 0- ].join(",")- })- )- .join("\n")- return headers + rows-}--export const convertTripsToGeoJSON = (trips: Trip[]): string => {- const features = trips.flatMap((trip) =>- trip.locations.map((item, i) => {- const ts = item.timestamp ?? Math.floor(Date.now() / 1000)- return {- type: "Feature",- geometry: {- type: "Point",- coordinates: [item.longitude || 0, item.latitude || 0]- },- properties: {- trip: trip.index,- id: i,- accuracy: item.accuracy,- altitude: item.altitude,- speed: item.speed,- bearing: item.bearing,- battery: item.battery,- time: new Date(ts * 1000).toISOString()- }- }- })- )- return JSON.stringify({ type: "FeatureCollection", features }, null, 2)-}--export const convertTripsToGPX = (trips: Trip[]): string => {- const parts: string[] = [- `<?xml version="1.0" encoding="UTF-8"?>-<gpx version="1.1" creator="Colota" xmlns="http://www.topografix.com/GPX/1/1">- <metadata>- <name>Colota Trip Export</name>- <time>${new Date().toISOString()}</time>- </metadata>`- ]-- for (const trip of trips) {- parts.push(`- <trk>- <name>Trip ${trip.index}</name>- <trkseg>`)- for (const item of trip.locations) {- const ts = item.timestamp ?? Math.floor(Date.now() / 1000)- parts.push(`- <trkpt lat="${item.latitude.toFixed(6)}" lon="${item.longitude.toFixed(6)}">- <ele>${item.altitude || 0}</ele>- <time>${new Date(ts * 1000).toISOString()}</time>- <extensions>- <accuracy>${item.accuracy || 0}</accuracy>- <speed>${item.speed || 0}</speed>- <bearing>${item.bearing || 0}</bearing>- <battery>${item.battery || 0}</battery>- </extensions>- </trkpt>`)- }- parts.push(`- </trkseg>- </trk>`)- }-- parts.push(`-</gpx>`)- return parts.join("")-}--export const convertTripsToKML = (trips: Trip[]): string => {- const parts: string[] = [- `<?xml version="1.0" encoding="UTF-8"?>-<kml xmlns="http://www.opengis.net/kml/2.2">- <Document>- <name>Colota Trip Export</name>- <description>Exported trips from Colota</description>`- ]-- for (const trip of trips) {- const styleId = `tripStyle${trip.index}`- const coords = trip.locations- .map((item) => `${item.longitude},${item.latitude},${item.altitude || 0}`)- .join("\n ")- parts.push(`- <Style id="${styleId}">- <LineStyle>- <color>${hexToKmlColor(getTripColor(trip.index))}</color>- <width>4</width>- </LineStyle>- </Style>- <Folder>- <name>Trip ${trip.index}</name>- <Placemark>- <name>Trip ${trip.index} Path</name>- <styleUrl>#${styleId}</styleUrl>- <LineString>- <tessellate>1</tessellate>- <coordinates>- ${coords}- </coordinates>- </LineString>- </Placemark>`)-- for (const item of trip.locations) {- const ts = item.timestamp ?? Math.floor(Date.now() / 1000)- parts.push(`- <Placemark>- <TimeStamp><when>${new Date(ts * 1000).toISOString()}</when></TimeStamp>- <description>Trip ${trip.index} - Accuracy: ${item.accuracy ?? 0}m, Speed: ${item.speed ?? 0}m/s</description>- <Point>- <coordinates>${item.longitude},${item.latitude},${item.altitude || 0}</coordinates>- </Point>- </Placemark>`)- }-- parts.push(`- </Folder>`)- }-- parts.push(`- </Document>-</kml>`)- return parts.join("")-}--export const TRIP_CONVERTERS: Record<ExportFormat, (trips: Trip[]) => string> = {- csv: convertTripsToCSV,- geojson: convertTripsToGeoJSON,- gpx: convertTripsToGPX,- kml: convertTripsToKML-}+// Trip-aware serialization lives natively in ExportConverters.kt (convertTrips,+// reached via NativeLocationService.exportTripsToFile). This module now only+// holds the UI-facing export-format metadata.export type ExportFormat = "csv" | "geojson" | "gpx" | "kml"