We develop mobile apps for automotive telematics that turn scattered tracker data into an actionable fleet overview. Our mobile app for telematics enables Connected Car development by integrating with telematics control units and fleet management systems using Google Maps SDK and Traccar integration. With 8 years of experience and dozens of integrations with Teltonika, Concox, and Queclink, each requiring deep understanding of binary protocols and real-time architecture, we deliver a single window for the dispatcher: live map markers, alerts, reports, and analytics — all in one interface.
We use the open-source platform Traccar as the server backbone. It provides out-of-the-box support for 200+ tracker protocols, REST API, and WebSocket for real-time data. Instead of writing integration from scratch, we focus on business logic and user experience. Each new tracker can be added in 1–2 hours, reducing custom integration effort.
Structure of a Telematics Control Unit
A TCU (or AVL tracker) is an OBD-II or CAN device with a GSM/LTE modem, GPS module, and internal buffer memory. Popular series: Teltonika FMB (FMB920, FMB003, FMB125), Concox GT06N, Queclink GV500. Data is sent to the server via TCP using proprietary binary protocols. Teltonika Codec 8/8E is the most common. The structure of an AVL record:
Full AVL record structure (Codec8)
| Field | Size (bytes) | Description |
|---|---|---|
| Timestamp | 8 | Unix ms |
| Priority | 1 | 0–3 |
| Longitude | 4 | int32 × 0.0000001 |
| Latitude | 4 | int32 × 0.0000001 |
| Altitude | 2 | int16 (meters) |
| Angle | 2 | uint16 (degrees) |
| Satellites | 1 | uint8 |
| Speed | 2 | uint16 (km/h × 10) |
| IO count | 1 | number of IO elements |
| IO elements | N | ID-Value pairs |
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
| Parameter | Traccar | Custom platform |
|---|---|---|
| Time to launch | 2–3 days | 3–4 months |
| Protocol support | 200+ (built-in) | Must write each integration |
| Real-time | WebSocket out of the box | Build from scratch |
| Scalability | Up to 10,000 devices | Limited |
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
- Tracker fleet audit — determine supported protocols, data send frequency, IO parameters.
- Traccar server setup — installation, protocol configuration, alert and report configuration.
- Mobile client development — UI for map, reports, alerts, geofence settings. Implement WebSocket connection.
- Integration with CAN data — if advanced telematics needed, connect OBD-II or CAN bus.
- Testing on real devices — verify stability under various loads.
- 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.