Mobile App Development for Automotive Telematics

Parsing on the server (Go):

type AVLRecord struct { Timestamp time.Time Longitude float64 Latitude float64 Altitude int16 Angle uint16 Satellites uint8 Speed uint16 IOElements map[uint16]int64 } func parseAVLRecord(r *bufio.Reader) (AVLRecord, error) { var rec AVLRecord var tsMs uint64 binary.Read(r, binary.BigEndian, &tsMs) rec.Timestamp = time.UnixMilli(int64(tsMs)) var priority uint8 binary.Read(r, binary.BigEndian, &priority) // GPS Element: lon(4), lat(4), alt(2), angle(2), sat(1), speed(2) var lonRaw, latRaw int32 binary.Read(r, binary.BigEndian, &lonRaw) binary.Read(r, binary.BigEndian, &latRaw) rec.Longitude = float64(lonRaw) / 10_000_000.0 rec.Latitude = float64(latRaw) / 10_000_000.0 // ... remaining fields return rec, nil } 

Why Traccar is the Optimal Choice for the Server Part

Traccar is an open-source platform that knows 200+ tracker protocols and provides REST API and WebSocket. It can be deployed in 2–3 days, which is 30–60 times faster than developing a custom server platform (3–4 months).

According to the official documentation, Traccar supports 200+ protocols. GitHub: Traccar

Traccar REST API for the mobile client:

interface TraccarApi { @GET("devices") suspend fun getDevices(@Query("groupId") groupId: Long? = null): List<Device> @GET("positions") suspend fun getLatestPositions( @Query("deviceId") deviceId: Long? = null ): List<Position> @GET("reports/trips") suspend fun getTrips( @Query("deviceId") deviceId: Long, @Query("from") from: String, @Query("to") to: String, ): List<Trip> @GET("reports/events") suspend fun getEvents( @Query("deviceId") deviceId: Long, @Query("from") from: String, @Query("to") to: String, @Query("type") types: List<String>, ): List<Event> } 

Real-time positions — Traccar WebSocket (wss://server/api/socket):

class TraccarLiveSession(private val baseUrl: String, private val sessionCookie: String) { fun observe(): Flow<TraccarMessage> = callbackFlow { val client = OkHttpClient.Builder() .readTimeout(0, TimeUnit.MILLISECONDS) .build() val ws = client.newWebSocket( Request.Builder() .url("wss://$baseUrl/api/socket") .header("Cookie", "JSESSIONID=$sessionCookie") .build(), object : WebSocketListener() { override fun onMessage(webSocket: WebSocket, text: String) { trySend(Json.decodeFromString(text)) } override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) { close(t) } } ) awaitClose { ws.close(1000, null) } } } 

Smooth Marker Animation on the Map

Google Maps SDK is standard for Android, MapKit for iOS, Mapbox or Yandex MapKit for the Russian market. Markers move smoothly between positions using interpolation:

private fun updateVehicleMarker(position: Position) { val latLng = LatLng(position.latitude, position.longitude) val existing = vehicleMarkers[position.deviceId] if (existing == null) { vehicleMarkers[position.deviceId] = map.addMarker( MarkerOptions() .position(latLng) .icon(getVehicleIcon(position.attributes["ignition"] as? Boolean ?: false)) .rotation(position.course.toFloat()) .flat(true) )!! } else { ValueAnimator.ofFloat(0f, 1f).apply { duration = 1000 interpolator = LinearInterpolator() val from = existing.position addUpdateListener { anim -> val f = anim.animatedFraction existing.position = LatLng( from.latitude + (latLng.latitude - from.latitude) * f, from.longitude + (latLng.longitude - from.longitude) * f ) existing.rotation = position.course.toFloat() } }.start() } } 

Clustering for fleets with > 50 vehicles is mandatory: ClusterManager from Maps SDK Utilities — without it, the map lags with hundreds of markers.

Trip History and Geofences

A trip track is a Polyline from a list of GPS points. Speed-colored lines give immediate visual insight into driving style:

fun drawSpeedColoredRoute(points: List<Position>) { points.zipWithNext().forEach { (from, to) -> val color = when { to.speed > speedLimitKph -> Color.RED to.speed > speedLimitKph * 0.8 -> Color.YELLOW else -> Color.GREEN } map.addPolyline( PolylineOptions() .add(LatLng(from.latitude, from.longitude)) .add(LatLng(to.latitude, to.longitude)) .color(color) .width(4f) ) } } 

Geofences are polygons on the map; crossing them generates server events. Creating a geofence from the app: draw a polygon with taps, send coordinates to the Traccar Geofences API. Link the device via notificationTypes.

CAN Data and Advanced Telematics

Through OBD-II port or CAN bus we obtain: fuel level, mileage from ECU, RPM, load, DTC codes, temperature. Data arrives in IO Elements of the AVL record by IO ID. For Teltonika: ID 12 = ignition, ID 67 = CAN speed, ID 82 = CAN fuel level. On the server, a mapping is stored; the client receives already named fields.

Notifications and Alerts

Alerts are configured on the server and delivered via FCM or APNS. Typical fleet alerts:

• speed exceeding X km/h
• leaving a geofence during off-hours
• extended idle with engine running (fuel waste)
• battery low (< 11.8 V)
• harsh braking / acceleration
• loss of device communication for > 5 minutes

On the client: an alert feed with filtering, navigation to the map at the time of the event.

Development Stages for a Telematics App

1. Tracker fleet audit — determine supported protocols, data send frequency, IO parameters.
2. Traccar server setup — installation, protocol configuration, alert and report configuration.
3. Mobile client development — UI for map, reports, alerts, geofence settings. Implement WebSocket connection.
4. Integration with CAN data — if advanced telematics needed, connect OBD-II or CAN bus.
5. Testing on real devices — verify stability under various loads.
6. Deployment to App Store and Google Play — prepare metadata, pass review.

Each stage ends with a demo to the client. After launch, we provide one month of support.

Timelines and Cost Estimation

Basic app on Traccar: 8–12 weeks. Custom platform with CAN data and white label: 4–6 months. Typical investment ranges from $15,000 to $45,000, with clients recouping that investment within the first year through reduced downtime and fuel savings of 10-15%. We guarantee certified integrations and reduce development risk through proven experience.

What's Included in the Work

When you partner with us, you get: complete source code (iOS & Android), API documentation, deployment guides for Traccar server, access to demo environment, one month of post-launch support, and training for your dispatchers. All deliverables are thoroughly tested and come with a 30-day warranty against defects.