Design Maps & Live Location Tracking

FusedLocationProviderClient combines GPS, Wi-Fi positioning, Bluetooth beacons, and cell towers, choosing the best source for the requested accuracy/battery trade-off. Raw LocationManager with GPS_PROVIDER only uses satellites — cold start takes 30–60 s, fails indoors, and drains battery constantly. FLPC gets a fix in ~1–2 s by using the last known Wi-Fi position immediately while GPS warms up. For consumer apps, always use FLPC over raw LocationManager.

HIGH_ACCURACY activates the GPS hardware — 3–5 m accuracy but significant battery cost. Use it during active trips. BALANCED_POWER uses Wi-Fi and cell towers only — no GPS chip activated, 50–100 m accuracy, minimal battery. Use it for the passenger's own blue dot, or the driver app during IDLE/SEARCHING state. Only activate HIGH_ACCURACY when the driver is actively on a trip.

Since Android 8, location updates in a background service are throttled to once per hour. A Foreground Service with a visible notification has much higher OS priority and receives continuous updates. Declare android:foregroundServiceType="location" in the manifest (required since Android 10), and call startForeground(id, notification) within 5 seconds of service start. Return START_STICKY so the OS restarts the service if killed under memory pressure.

Use ValueAnimator.ofFloat(0f, 1f) with duration matching the update interval (1 000 ms). In addUpdateListener, linearly interpolate lat/lng: lat = startLat + (endLat - startLat) * t. Also interpolate bearing — handle the 359° → 1° wrap: compute delta, if >180 subtract 360, if <-180 add 360. Crucially, cancel any active animation before starting a new one (activeAnimator?.cancel()) to prevent backlog when updates arrive faster than the animation completes.

Introduced in Android 10, it's a separate runtime permission from ACCESS_FINE_LOCATION, granting location access when the app is not visible. You must request FINE first; only after that can you request BACKGROUND. On Android 11+, you can't request both in the same dialog — the system forces the user to Settings. The Play Store also requires justification. For driver apps, explain the benefit clearly before requesting.

Register GoogleMap.setOnCameraMoveStartedListener. The callback receives a reason: REASON_GESTURE means the user is panning — set isFollowing = false. REASON_API_ANIMATION means your own code called animateCamera() — don't change the flag. When isFollowing is false, skip animateCamera() but still animate the marker. Show a "Re-center" FAB that sets isFollowing = true and snaps back to the driver.

You register a Geofence with a circular region and transition types. Play Services monitors the device position at the OS level using low-power cell/Wi-Fi — no GPS chip activated. When a transition is detected, it fires a PendingIntent to your BroadcastReceiver. Your app code doesn't run during monitoring — the OS handles everything and only wakes your app on boundary crossing. Far more battery-efficient than polling your own location every few seconds.

Fetch the route from the Directions API as a list of LatLng waypoints. Draw with map.addPolyline(PolylineOptions().addAll(points)). Store the Polyline reference. As the driver moves, find the closest waypoint to the driver's current position, then set polyline.points = originalPoints.drop(closestIndex). This gives the "road disappearing behind" effect without a full redraw. Don't remove and re-add the polyline on every update — updating points in-place avoids a redraw flash.

setMinUpdateDistanceMeters(5f) suppresses callbacks if the device hasn't moved more than 5 m since the last update, even if the time interval has elapsed. This filters GPS jitter when a driver is stationary — the chipset oscillates slightly, generating false position updates. Without this filter you'd upload hundreds of tiny "moves" per minute. Combine with the time interval for both time-based and distance-based filtering.

On onFailure(), emit DriverState.Disconnected(attempt = n). UI shows "Reconnecting..." and greys the marker. Reconnect with exponential backoff: min(base * 2^attempt, 30_000) + jitter. Listen to ConnectivityManager.NetworkCallback.onAvailable() to trigger immediate reconnect when network returns — don't wait for the timer. On reconnect, request a fresh snapshot from the server before resuming streaming. Cap retries at 10, then show a "Retry" button.

Use ClusterManager from Maps Android Utils. It groups nearby markers into a cluster showing the count, splitting on zoom-in. For updates: maintain a Map<driverId, Marker>. On each position update, set marker.position = newLatLng directly — O(1), preserves cluster grouping. For high volumes (100+ drivers): filter to only markers within the visible map bounds via map.projection.visibleRegion.latLngBounds.contains(pos) before adding to ClusterManager.

Dead reckoning extrapolates position between GPS fixes using last known speed and bearing: newLat ≈ lastLat + (speed * cos(bearing) * dt / R). If the driver is doing 14 m/s at 90° and the GPS fix is 1 s late, you estimate the position and keep the marker moving continuously. A Kalman filter combines these estimates with actual measurements, weighted by uncertainty, to produce a smooth filtered track — used in Google Maps navigation. Trade-off: errors compound if speed/bearing change during the gap.

Generate a JSON style file at mapstyle.withgoogle.com and save it in res/raw/map_style.json. Apply with: map.setMapStyle(MapStyleOptions.loadRawResourceStyle(context, R.raw.map_style)) inside onMapReady(). For dark mode: detect resources.configuration.uiMode and UI_MODE_NIGHT_MASK == UI_MODE_NIGHT_YES and load a dark JSON. The style is client-side — no server changes. Common use: hide POI labels to reduce visual noise during navigation.

Three cases after RequestPermission(): (1) Granted — proceed. (2) Denied but not permanently — show rationale dialog, re-request. (3) Permanently denied (shouldShowRequestPermissionRationale() returns false) — show "Open Settings" dialog launching Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS). Never loop permission requests. Show the feature as disabled with a CTA. For background location on Android 11+, the user is always directed to Settings — prepare UI for this flow.

Two approaches. (1) Maps SDK offline areas — built-in support, user downloads a rectangular region. No custom code needed. (2) Custom TileProvider: implement getTile(x, y, zoom) — check a local disk cache (LRU), return cached bytes if found, else fetch and cache. Use MBTiles for structured offline storage. Register with map.addTileOverlay(TileOverlayOptions().tileProvider(yourProvider)). For trip-start pre-caching: compute route bounding box, determine tile coordinates at zoom 14–16, fetch via WorkManager before departure.

fusedClient.lastLocation resolves instantly from cache — no GPS activation — but can be null after a fresh reboot. Use it for: showing an initial map position before live updates start, pre-populating a pickup address field, or a coarse check whether the user is in a service area. Don't use it as the main tracking mechanism — it's stale by design. Start requestLocationUpdates() for live data and use lastLocation as a quick first position while the live stream warms up.

Multiple strategies together: (1) Trip-state-adaptive priority — LOW_POWER when IDLE, HIGH_ACCURACY only during EN_ROUTE. (2) setMinUpdateDistanceMeters(5f) — suppresses callbacks when stationary. (3) Client-side filtering before WS send — skip upload if speed == 0 or delta < 3 m. (4) Batch uploads — buffer 3–5 fixes to reduce radio activations. (5) Guide driver to whitelist the app from battery optimisation via ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS — only during active trips. (6) Verify with Battery Historian before shipping.

Multiple signals: (1) location.isMock (API 31+) — true if a mock location app is active. (2) Cross-check GPS vs network location — consistent disagreement >1 km is suspicious. (3) Velocity sanity — position jumps 10 km in 1 second is physically impossible. (4) Sensor fusion — compare GPS bearing with accelerometer/gyroscope; spoofed GPS that "teleports" won't match inertial data. (5) Check if developer options mock locations is enabled. Flag signals server-side in an anti-fraud system — don't block locally.

map.isMyLocationEnabled = true shows the built-in blue dot for the user's position, plus a "My Location" button. It requires ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION at runtime — enabling it without the permission throws SecurityException. Always check ContextCompat.checkSelfPermission() first. The SDK handles all FusedLocation calls internally. Use it for the passenger's position; use your own marker + FusedLocation for the driver's position that needs server upload and custom animation.

Two approaches. (1) Server-side (standard): server receives each driver position, queries a routing engine from driver's current position to destination, pushes updated ETA back via WebSocket to the passenger. (2) Client-side: detect deviation by checking if the driver is >N metres off the drawn polyline. If deviation exceeds threshold consistently for 10+ seconds, request a new route from the Directions API, redraw the polyline, and recompute ETA from the new route's duration field. Debounce rerouting — don't trigger on every minor deviation. Use server-side in production — routing is expensive and best centralised.