Google Map

Current Location

Note

You only need to add the Google Play Services support here if your application needs to display the user's current location.

Next, let's add the user's current location. A little later we'll use this for the initial map position and to keep track of where the user parked their car.

The user's Location is determined by the "Fused Location Provider". This service uses technologies such as GPS, cell towers, and wi-fi to determine the current location. Some of these provide precise location (such as GPS), while others might only be able to approximate user location.

Because an application could send location information somewhere else (a server on the internet, for example), location is considered a "dangerous" permission, and we must ask the user if it's ok to use while the application is running.

The user has a choice: they can allow precise or approximate location information, for all runs of the application or just the current run, or deny the request. Ideally, your application should gracefully handle denied function. For our car-finder application, if the user denies current location tracking, we could, for example, allow the user to tap the location of their car on the map rather than automatically using the current location. (For this example application, we won't do that; we'll just tell the user the application cannot function without location.)

Note

Requesting permissions at runtime can be a bit tricky, and support for permissions when using Jetpack Compose is still experimental (and a bit difficult to use properly). For now, we'll be requesting permissions and listening for location using the Activity and updating a view model with the reported locations.

Any needed permissions must be declared first in the AndroidManifest.xml. Here we declare

show in full file app/src/main/AndroidManifest.xml

// ...
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

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

    <application
        // ...
</manifest>

Coarse Location (for "approximate" location)
Fine Location (for "precise" location)

Both of these are "dangerous" permissions and must be requested at runtime.

The Google Play Location Services allows us to set up a listener to receive location updates. We'll want to store the current location somewhere, and we'll need it when setting the car's location. The car's location will be persisted and we want to ensure it stays across configuration changes. This sounds like a job for a View Model.

We access Play Location Services by adding a new dependency. While we're here we'll also add lifecycle support for compose.

show in full file gradle/libs.versions.toml

[versions]
// ...
//
maps-compose = "6.2.1"
location-services = "21.3.0"
lifecycle-runtime-compose = "2.8.7"

[libraries]
location-services = { group = "com.google.android.gms", name = "play-services-location", version.ref = "location-services" }
lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle-runtime-compose" }
maps-compose = { group = "com.google.maps.android", name = "maps-compose", version.ref = "maps-compose" }
maps-compose-utils = { group = "com.google.maps.android", name = "maps-compose-utils", version.ref = "maps-compose" }
// ...
[plugins]
// ...

show in full file app/build.gradle.kts

// ...

dependencies {
    implementation(libs.location.services)
    implementation(libs.lifecycle.runtime.compose)
    implementation(libs.maps.compose)
    implementation(libs.maps.compose.utils)
    // ...
}
// ...

We'll need to track the location. We create a CarViewModel and set up a MutableStateFlow as a private property in the view model. By convention, we prefix it with an underscore, indicating it's the actual flow that we'll emit to. We want our view model to keep control of emitted values, so we only expose a read-only Flow publicly.

But our MainActivity will be the thing that actually talks with the Fused Location Provider; it'll need to update the current location (by calling updateLocation).

show in full file app/src/main/java/com/androidbyexample/compose/google/google/maps/CarViewModel.kt

// ...
import kotlinx.coroutines.flow.MutableStateFlow

class CarViewModel(application: Application) : AndroidViewModel(application) {
    private val _currentLocation = MutableStateFlow<Location?>(null)

    val currentLocation: Flow<Location?>
        get() = _currentLocation

    fun updateLocation(location: Location?) {
        _currentLocation.value = location
    }
}

In the MainActivity, we define properties for the fused location provider client and the callback that we'll register to receive location updates.