Android Academy · Aula

Obtendo a localização do usuário

Noções básicas do provedor de localização combinada.

Obtendo a localização do usuário é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

Onde está o usuário?

A maioria dos aplicativos que usam localização começa com uma pergunta: onde o dispositivo está agora? O Android responde a isso por meio do Fused Location Provider, que faz parte do Google Play services.

Nesta lição, você adicionará a dependência, solicitará uma localização única, ouvirá atualizações contínuas e exibirá o resultado no Compose.

Por que usar o provedor combinado

O Android tem várias fontes de localização: GPS, Wi-Fi e torres de celular. O Fused Location Provider as combina de forma inteligente para fornecer a melhor localização com o menor consumo de bateria.

Atualmente, quase nunca é necessário usar LocationManager diretamente — o cliente combinado é mais simples e inteligente.

// build.gradle.kts (module)
dependencies {
    implementation("com.google.android.gms:play-services-location:21.3.0")
}

Declarando a permissão

A localização é um recurso sensível. Declare a permissão no seu AndroidManifest.xml. Use ACCESS_FINE_LOCATION para um posicionamento preciso ou ACCESS_COARSE_LOCATION para uma localização aproximada.

Declarar a permissão é apenas o primeiro passo — você também precisa solicitá-la em tempo de execução (isso será abordado em uma lição posterior).

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

Criando o cliente combinado

Obtenha um FusedLocationProviderClient de LocationServices. No Compose, obtenha o contexto com LocalContext.current e lembre-se do cliente para que ele não seja recriado a cada recomposição.

import com.google.android.gms.location.LocationServices

@Composable
fun rememberFusedClient() = run {
    val context = LocalContext.current
    remember {
        LocationServices.getFusedLocationProviderClient(context)
    }
}

Obtendo a última localização conhecida

A resposta mais rápida é lastLocation — a localização mais recente que o sistema já armazenou em cache. Ela retorna uma Task, portanto, adicione um ouvinte de sucesso.

O valor pode ser null se nenhum aplicativo tiver solicitado uma localização recentemente; por isso, sempre verifique se ele é nulo.

@SuppressLint("MissingPermission")
fun fetchLastLocation(
    client: FusedLocationProviderClient,
    onResult: (Location?) -> Unit
) {
    client.lastLocation
        .addOnSuccessListener { location -> onResult(location) }
        .addOnFailureListener { onResult(null) }
}

Aguardando a tarefa com corrotinas

Os retornos de chamada se aninham rapidamente. A biblioteca kotlinx-coroutines-play-services adiciona .await(), permitindo ler uma localização com um código suspensivo mais limpo.

import kotlinx.coroutines.tasks.await

@SuppressLint("MissingPermission")
suspend fun currentLastLocation(
    client: FusedLocationProviderClient
): Location? {
    return client.lastLocation.await()
}

Solicitando uma localização atualizada

lastLocation pode estar desatualizada. Para obter uma localização atualizada, chame getCurrentLocation com uma prioridade. PRIORITY_HIGH_ACCURACY usa GPS; PRIORITY_BALANCED_POWER_ACCURACY economiza bateria.

import com.google.android.gms.location.Priority
import com.google.android.gms.location.CurrentLocationRequest

@SuppressLint("MissingPermission")
suspend fun freshLocation(
    client: FusedLocationProviderClient
): Location? {
    val request = CurrentLocationRequest.Builder()
        .setPriority(Priority.PRIORITY_HIGH_ACCURACY)
        .build()
    return client.getCurrentLocation(request, null).await()
}

Atualizações contínuas de localização

Para navegação ou rastreamento, você precisa de um fluxo de atualizações. Crie uma LocationRequest com um intervalo e registre um LocationCallback usando requestLocationUpdates.

Sempre interrompa as atualizações quando terminar, para economizar bateria.

import com.google.android.gms.location.LocationRequest
import com.google.android.gms.location.LocationResult
import com.google.android.gms.location.LocationCallback

val request = LocationRequest.Builder(
    Priority.PRIORITY_HIGH_ACCURACY,
    5000L // 5 seconds
).build()

val callback = object : LocationCallback() {
    override fun onLocationResult(result: LocationResult) {
        result.lastLocation?.let { /* use it */ }
    }
}

Atualizações como um fluxo

Um padrão limpo envolve as atualizações em um callbackFlow, permitindo que os consumidores coletem localizações e que as atualizações sejam interrompidas automaticamente quando a coleta terminar, por meio de awaitClose.

import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.callbackFlow

@SuppressLint("MissingPermission")
fun FusedLocationProviderClient.locationFlow(request: LocationRequest) = callbackFlow {
    val cb = object : LocationCallback() {
        override fun onLocationResult(result: LocationResult) {
            result.lastLocation?.let { trySend(it) }
        }
    }
    requestLocationUpdates(request, cb, Looper.getMainLooper())
    awaitClose { removeLocationUpdates(cb) }
}

Exibindo a localização no Compose

Colete o resultado em um composable usando LaunchedEffect para uma leitura única ou collectAsStateWithLifecycle para um fluxo. Em seguida, exiba as coordenadas.

@Composable
fun LocationLabel(client: FusedLocationProviderClient) {
    var location by remember { mutableStateOf<Location?>(null) }
    LaunchedEffect(Unit) {
        location = freshLocation(client)
    }
    Text(
        location?.let { "Lat ${it.latitude}, Lng ${it.longitude}" }
            ?: "Locating..."
    )
}

Bateria e compromissos de precisão

A localização é uma das maiores fontes de consumo de bateria em aplicativos móveis. Escolha a menor precisão que ainda atenda às suas necessidades, use o maior intervalo de atualização aceitável e sempre interrompa as atualizações quando a tela deixar de ser exibida.

Alta precisão + atualizações frequentes consomem bateria rapidamente — reserve essa combinação para a navegação ativa.

Verificação rápida

Você precisa obter agora a posição atual única e mais precisa possível, usando uma função suspensiva. Qual abordagem é a mais adequada?

Recapitulação

Agora você já consegue ler a localização do dispositivo:

Adicione play-services-location e declare ACCESS_FINE/COARSE_LOCATION.
Obtenha um FusedLocationProviderClient de LocationServices.
Use lastLocation para uma localização armazenada em cache e getCurrentLocation para obter uma localização atualizada.
Transmita atualizações por meio de requestLocationUpdates / um callbackFlow e interrompa-as para economizar bateria.

A seguir: desenhar marcadores e mover a câmera para essas coordenadas.

Perguntas Frequentes

A aula “Obtendo a localização do usuário” é grátis?

Sim — o texto completo de “Obtendo a localização do usuário” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Obtendo a localização do usuário”?

Noções básicas do provedor de localização combinada. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Obtendo a localização do usuário”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Exibindo um mapa
Obtendo a localização do usuário
Marcadores e câmera
Permissões de localização do jeito certo

← Voltar para Android Academy