Modern mobile devices have become an integral part of the navigation infrastructure, providing access to accurate geodata anywhere in the world. For application developers and advanced users, knowing how to programmatically or systemically extract coordinates opens up great opportunities for creating geoservices, trackers, and smart notifications. The process of obtaining this data on the platform latitudes and longitudes, opens up wide opportunities for creating geoservices, trackers and smart notifications. The process of obtaining this data on the platform Android has evolved from simple methods to complex asynchronous requests taking into account energy efficiency.
Understanding how geolocation works is critically important, since an error in the code or settings can lead to a complete lack of signal or rapid battery drain. In this article, we will analyze in detail the architectural features of working with GPS, consider current APIs and answer the question of how to correctly process data LocationManager to obtain a stable result.
Geolocation architecture in Android
The foundation of any work with coordinates in the ecosystem Google is a service Google Play Servicesthat abstracts the developer from direct interaction with the hardware. Previously, the classic approach via LocationManagerwas used, requiring manual control of providers such as GPS, network or passive mode. However, the modern paradigm has shifted toward one that intelligently selects the best data source. Fused Location Provider API, which intelligently selects the best data source.
This API automatically balances accuracy and power consumption by switching between satellites, cell towers, and Wi-Fi hotspots. Using outdated methods may cause your application to work unstable on new versions of the OS, starting from Android 10 and higher, where the rules for accessing background processes have been tightened.
⚠️ Attention: Direct access to the GPS chip through old methods may be blocked by the system on devices with the latest security patches, so always check the API support in manufacturer's documentation.
For correct operation, you need to understand the difference between coarse (approximate) and fine (exact) location. In the first case, you will receive data with an error of several hundred meters based on IP or towers, in the second - accurate coordinates up to several meters, but with high power consumption.
Use the Fused Location Provider API for most tasks, as it automatically switches between signal sources, providing a better balance of accuracy and battery consumption.
Required permissions and security settings
Starting with version Android 6.0 (Marshmallow), the permission model has become dynamic, requiring explicit user consent during application execution, and not just during installation. This means that simply adding lines to the manifest is not enough: you need to programmatically request rights to access geodata.
In the file AndroidManifest.xml you should write the necessary tags, indicating the level of accuracy. To obtain longitude and latitude, a combination of permissions is most often required, especially if the application must run in the background.
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /><uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
Particular attention should be paid to background access, since in Android 11 and later, users can only allow access to geolocation while using the application. If your app tries to get coordinates in the background without special permission, the system will simply return the last known location or null.
☑️ Check permissions
Using the Fused Location Provider API
This is the primary tool for developers who want reliable location data. The class FusedLocationProviderClient provides a simple interface for querying your current location or subscribing to its updates. Unlike old methods, it does not require deep knowledge about the operation of a specific GPS module of the device.
To initialize the request, you need to create a client object and configure parameters via LocationRequest. Here you set the priority (accuracy), update interval and the minimum distance that the user must travel for the system to send a new event.
The code for obtaining the last known location is as follows:
fusedLocationClient.lastLocation.addOnSuccessListener { location ->
if (location != null) {
val latitude = location.latitude
val longitude = location.longitude
// Coordinate processing
}
}
In such cases, it is recommended to use a method requestLocationUpdatesthat guarantees receiving fresh data, such as only they will become available from the provider.
| Request parameter | Description | Impact on battery |
|---|---|---|
| PRIORITY_HIGH_ACCURACY | Uses GPS for maximum accuracy | High |
| PRIORITY_BALANCED_POWER_ACCURACY | Balance between Wi-Fi/towers and GPS | Medium |
| PRIORITY_LOW_POWER | Cell towers only (City level) | Low |
| PRIORITY_NO_POWER | Passive mode (only if other applications request) | Minimal |
Why does lastLocation return null?
This happens if the device has never previously requested a location or if the geodata cache has been cleared by the system to save resources. In this case, be sure to use requestLocationUpdates.
Working with the classic LocationManager
Although Google recommends using the Fused API, in some specific scenarios, such as when working with specialized hardware or in system applications, you may need direct access through LocationManager. This approach gives full control over the choice of provider, but requires manual handling of all possible errors and conditions.
You can explicitly tell the system to use LocationManager.GPS_PROVIDER to receive data exclusively from satellites. This is useful in field conditions where there is no cellular network coverage, but increases time to first fix (TTFF).
- 📍 Direct control over turning a specific provider on and off.
- ⚡ Ability to set your own criteria for accuracy and response time.
- 📡 Access to raw GNSS data for professional navigation calculations.
However, using this method places the responsibility on the developer to check the availability of the provider. Not all devices may have a GPS module installed, and attempting to request data from a non-existent provider will result in an exception or an empty result.
⚠️ Attention: When using LocationManager in the background on Android 8.0+, location updates may not arrive more often than once every few minutes, regardless of your settings, due to system limitations.
Coordinate processing and data conversion
Having received an object Location, you retrieve the latitude and longitude values in double precision format. This data is in decimal degrees and must be processed correctly before being sent to the server or displayed on a map.
Often there is a need to convert these coordinates to other formats, such as degrees, minutes and seconds (DMS), or to calculate the distance between two points. The class Location provides a built-in method distanceTothat uses Vincenty's formula to calculate the distance in meters between two location objects.
For display on web maps or in specific GIS systems, conversion to projection Web Mercator or other standards may be required. It is important to consider that the accuracy returned along with the coordinates indicates the radius of uncertainty in meters, and this parameter cannot be ignored.
val accuracyInMeters = location.accuracyif (accuracyInMeters > 100) {
// The coordinates are too imprecise for our purposes
discardLocation()
} else {
processCoordinates(location.latitude, location.longitude)
}
Always check the timestamp (time) of the received location. If the difference between the current time and the time the coordinates were received exceeds an acceptable threshold (for example, 5 minutes), the data may be out of date and may not reflect the actual position of the device.
Always check the accuracy and time fields of the Location object before use to avoid processing outdated or inaccurate data.
Typical problems and solutions
The development of geo-based applications is associated with a number of specific difficulties, such as lack of signal in the room, “drift” of coordinates, or system refusal to provide access. One of the most common problems is receiving the same point (often zero or last known) instead of the real location.
This often happens due to aggressive energy conservation by the smartphone manufacturer. Many vendors, such as Xiaomi, Huawei or Samsung, have their own add-ons for Android that kill background processes, including geolocation services.
- 🔋 Check your battery settings and add the application to the exceptions (Whitelist).
- 📶 Make sure they are enabled high-precision modes in the system settings.
- 🔄 Implement the logic of re-request when receiving a null or old location.
It is also worth considering that in Android Studio emulators, coordinates are set manually and may behave differently than on a real device. To debug motion-dependent functions, use the emulator's advanced settings panel to simulate the route.
⚠️ Attention: On devices without a built-in GPS module (some tablets and TVs), you can only get coordinates via Wi-Fi, and the accuracy will be significantly lower.
Interfaces and menu names in the settings may vary depending on the Android version and the manufacturer's shell. If you cannot find the switch you need, check the official user manual for your specific device model.
Frequently asked questions (FAQ)
Why does the application not receive coordinates even though permission is given?
Most often the problem lies in the system's power saving settings or what you request access only in the background, and the user has allowed access "Only while in use". Check the battery settings for a specific application.
How to get coordinates without the Internet?
The Internet is not required for GPS to work, since satellites transmit the signal directly to the chip. However, to quickly download the satellite almanac (A-GPS) and determine the location using towers (Network Location), a network connection is desirable.
How accurate are the coordinates obtained via Wi-Fi?
The accuracy of Wi-Fi determination usually ranges from 50 to 150 meters in urban environments, as it depends on the density of known access points in the Google database. In rural areas, the error can reach several kilometers.
Is it possible to fake a location on Android?
Yes, using standard developer tools you can select a fictitious application to provide location. However, modern applications can detect the use of mock locations through the flag isFromMockProvider.