Skip to content

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.md
index 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.kt
index 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))
+ }
+
@ReactMethod
fun 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.kt
index 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.export
import com.Colota.data.DatabaseHelper
+import com.Colota.util.BatteryStatus
import java.io.BufferedReader
import java.io.BufferedWriter
import 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).mimeType
else -> "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.kt
index 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:Rule
val 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.csv
new file mode 100644
index 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 file
diff --git a/apps/mobile/android/app/src/test/resources/golden/export/trip.geojson b/apps/mobile/android/app/src/test/resources/golden/export/trip.geojson
new file mode 100644
index 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 file
diff --git a/apps/mobile/android/app/src/test/resources/golden/export/trip.gpx b/apps/mobile/android/app/src/test/resources/golden/export/trip.gpx
new file mode 100644
index 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 file
diff --git a/apps/mobile/android/app/src/test/resources/golden/export/trip.kml b/apps/mobile/android/app/src/test/resources/golden/export/trip.kml
new file mode 100644
index 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 file
diff --git a/apps/mobile/src/screens/LocationInspectorScreen.tsx b/apps/mobile/src/screens/LocationInspectorScreen.tsx
index 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<"Lo
async (format: ExportFormat, tripsToExport: Trip[]) => {
if (tripsToExport.length === 0) return
try {
- const content = TRIP_CONVERTERS[format](tripsToExport)
const dateStr = mapDate.toISOString().slice(0, 10)
const isSingle = tripsToExport.length === 1
const 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.tsx
index 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 De
const 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.tsx
index 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.ts
index 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.ts
index 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.ts
index 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"