Location Permission in Mobile Development: What It Is, Access Levels and How It Works

What is Location Permission?

Location Permission is an operating system mechanism that regulates application access to data about the device’s geographical location. Without explicit user consent, the application cannot obtain GPS coordinates, Wi-Fi network data, or cellular tower information.

Mobile platforms Android and iOS implement their own permission systems, but the general logic is the same: the application declares the necessary permissions in the manifest or configuration file, then requests them at runtime. According to Android Developers, 2024, starting from Android 10, all geolocation permissions belong to the dangerous category and require runtime requests.

The reason for this approach is user privacy protection. Location data can be used to build travel routes, determine places of work and leisure, and identify individuals. Therefore, both platforms require transparent explanation in the request dialog: the application must state the reason why it needs access to geolocation.

Why Location Permission is Needed

Location Permission is necessary for any application whose functionality depends on knowing the user’s physical location. Maps and navigation, delivery apps, weather services, social networks with geotagging — all these categories of software require Location Permission.

Without this permission, the application cannot determine device coordinates by any available method: neither through the GPS module, nor through Wi-Fi scanning, nor through cellular tower positioning. The user can revoke the permission at any time in the system settings, after which the application must handle the denial gracefully.

According to a study by Pew Research Center (2024), about 45% of users revoke geolocation access in applications that do not use it for their core functionality. This means that developers need to clearly justify the request and offer alternative mechanics for those who declined Location Permission.

Legal Requirements

GDPR in Europe and Federal Law 152-FZ in Russia require obtaining informed consent for processing location data. The application must not only request permission through the system dialog but also provide a separate notice about the purposes of data collection. Violation of these requirements entails fines of up to 20 million euros or 4% of the company’s annual turnover.

Consequences of Missing Permission

If the application does not request Location Permission or the user denies access, the developer must provide a fallback scenario. For a mapping application, this could be manual address entry; for a delivery app — selection from a list of saved addresses; for a weather service — city determination by IP address. Graceful degradation is a standard practice recommended by Google and Apple.

Location Access Levels

Location access levels differ on Android and iOS, although the general idea is the same: the more precise the access, the stricter requirements the platform imposes on the application.

ACCESS_FINE_LOCATION and ACCESS_COARSE_LOCATION on Android

ACCESS_FINE_LOCATION provides access to precise GPS coordinates with an accuracy of up to several meters. To declare this permission in the manifest, the constant android.permission.ACCESS_FINE_LOCATION is used. ACCESS_COARSE_LOCATION, in turn, provides approximate location with an accuracy of up to 500 meters based on Wi-Fi and cellular tower data.

When In Use and Always on iOS

When In Use allows the application to receive coordinates only when it is open on the screen. Always provides access to geolocation even in the background, but requires mandatory App Store review. Starting from iOS 14, the user can separately disable precise positioning for each application using the Precision toggle.

Requesting Location Permission on Android

Requesting Location Permission on Android is done in two stages: declaring permissions in the manifest and runtime request in code. Starting from Android 6.0 (API 23), all dangerous permissions are requested during application runtime, not at installation.

Declaration in the Manifest

The first step is to add the necessary permissions to the AndroidManifest.xml file. Different constants are used for precise and approximate positioning.

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Runtime Request in Kotlin

After declaring in the manifest, the system permission request dialog must be called in the application code. Let’s look at an example in Kotlin using the Activity Result API.

private val locationPermissionRequest =
    registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
    when {
        permissions.getOrDefault(Manifest.permission.ACCESS_FINE_LOCATION, false) -> {
            // Permission granted
            getLocation()
        }
        permissions.getOrDefault(Manifest.permission.ACCESS_COARSE_LOCATION, false) -> {
            // Approximate location only
            getCoarseLocation()
        }
        else -> {
            // User denied
            showLocationExplanation()
        }
    }
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    checkLocationPermission()
}

Handling Denial and Re-request

If the user denies access, the Android system does not allow showing the dialog again automatically. The developer needs to call shouldShowRequestPermissionRationale to display a preliminary explanation. In case of a repeated denial with the Never Ask Again flag, the user should be redirected to system settings.

private fun checkLocationPermission() {
    when {
        ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) ==
            PackageManager.PERMISSION_GRANTED -> {
            getLocation()
        }
        ActivityCompat.shouldShowRequestPermissionRationale(this,
            Manifest.permission.ACCESS_FINE_LOCATION) -> {
            showRationaleDialog {
                requestLocationPermission()
            }
        }
        else -> {
            openAppSettings()
        }
    }
}

Requesting Location Permission on iOS

Requesting Location Permission on iOS requires adding special keys to the Info.plist file and calling methods of the CLLocationManager class. Apple places special emphasis on privacy, so the explanation text in the request dialog must be as specific as possible.

Configuring Info.plist

To request location on iOS, you need to add one or both keys to Info.plist: NSLocationWhenInUseUsageDescription for access while using the app and NSLocationAlwaysAndWhenInUseUsageDescription for background access. The value of each key is a string that will be shown to the user in the dialog.

<key>NSLocationWhenInUseUsageDescription</key>
<string>Your app needs your location to display nearby points on the map.</string>
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>Your app needs background location access to track your route.</string>

Request in Swift

In Swift code, the request is made through an instance of CLLocationManager. Depending on the required access level, requestWhenInUseAuthorization or requestAlwaysAuthorization is called.

import CoreLocation

class LocationManager: NSObject, CLLocationManagerDelegate {
    private let manager = CLLocationManager()

    func requestLocationAccess() {
        manager.delegate = self
        manager.requestWhenInUseAuthorization()
    }

    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
        switch manager.authorizationStatus {
        case .authorizedWhenInUse, .authorizedAlways:
            startLocationUpdates()
        case .denied, .restricted:
            showSettingsAlert()
        case .notDetermined:
            break
        }
    }
}

Difference Between Platforms

Unlike Android, iOS does not provide the developer with a method to check shouldShowRequestPermissionRationale. The system itself decides when to show the explanation. Additionally, on iOS, the user can only change permission through system settings — the application cannot re-display the system dialog after the user has made a choice. RequestAlwaysAuthorization first requests When In Use, and then, after receiving the first consent, a separate dialog for background access.

Best Practices for Working with Geolocation

Best practices for working with Location Permission help reduce user denials and meet app store requirements. Google and Apple have published recommendations that increase the likelihood of app approval.

Request Permission in Context

Do not show the Location Permission request dialog immediately when the application starts. A user who has just opened the app does not yet understand why they need to provide geolocation access. Contextual request means that the dialog appears at the moment when the user actually needs a feature that requires permission. For example, when clicking the “Find nearest store” button.

Explain the Reason in Advance

Before the system dialog, show your own pre-permission screen. On it, explain why the app needs geolocation, what data is collected, and how it will be used. After the user clicks “Allow” on your screen, show the system dialog. According to Appsflyer (2024), this approach increases approval conversion by 25-35%.

Don’t Request Always Unnecessarily

Background geolocation access is only needed for apps that work in the background: navigators, activity trackers, delivery apps. If your app only needs coordinates when the screen is open, request When In Use. The App Store will reject the app if Always is not functionally justified. On Android, background access is additionally regulated through the ACCESS_BACKGROUND_LOCATION permission.