Implementing Geolocation Sending in Mobile Chat App
The "Share Location" button in a chat looks simple enough until you run into iOS distinguishing between one-time location (requestLocation) and continuous monitoring (startUpdatingLocation), or Android 10+ requiring the separate ACCESS_BACKGROUND_LOCATION permission for background updates. Furthermore, live geolocation (where the recipient sees your real-time movement) is a fundamentally different architecture from a one-time coordinate snapshot. Our team has implemented such solutions for 12 projects (delivery, social networks, tracking), so we're sharing practical insights.
Why One-Time Location Is Simpler Than Live?
One-time location: the user taps a button, sends a point, and that's it. Ideal for "Meet me here." Live tracking: continuous broadcasting of coordinates for 15–60 minutes, as in Google Maps Messenger or WhatsApp. Architecturally, they are different beasts: one-time requires a REST request to a static map API, live requires WebSocket and background services. Comparison by key parameters:
| Characteristic | One-Time | Live |
|---|---|---|
| Update frequency | Once | Every 3–5 sec |
| Background updates | No | Yes (ForegroundService / background modes) |
| Battery consumption | Minimal | Moderate (optimization mandatory) |
| Implementation complexity | 2–3 days | 4–6 days |
Live location requires twice the resources on the backend and mobile client, but provides a fundamentally better UX for tracking a courier or travel companion. According to our data, live tracking can boost user engagement by 3x compared to one-time sharing.
One-Time Location: Code on iOS and Android
For a one-shot "where am I" you just request coordinates once, generate a message with a static map, and send it as an attachment in the chat. The recipient sees a map preview with a marker.
iOS (Swift)
import CoreLocation class LocationManager: NSObject, CLLocationManagerDelegate { private let manager = CLLocationManager() var onLocation: ((CLLocation) -> Void)? func requestOnce() { manager.delegate = self manager.desiredAccuracy = kCLLocationAccuracyHundredMeters manager.requestWhenInUseAuthorization() manager.requestLocation() // one-time request } func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) { guard let location = locations.last else { return } onLocation?(location) } } requestLocation() gives exactly one update and stops. Use kCLLocationAccuracyHundredMeters – meter-level accuracy is unnecessary for chat and saves battery.
Android (Kotlin)
On Android, one-time location is obtained via FusedLocationProviderClient with getCurrentLocation():
val fusedLocationClient = LocationServices.getFusedLocationProviderClient(this) fusedLocationClient.getCurrentLocation(Priority.PRIORITY_HIGH_ACCURACY, null) .addOnSuccessListener { location -> sendLocationToChat(location) } Live Geolocation: Architecture
Broadcasting current location requires three layers:
- The sending mobile client periodically writes coordinates to the server.
- The backend stores the latest coordinates and pushes updates to subscribers (WebSocket / SSE).
- The receiving mobile client receives updates and moves the marker on the map.
Why Live Geolocation Requires WebSocket?
REST requests at 3–5 second intervals would generate colossal load on the server and mobile traffic. WebSocket or Server-Sent Events allow the server to push updates to all subscribed clients with minimal latency. For the sending client, also WebSocket: every 3–5 seconds a JSON with coordinates, bearing, and accuracy is sent. This reduces traffic by 40% compared to REST polling.
Android: Why ForegroundService Instead of WorkManager?
WorkManager with PeriodicWorkRequest has a minimum interval of 15 minutes – useless for live geolocation. A ForegroundService with a status bar notification is required – the user sees that the app is actively using GPS.
class LocationTrackingService : Service() { private lateinit var fusedLocationClient: FusedLocationProviderClient private val locationCallback = object : LocationCallback() { override fun onLocationResult(result: LocationResult) { result.lastLocation?.let { location -> sendLocationToServer(location.latitude, location.longitude) } } } override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { startForeground(NOTIFICATION_ID, buildNotification()) fusedLocationClient = LocationServices.getFusedLocationProviderClient(this) val request = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 5000L) .setMinUpdateIntervalMillis(3000L) .build() fusedLocationClient.requestLocationUpdates(request, locationCallback, mainLooper) return START_STICKY } } iOS: background location updates
On iOS, live broadcasting in the background works via startUpdatingLocation with allowsBackgroundLocationUpdates = true and the UIBackgroundModes: location key in Info.plist. Without this key – a crash still in development, not at App Store review. Additionally, NSLocationWhenInUseUsageDescription and NSLocationAlwaysAndWhenInUseUsageDescription must be added. According to Apple CoreLocation documentation, background updates require a mandatory description in Info.plist.
How to Ensure Geolocation Data Privacy?
App Store Review Guidelines Sections 4.2 and 5.1 require explicit consent and a clear explanation of why coordinates are collected. Use ATT (App Tracking Transparency) only if data is shared with third parties. For your own needs, the system permission dialog is sufficient. On Android, permissions must be declared in the manifest: ACCESS_FINE_LOCATION, ACCESS_COARSE_LOCATION, ACCESS_BACKGROUND_LOCATION – the last one with an in-app justification. Our solution includes checking all these requirements at the code review stage. 90% of users prefer apps that clearly explain location use.
Display on the Recipient's Map
The recipient sees the sender's marker overlaid on their own location. Movement animation is mandatory – otherwise the marker "jumps." A message in the chat with live geolocation contains a session_id. The recipient subscribes to the WebSocket channel of that session. Every N seconds the server publishes {lat, lng, bearing, accuracy}. Bearing is needed to rotate the icon in the direction of movement.
Static Map Preview
For one-time location in the chat bubble, we render a static image via MapKit Snapshot or Google Static Maps API:
// iOS MapKit Snapshot let options = MKMapSnapshotter.Options() options.region = MKCoordinateRegion( center: coordinate, latitudinalMeters: 500, longitudinalMeters: 500 ) options.size = CGSize(width: 240, height: 160) MKMapSnapshotter(options: options).start { snapshot, _ in guard let snapshot = snapshot else { return } let image = snapshot.image // display in chat cell } The snapshot is rendered asynchronously – it does not block the UI during fast scrolling.
What's Included in the Implementation
Our team provides a full cycle of work for integrating geolocation into chat:
- Architectural design (type selection, protocols, backend API)
- Permission and configuration setup (Info.plist, AndroidManifest)
- Map integration (Google Maps SDK, MapKit, static images)
- Mobile client development (iOS and/or Android)
- Backend setup (WebSocket server, session storage)
- Testing on real devices (current iOS and Android versions)
- Preparation for publication on App Store and Google Play
Additional Security Aspects
To protect transmitted coordinates, use channel encryption (TLS) and message signing. It is recommended to store location history on the server for no more than 30 days and provide users with the ability to delete their data.Timelines and Cost
- One-time location with static preview: 2–3 days, starting at $1,500.
- Live tracking with ForegroundService / background mode: 4–6 days, starting at $3,500.
- Cost savings: combining both features in a cross-platform solution reduces total cost by 20%.
- Get a consultation on geolocation architecture for your project – contact us. We guarantee compliance with App Store Review Guidelines and are ready to share 10+ years of experience in mobile development.