Our custom mobile IoT app for fleet telematics delivers real-time tracking and driver analytics. By integrating with Traccar, we ensure seamless GPS data processing. The app displays live positions on a map, generates trip reports, and works offline. Fuel savings up to 30% are achieved through detailed driver behavior analytics. Typical MVP development cost ranges from $15,000 to $30,000 depending on complexity. For a fleet of 10 vehicles, annual fuel savings can reach $12,000–$24,000. Get a consultation to receive a precise quote.
What is Vehicle Telematics?
Telematics is the collection of data from moving objects: GPS coordinates, speed, mileage, driver behavior (harsh acceleration, braking), fuel consumption, temperature for refrigerated vans. Data flows from an onboard tracker via GPRS/LTE to a server; the mobile app is the dispatcher's or fleet manager's tool. Development splits into three layers: tracker protocol, server platform, and mobile client.
GPS Tracker Protocols
Trackers use several common protocols:
| Protocol | Trackers | Transport |
|---|---|---|
| Teltonika codec 8/8E | Teltonika FMB920, FMC003 | TCP |
| Concox protocol | Concox GT06, JT701 | TCP |
| GT06N (Gotop) | 90% of cheap Chinese trackers | TCP |
| NMEA 0183 | Most GPS modules | RS-232/TCP |
| MQTT JSON | Modern IoT trackers | MQTT/TLS |
For parsing tracker protocols we use Traccar — an open-source server platform supporting 200+ protocols. Traccar is deployed on a server, receives tracker data, and provides REST API + WebSocket for mobile clients. Using Traccar is 3x faster than a custom parser in terms of integration time: you don't need to implement parsing and track storage.
Traccar Simplifies Telematics Development
Traccar handles all the dirty work: protocol parsing, track storage, daily statistics calculation, event processing (e.g., overspeeding). Our job is only the mobile client connected via WebSocket. Example Android integration:
// Retrofit interface to Traccar API
interface TraccarApi {
@GET("devices")
suspend fun getDevices(
@Query("all") all: Boolean = false,
@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, // ISO 8601
@Query("to") to: String,
): List<Trip>
}
data class Position(
val id: Long,
val deviceId: Long,
val latitude: Double,
val longitude: Double,
val speed: Double, // knots, convert to km/h * 1.852
val course: Double,
val altitude: Double,
val accuracy: Double,
val fixTime: String,
val valid: Boolean,
val attributes: Map<String, Any>, // battery, ignition, odometer, etc.
)
Real-time updates via Traccar WebSocket:
class TraccarWebSocketClient(private val baseUrl: String, private val token: String) {
private val okHttpClient = OkHttpClient.Builder()
.readTimeout(0, TimeUnit.MILLISECONDS) // infinite timeout for WS
.build()
fun connect(): Flow<TraccarEvent> = callbackFlow {
val request = Request.Builder()
.url("wss://${baseUrl}/api/socket")
.header("Cookie", "JSESSIONID=$token")
.build()
val ws = okHttpClient.newWebSocket(request, object : WebSocketListener() {
override fun onMessage(webSocket: WebSocket, text: String) {
val event = json.decodeFromString<TraccarSocketMessage>(text)
event.positions?.forEach { trySend(TraccarEvent.Position(it)) }
event.devices?.forEach { trySend(TraccarEvent.DeviceUpdate(it)) }
event.events?.forEach { trySend(TraccarEvent.Alert(it)) }
}
override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
close(t)
}
})
awaitClose { ws.close(1000, "Closed") }
}
}
Connecting Traccar for Real-Time Monitoring
Step-by-step guide
- Deploy Traccar server on Ubuntu 22.04:
docker run -d --restart always --name traccar -p 8082:8082 -p 5000-5150:5000-5150/udp traccar/traccar:latest. - Configure tracker protocols: in
conf/traccar.xmlspecify ports for each protocol (e.g.,<entry key='teltonika.port'>5060</entry>). - Register devices in Traccar via web interface: add tracker by IMEI and protocol.
- Get API token: generate an access token in user profile.
- In the mobile app, use Traccar WebSocket to receive real-time positions – subscribe to
wss://your-server/api/socketwith cookieJSESSIONID. - Display positions on a map using Google Maps or Mapbox. Animate markers for smooth movement.
Live Map with Markers
We use Google Maps SDK on Android with custom vehicle markers. Each marker shows the current track position, and animation smoothly moves it between points – without it the icon jumps on the map.
class FleetMapFragment : Fragment() {
private lateinit var map: GoogleMap
private val vehicleMarkers = HashMap<Long, Marker>()
private fun updateVehiclePosition(position: Position) {
val latLng = LatLng(position.latitude, position.longitude)
val marker = vehicleMarkers[position.deviceId]
if (marker == null) {
val newMarker = map.addMarker(
MarkerOptions()
.position(latLng)
.icon(getBitmapDescriptor(R.drawable.ic_truck, position.course))
.title(getVehicleName(position.deviceId))
)
vehicleMarkers[position.deviceId] = newMarker!!
} else {
// Animate marker movement
animateMarker(marker, latLng, position.course)
}
}
private fun animateMarker(marker: Marker, to: LatLng, bearing: Float) {
val animator = ValueAnimator.ofFloat(0f, 1f).apply {
duration = 1000
interpolator = LinearInterpolator()
}
val from = marker.position
animator.addUpdateListener { anim ->
val fraction = anim.animatedValue as Float
marker.position = LatLng(
from.latitude + (to.latitude - from.latitude) * fraction,
from.longitude + (to.longitude - from.longitude) * fraction,
)
marker.rotation = bearing
}
animator.start()
}
}
Driver Behavior Analytics: How to Reduce Fuel Consumption?
Harsh accelerations (> 0.3g), braking (> 0.4g), sharp turns – events from the tracker's accelerometer. They come in the attributes of the position. Driver scoring is calculated on the backend, the app receives daily/weekly aggregates: percentage of time overspeeding, number of harsh events, rating out of 100. Geofences – zones on the map, events are generated on entry/exit. Adding a geofence from the mobile app: draw a polygon on the map, send coordinates to the Traccar Geofences API.
Offline Mode Critical for Dispatchers
The dispatcher watches the app constantly, and if the server is unavailable for 5 minutes – you can't show an empty map. We cache the latest positions of all vehicles in Room. On startup, show the cache, update via WebSocket. The timestamp of the last update is visible in the header. This guarantees the app works even during temporary network loss.
Tracker Parsing Approaches: Comparison
| Criteria | Custom parser | Traccar |
|---|---|---|
| Implementation time | 2-3 weeks | 1-2 days |
| Protocol support | 1-5 (manual development) | 200+ ready |
| Scalability | Limited (single-threaded parsing) | Horizontal scaling, clustering |
| Events and analytics | Requires separate development | Built-in engine for geofences, reports |
What's Included in the Work
We offer turnkey telematics development. The project includes:
- Analysis of your tracker protocols (up to 2 days)
- Deployment of Traccar server with redundancy
- Mobile app for iOS/Android (Swift/Kotlin)
- Integration with Traccar API and WebSocket
- Implementation of maps, reports, geofences, analytics
- Offline caching of latest positions
- API and configuration documentation
- Training for 2-3 staff on system usage
- Support for 2 weeks after release
Timeline: MVP in 5–8 weeks, full platform with CAN integration – 3–4 months. Cost is calculated individually after analyzing your device fleet. Request a demo access to the app – evaluate the functionality on real data from your fleet. We will respond within one day. Get a consultation on your fleet.
We have extensive experience in IoT and telematics, having completed over 50 projects. Our engineers hold Google and Apple Developer certifications. We guarantee compliance with App Store Review Guidelines (Section 4.2) and 5.1, as well as data confidentiality.