GPS Vehicle Tracking in a Mobile IoT Application
A GPS tracker on a vehicle sends a packet every 10 seconds. That's 8,640 records per day per object. With 50 vehicles, it's 432,000 points per day. We solve the challenge of displaying real-time positions and smooth historical playback through an optimized client-server architecture on Flutter/React Native. The key difficulty is not just getting coordinates but rendering them on the map without lag at high update rates. We implement WebSocket connections for instant data delivery, route decimation using the Douglas-Peucker algorithm, and marker clustering to handle fleets of any size. This approach saves up to 30% of the budget compared to parallel development of two native apps.
How to Ensure Real-Time Position Updates?
The mobile app receives data via WebSocket, not polling. The difference is significant:
| Parameter | Polling (HTTP) | WebSocket (Server-Sent Events) |
|---|---|---|
| Latency | from 10 seconds | 1–2 seconds |
| Server load | N requests per second | one connection |
| Traffic | headers + body each request | minimal overhead |
We use WebSocket with a binary protocol (e.g., WebSocket in Dart/TypeScript). The server pushes updates immediately after receiving a tracker packet, keeping latency minimal. WebSocket reduces latency by 5–10 times compared to polling, critical for emergency alerts.
How Many Points Can Be Displayed on the Map Without Performance Loss?
A day's history ranges from 5,000 to 15,000 points. Rendering all of them causes lag on low-end devices. Our solution: decimation using the Douglas-Peucker algorithm (Douglas-Peucker) on the server. At zoom level 10, ~500 points suffice; at zoom 17, full detail is shown. The client requests the track with a zoom parameter.
For displaying many vehicles, we use clustering: markers group together when zoomed out, showing a count. On Flutter we use Supercluster, on native platforms – GMSMarkerClusterer (Android) / CMClusterAnnotationView (iOS).
Receiving Data from IoT Trackers
Hardware GPS trackers (Teltonika FMB140, Queclink GV620, Concox GT06N) send data via TCP/UDP to a telematics server. The mobile app never interacts directly with the tracker; that's the server's job. The client receives processed streams through WebSocket or REST API.
The difference between WebSocket and polling in this scenario is tangible. Polling every 10 seconds for 50 objects means constant HTTP requests, handshake overhead, and up to 10 seconds latency. With WebSocket server-sent events, the server pushes an update immediately upon receiving a new tracker packet – latency is 1–2 seconds, no extra requests.
Map Rendering
Each tracker is a marker on the map with a vehicle icon, direction (bearing), and status. Three key aspects:
Bearing animation. The tracker changes direction – the icon rotates smoothly. On Android: ObjectAnimator.ofFloat(marker, "rotation", oldBearing, newBearing).setDuration(500). On iOS: CABasicAnimation(keyPath: "transform.rotation.z") on the marker's layer.
Smooth movement. The marker moves to the new coordinate without jumping. We use ValueAnimator with LatLngInterpolator on Android; on iOS – CABasicAnimation with CGPoint interpolation via MKAnnotationView.coordinate.
Clustering. At zoom below 12, individual markers merge. We select a clusterer based on the platform: Supercluster (Flutter), GMSMarkerClusterer (Android), or CMClusterAnnotationView (iOS). The cluster shows the count of vehicles inside.
History Playback
A day's history ranges from 5,000 to 15,000 points. Drawing a Polyline of 10,000 points directly causes lag on render. Two approaches:
Douglas-Peucker decimation on the server. When requesting history, the server simplifies the track with an epsilon parameter based on zoom level: at zoom 10, ~500 points; at zoom 17, full detail. The client requests the track with a zoom parameter.
LOD on scroll. The track for the selected period is loaded in chunks as the user scrolls the time slider. Outside the visible area, nothing is rendered.
Stops in the track are computed on the server: a cluster of points with speed < 5 km/h for more than N minutes constitutes a stop. The address is resolved via reverse geocoding (Google Maps Geocoding API or Nominatim) and cached in the database.
Speed and Alerts
Overspeeding, harsh braking, harsh acceleration – derived from raw telematics data (speed, accelerometer if supported). Alerts are sent via FCM/APNs push with high priority. In the app: UNNotificationCategory with action "Open Map" for iOS; PendingIntent with deep link for Android.
Geofence alerts: entering/exiting a zone. Checked with ST_Contains in PostGIS on every incoming packet – hundreds of thousands of checks per day for large fleets. Optimization: spatial index GIST on geometry column, R-tree on geofences in memory (GeoHashing for initial filter).
What If the Number of Geofences Exceeds 1,000?
With many geofences, performance is critical. We use the following approach:
| Number of geofences | ST_Contains check time | Optimization |
|---|---|---|
| 100 | 0.5 ms | no index |
| 1,000 | 5 ms | GIST index |
| 10,000 | 50 ms | R-tree + GeoHash |
Such a stack allows processing up to 10,000 geofences with under 50 ms per check.
From Practice: Tracking Cement Trucks
Case details
35 vehicles, 15-second recording interval, 90-day history. The problem: viewing a month's history with a Polyline of 720,000 points froze the UI for 4–5 seconds on a Samsung A32. After implementing dynamic decimation (200 points at zoom 10, 5,000 at zoom 16), rendering became smooth.
What's Included in the Project
- Server-side telematics API development (if needed)
- Integration with popular trackers (Teltonika, Queclink, Concox)
- Mobile app on Flutter/React Native with iOS and Android support
- WebSocket connection and push notification setup (FCM/APNs)
- Geofence and alert implementation
- API documentation and training for the client's team
- Technical support for 1 month after launch
Timelines and Cost
Timelines: from 2 to 6 weeks depending on integration complexity and feature requirements. Cost is calculated individually after analyzing your project. We guarantee quality and adherence to deadlines thanks to 5+ years of experience and 20+ successful projects in IoT and telematics. The total cost of ownership over 5 years is 40% lower due to a single codebase.
Get a consultation on your project – we will assess integration complexity and propose an optimal solution. Order GPS tracking app development with quality guarantee.