Criar um app de navegação simples para Android com o SDK de navegação da Plataforma Google Maps

1. Antes de começar

Este codelab ensina a criar um app Android simples que usa o SDK Navigation da Plataforma Google Maps para navegar até um destino pré-configurado.

O app vai ter esta aparência quando você terminar.

b6c535afde7abd20.png

Pré-requisitos

  • Conhecimento básico de desenvolvimento de apps Android em Kotlin
  • Familiaridade com conceitos básicos do SDK do Google Maps, como mapas, locais e coordenadas.

O que você vai aprender

  • Como criar um app Android simples que usa o SDK Navigation para navegar até um destino.
  • Como integrar o SDK Navigation do repositório Maven remoto do Google
  • Como gerenciar permissões de local e o contrato do usuário com os termos do usuário final do SDK Navigation
  • Como inicializar o SDK
  • Como definir um destino e iniciar o trajeto.

O que é necessário

  • A versão estável mais recente do Android Studio instalada. Este codelab foi criado usando o Android Studio Jellyfish. Se você estiver usando uma versão diferente, a aparência e o layout da interface e dos componentes poderão variar.
  • Uma Conta do Google e um projeto com o faturamento ativado.
  • Um dispositivo Android no modo de desenvolvedor com a depuração USB ativada ou um emulador Android. Qualquer uma das opções escolhidas precisa atender aos requisitos mínimos do SDK Navigation.

2. Começar a configuração

Se você ainda não tiver uma conta do Google Cloud Platform e um projeto com faturamento ativado, configure seu projeto do Google Cloud seguindo as instruções de primeiros passos com a Plataforma Google Maps https://developers.google.com/maps/gmp-get-started

Selecione seu projeto do Google Cloud no console.

No Console do Cloud, clique no menu suspenso do projeto e selecione o projeto que você quer usar neste codelab.

O menu suspenso do seletor de projetos no console do Google Cloud.

Ativar o SDK Navigation no seu projeto

Ative as APIs e os SDKs da Plataforma Google Maps necessários para este codelab no Google Cloud Marketplace.

Acesse APIs e serviços > Biblioteca no console do Google Cloud e pesquise "SDK Navigation".

Você vai ver um resultado da pesquisa.

A tela da biblioteca de APIs no console do Google Cloud, mostrando a página do SDK Navigation.

Clique no resultado do SDK Navigation para abrir a página de detalhes do produto. Clique no botão "Ativar" para ativar o SDK no seu projeto.

Repita esse processo para o SDK do Maps para Android.

crie uma chave de API

Gere uma chave de API na página Credenciais do Console do Cloud. Siga as etapas da etapa 3 da seção de guia de início rápido em Começar a usar a Plataforma Google Maps. Todas as solicitações à Plataforma Google Maps exigem uma chave de API.

3. Acessar os arquivos do projeto de exemplo

Esta seção descreve como configurar um projeto básico vazio do Android Studio clonando arquivos do repositório do GitHub para este codelab. O repositório do GitHub contém versões do código do codelab antes e depois. O codelab vai começar com um modelo de projeto vazio e criar até o estado final. Se você tiver dificuldades, use o projeto concluído no repositório como referência.

Clone este repositório do GitHub para acessar o código deste codelab.

git clone https://github.com/googlemaps-samples/codelab-navigation-101-android-kotlin.git

Se você não tiver o git instalado, clique neste botão para acessar o código:

Para começar o mais rápido possível, o repositório contém um código inicial na pasta Starter para ajudar você a acompanhar este codelab. O projeto inicial fornece uma interface básica do app e uma configuração de build, mas não tem o SDK Navigation adicionado. Há também um projeto Solution concluído caso você queira avançar ou verificar seu progresso a qualquer momento.

Abra o repositório clonado no Android Studio

Depois de clonar o repositório localmente, use o Android Studio para abrir a pasta Starter como um projeto existente.

  1. Na caixa de diálogo "Welcome to Android Studio", clique no botão "Open".
  2. Navegue até a pasta em que você salvou o repositório clonado e selecione a pasta Starter dentro da pasta de nível superior "codelab-navigation-101-android-kotlin".
  3. Verifique se o projeto é criado e executado.

Adicionar um dispositivo virtual ou conectar um dispositivo físico

Para conectar um dispositivo Android ao computador, siga as instruções do Android Studio sobre como executar apps em um dispositivo de hardware. Também é possível configurar um dispositivo virtual usando o AVD Manager. Ao escolher um emulador, selecione uma imagem que inclua as APIs do Google.

No Android Studio, clique na opção de menu "Run" ou no ícone do botão de reprodução. Escolha um dispositivo quando solicitado.

4. Adicionar o SDK Navigation ao seu app

Adicionar a biblioteca do SDK Navigation e sua chave de API ao projeto

Para adicionar a biblioteca do SDK Navigation ao seu app, modifique o app-level build.gradle.kts para buscar o SDK Navigation no repositório Maven do Google e configurar um número de versão.

Crie uma variável na configuração de build para armazenar o número da versão do SDK Navigation.

Configure uma variável no build.gradle.kts do nível do app para conter o valor da versão do SDK Navigation usada no app. Assim, será fácil mudar para a versão mais recente no futuro.

Confira as notas da versão do SDK Navigation para saber o número da versão mais recente.

val navSdkVersion by extra("6.0.0")

Também é possível modificar os valores dessa e de outras variáveis usando a caixa de diálogo em Arquivo > Estrutura do projeto > Variáveis:

668332736b67dc82.png

Adicionar uma dependência à configuração do build

Agora, adicione a seguinte dependência de API ao bloco de dependências no arquivo build.gradle.kts. do app. A versão usada será o valor de ${navSdkVersion}, que você acabou de definir no arquivo build.gradle.kts do app:

dependencies {

   // Include the Google Navigation SDK.
   api("com.google.android.libraries.navigation:navigation:${navSdkVersion}")

...

Adicionar sua chave de API

Usar o plug-in Secrets Gradle para gerenciar a chave de API

Recomendamos usar o plug-in Secrets Gradle para gerenciar a chave de API no seu app de forma segura. O plug-in foi adicionado ao modelo de projeto inicial como uma dependência no arquivo build.gradle.kts de nível superior.

// Top-level build file where you can add configuration options common to all sub-projects/modules.
plugins {
    id("com.google.android.libraries.mapsplatform.secrets-gradle-plugin") version "2.0.1" apply false
    //... other plugin definitions here
}

Abra o arquivo secrets.properties no diretório de nível superior e substitua YOUR_API_KEY pela sua chave de API. Armazene sua chave nesse arquivo porque secrets.properties não é verificado em um sistema de controle de versões.

MAPS_API_KEY=YOUR_API_KEY

Para mais informações sobre esse tópico, consulte Adicionar a chave de API ao seu app na documentação do SDK Navigation.

Verifique o conteúdo de local.defaults.properties

O projeto vazio também contém um arquivo local.defaults.properties no diretório de nível superior, na mesma pasta que o arquivo secrets.properties. Abra e observe o código a seguir.

MAPS_API_KEY=DEFAULT_API_KEY

Isso existe para fornecer um valor de backup para a propriedade MAPS_API_KEY caso secrets.properties não seja adicionado ao projeto, para que os builds não falhem. Não é necessário editar esse arquivo. Se a definição secrets.properties de MAPS_API_KEY não for encontrada, o valor padrão vai interromper a execução do app no tempo de execução, com um erro de chave de API.

Verifique se o manifesto do Android está usando a chave de API especificada

Abra app/src/main/AndroidManifest.xml. Você vai notar que a propriedade MAPS_API_KEY é usada para definir a chave de API do aplicativo:

<meta-data
    android:name="com.google.android.geo.API_KEY"
    android:value="${MAPS_API_KEY}" />

Abra o arquivo build.gradle.kts no nível do app e encontre a propriedade secrets.

A configuração propertiesFileName do plug-in precisa ser definida como secrets.properties, e defaultPropertiesFileName precisa ser local.defaults.properties.

secrets {
    // Optionally specify a different file name containing your secrets.
    // The plugin defaults to "local.properties"
    propertiesFileName = "secrets.properties"

    // A properties file containing default secret values. This file can be
    // checked in version control.
    defaultPropertiesFileName = "local.defaults.properties"
}

Salve todos os arquivos e sincronize seu projeto com o Gradle.

5. Configurar permissões do app e adicionar uma interface básica

Solicitar permissão de localização exata

O SDK Navigation depende de sinais de GPS para funcionar. Portanto, seu app precisa pedir ao usuário que conceda acesso a dados de localização exatos. Adicione a permissão para acessar o local exato como um elemento filho de <manifest> no 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_FINE_LOCATION"
   />
</manifest>

Leia mais sobre as permissões de localização do Android na seção Solicitar permissões de localização da documentação para desenvolvedores Android.

Para executar o app em um dispositivo Android 14, solicite a permissão de localização do serviço em primeiro plano adicionando a seguinte tag uses-permission no mesmo local da permissão de acesso à localização precisa:

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

Adicionar uma atividade de inicialização com uma interface básica

Quando o app for executado, ele precisará de um código que seja executado durante a inicialização para verificar se o usuário concedeu permissão para acessar a localização e lidar com cada cenário possível, solicitando permissão se ela ainda não tiver sido concedida. Para isso, adicione uma interface do usuário básica ao app. Este codelab usa a interface criada quando você cria uma atividade Views vazia no Android Studio. Você vai adaptar isso para realizar a verificação de permissão de localização antes de adicionar código à atividade para a interface de navegação.

Abra o arquivo MainActivity.kt no editor de código e inspecione o código, que mostra uma interface básica.

Solicitar permissões de acesso à localização no momento da execução

Seu app precisará acionar a solicitação de acesso à localização exata antes da inicialização do SDK Navigation.

Para garantir que essa verificação aconteça quando o app for iniciado, adicione um código à classe MainActivity, no método onCreate() substituído da sua atividade.

O código a seguir verifica se o usuário concedeu a permissão de localização exata. Caso contrário, ele solicita a permissão. Adicione esse código ao método onCreate().

    val permissions =
      if (VERSION.SDK_INT >= VERSION_CODES.TIRAMISU) {
        arrayOf(permission.ACCESS_FINE_LOCATION, permission.POST_NOTIFICATIONS)
      } else {
        arrayOf(permission.ACCESS_FINE_LOCATION)
      }

    if (permissions.any { !checkPermissionGranted(it) }) {

      if (permissions.any { shouldShowRequestPermissionRationale(it) }) {
        // Display a dialogue explaining the required permissions.
      }

      val permissionsLauncher =
        registerForActivityResult(
          RequestMultiplePermissions(),
          { permissionResults ->
            if (permissionResults.getOrDefault(permission.ACCESS_FINE_LOCATION, false)) {
              onLocationPermissionGranted()
            } else {
              finish()
            }
          },
        )

      permissionsLauncher.launch(permissions)
    } else {
      android.os.Handler(Looper.getMainLooper()).postDelayed({ onLocationPermissionGranted() }, SPLASH_SCREEN_DELAY_MILLIS)
    }
  }

  private fun checkPermissionGranted(permissionToCheck: String): Boolean =
    ContextCompat.checkSelfPermission(this, permissionToCheck) == PackageManager.PERMISSION_GRANTED

Adicione uma nova função à classe MainActivity, chamada onLocationPermissionGranted, que vai processar o resultado quando o usuário conceder permissão para compartilhar a localização. Nas próximas etapas, vamos adicionar código aqui para iniciar uma nova atividade de navegação.

private fun onLocationPermissionGranted() {
   //code to initialize Navigation SDK will go here
}

Crie o projeto. Se houver erros de build, encontre e corrija.

Execute o projeto em um novo dispositivo virtual. A caixa de diálogo de solicitação de permissão vai aparecer quando o app for instalado e iniciado.

6. Adicionar uma interface do usuário de navegação

Há duas maneiras de adicionar uma interface de navegação: SupportNavigationFragment ou NavigationView.

Para simplificar, o codelab usa um NavigationView.

Editar o layout

Edite res/layout/activity_main.xml para adicionar um layout a uma NavigationView.

  1. Abra o arquivo e mude para a Visualização de código.
  2. Substitua todo o conteúdo do arquivo por um novo layout de um NavigationView dentro de um RelativeLayout, como no exemplo abaixo. Como você só vai adicionar uma visualização de navegação ao app, um layout simples é suficiente.
  3. Dê à NavigationView o ID "@+id/navigation_view".
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="match_parent"
   android:layout_height="match_parent">
 <com.google.android.libraries.navigation.NavigationView
     android:id="@+id/navigation_view"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
      />
</RelativeLayout>

Configurar a atividade de navegação

No Android Studio, abra o arquivo MainActivity.kt no editor.

Adicione um código de configuração básico para garantir que a experiência de navegação funcione corretamente no app. No arquivo MainActivity.kt, faça as seguintes mudanças:

  1. Declare uma variável na classe MainActivity para referenciar o NavigationView:
private lateinit var navView: NavigationView
  1. Adicione um código ao método onCreate() para receber uma referência ao seu NavigationView:
navView = findViewById(R.id.navigation_view)
navView.onCreate(savedInstanceState)
  1. Adicione um código ao método onCreate() para garantir que a tela permaneça ligada durante a orientação de navegação:
// Ensure the screen stays on during nav.
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
  1. Edite o código que chama ViewCompat.setOnApplyWindowInsetsListener para referenciar o ID do seu NavigationView.
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.navigation_view)) { v, insets ->
  val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
  v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
  insets
}
  1. Adicione um método showToast() à classe para mostrar feedback ao usuário:
private fun showToast(errorMessage: String) {
   Toast.makeText(this@MainActivity, errorMessage, Toast.LENGTH_LONG).show()
}

7. Inicializar o SDK Navigation

Agora que você concluiu a configuração básica da atividade de navegação, é possível inicializar o SDK Navigation. Para fazer isso, adicione o seguinte código ao arquivo MainActivity.kt:

/** Starts the Navigation API, capturing a reference when ready. */
@SuppressLint("MissingPermission")
private fun initializeNavigationApi() {
   NavigationApi.getNavigator(
       this,
       object : NavigatorListener {
           override fun onNavigatorReady(navigator: Navigator) {
               // store a reference to the Navigator object
               mNavigator = navigator
               // code to start guidance will go here
           }

           override fun onError(@NavigationApi.ErrorCode errorCode: Int) {
               when (errorCode) {
                   NavigationApi.ErrorCode.NOT_AUTHORIZED -> {
                       // Note: If this message is displayed, you may need to check that
                       // your API_KEY is specified correctly in AndroidManifest.xml
                       // and is been enabled to access the Navigation API
                       showToast(
                           "Error loading Navigation API: Your API key is " +
                                   "invalid or not authorized to use Navigation."
                       )
                   }
                   NavigationApi.ErrorCode.TERMS_NOT_ACCEPTED -> {
                       showToast(
                           "Error loading Navigation API: User did not " +
                                   "accept the Navigation Terms of Use."
                       )
                   }
                   else -> showToast("Error loading Navigation API: $errorCode")
               }
           }
       },
   )

}

Esse código cria um novo método chamado initializeNavigationApi(). Esse método recebe uma referência a um objeto Navigator chamando NavigationApi.getNavigator() e implementa um NavigatorListener para processar o callback.

Observe que, quando a API Navigation é inicializada, o método NavigationListener.onNavigatorReady é invocado, com um objeto Navigator transmitido como parâmetro. O código acima vai atualizar a variável mNavigator que você declarou anteriormente com o objeto Navigator inicializado transmitido a esse método.

Por fim, adicione uma chamada ao método initializeNavigationApi do método onLocationPermissionGranted.

private fun onLocationPermissionGranted() {
   initializeNavigationApi()
}

8. Adicionar listeners para eventos principais de navegação

Quando os usuários seguem as orientações, o SDK Navigation aciona eventos que podem notificar o app sobre mudanças importantes de estado no trajeto, como quando o usuário muda a rota ou chega ao destino. No arquivo MainActivity.kt, adicione listeners para processar estes eventos:

  1. Na classe MainActivity, declare duas variáveis para se referir a objetos de listener de eventos:
private var arrivalListener: Navigator.ArrivalListener? = null
private var routeChangedListener: Navigator.RouteChangedListener? = null
  1. Adicione um método registerNavigationListeners() para configurar os listeners quando o navegador for inicializado. Esse método chama Navigator.clearDestinations() para redefinir o NavigationView quando o evento "Chegada" é acionado:
/**
* Registers a number of example event listeners that show an on screen message when certain
* navigation events occur (e.g. the driver's route changes or the destination is reached).
*/
private fun registerNavigationListeners() {
   withNavigatorAsync {
       arrivalListener =
           Navigator.ArrivalListener { // Show an onscreen message
               showToast("User has arrived at the destination!")
               mNavigator?.clearDestinations()
           }
       mNavigator?.addArrivalListener(arrivalListener)

       routeChangedListener =
           Navigator.RouteChangedListener { // Show an onscreen message when the route changes
               showToast("onRouteChanged: the driver's route changed")
           }
       mNavigator?.addRouteChangedListener(routeChangedListener)
   }
}
  1. Adicione uma chamada para registerNavigationListeners() do código de callback onNavigatorReady no método initializeNavigationApi:
override fun onNavigatorReady(navigator: Navigator) {
   // store a reference to the Navigator object
   mNavigator = navigator

   //listen for events en route
   registerNavigationListeners()


}
  1. Configure a interface do usuário. É possível controlar vários aspectos da interface do usuário de navegação quando a orientação está em execução. Uma personalização importante é a posição da câmera. Adicione uma chamada ao método setTaskRemovedBehaviour do objeto navigator retornado em onNavigatorReady da seguinte maneira. Isso encerra a orientação e a notificação se o app for deslizado para fora da tela:
// Disables the guidance notifications and shuts down the app and background service
// when the user dismisses/swipes away the app from Android's recent tasks.
navigator.setTaskRemovedBehavior(Navigator.TaskRemovedBehavior.QUIT_SERVICE)
  1. Adicione uma chamada a GoogleMap.followMyLocation para especificar um CameraPerspective. O GoogleMap é acessado pelo método NavigatorView.getMapAsync() da seguinte maneira:
navView.getMapAsync {
   googleMap  ->
   googleMap.followMyLocation(GoogleMap.CameraPerspective.TILTED)
}
  1. Para garantir que a navegação funcione sem problemas durante todo o ciclo de vida do app, implemente os seguintes métodos na classe MainActivity:
override fun onSaveInstanceState(savedInstanceState: Bundle) {
   super.onSaveInstanceState(savedInstanceState)

   navView.onSaveInstanceState(savedInstanceState)
}

override fun onTrimMemory(level: Int) {
   super.onTrimMemory(level)
   navView.onTrimMemory(level)
}

override fun onStart() {
   super.onStart()
   navView.onStart()
}

override fun onResume() {
   super.onResume()
   navView.onResume()
}

override fun onPause() {
   navView.onPause()
   super.onPause()
}

override fun onConfigurationChanged(configuration: Configuration) {
   super.onConfigurationChanged(configuration)
   navView.onConfigurationChanged(configuration)
}

override fun onStop() {
   navView.onStop()
   super.onStop()
}

override fun onDestroy() {
   navView.onDestroy()
   withNavigatorAsync {
       // Unregister event listeners to avoid memory leaks.
       if (arrivalListener != null) {
           navigator.removeArrivalListener(arrivalListener)
       }
       if (routeChangedListener != null) {
           navigator.removeRouteChangedListener(routeChangedListener)
       }

       navigator.simulator?.unsetUserLocation()
       navigator.cleanup()
   }
   super.onDestroy()
}

9. Definir um destino

Agora você já pode definir um destino e iniciar a orientação de navegação. No arquivo MainActivity.kt, faça as seguintes mudanças:

  1. Adicione um novo método navigateToPlace() que define o destino de navegação e aceita um parâmetro placeId.
/**
* Requests directions from the user's current location to a specific place (provided by the
* Place ID).
*/
private fun navigateToPlace(placeId: String) {

}
  1. No método navigateToPlace(), use o método Waypoint.builder() para criar um Waypoint do ID de lugar transmitido ao método. Lide com o UnsupportedPlaceIdException que isso pode gerar em situações em que o ID de lugar não é resolvido para um endereço preciso:
val waypoint: Waypoint? =
// Set a destination by using a Place ID (the recommended method)
try {
   Waypoint.builder().setPlaceIdString(placeId).build()
} catch (e: Waypoint.UnsupportedPlaceIdException) {
   showToast("Place ID was unsupported.")
   return
}
  1. Adicione o seguinte código ao método navigateToPlace() para definir um destino usando o ponto de referência:
val pendingRoute = mNavigator?.setDestination(waypoint)

// Set an action to perform when a route is determined to the destination
pendingRoute?.setOnResultListener { code ->
   when (code) {
       RouteStatus.OK -> {
           // Code to start guidance will go here
       }

       RouteStatus.ROUTE_CANCELED -> showToast("Route guidance canceled.")
       RouteStatus.NO_ROUTE_FOUND,
       RouteStatus.NETWORK_ERROR ->
           // TODO: Add logic to handle when a route could not be determined
           showToast("Error starting guidance: $code")

       else -> showToast("Error starting guidance: $code")
   }
}

O objeto Navigator tem um método setDestinations() que pode receber vários parâmetros. A opção mais básica é fornecer um Waypoint. O padrão é o modo de transporte DRIVING, adequado para carros de quatro rodas. O método setDestinations() retorna um objeto ListenableResultFuture que contém um objeto RouteStatus. O RouteStatus vai indicar se uma rota foi encontrada para o destino e permitir que você processe vários estados de erro, se não.

  1. Faça outras mudanças de configuração para melhorar a experiência do usuário na navegação:
// Hide the toolbar to maximize the navigation UI
supportActionBar?.hide()

// Enable voice audio guidance (through the device speaker)
mNavigator?.setAudioGuidance(Navigator.AudioGuidance.VOICE_ALERTS_AND_GUIDANCE)


// Simulate vehicle progress along the route (for demo/debug builds)
if (BuildConfig.DEBUG) {
   mNavigator?.simulator?.simulateLocationsAlongExistingRoute(
       SimulationOptions().speedMultiplier(5f)
   )
}

Essas mudanças incluem as seguintes melhorias:

  • Ocultar a barra de ações para maximizar o espaço da interface de navegação.
  • Ativar a orientação por áudio para falar alertas e instruções de navegação.
  • Configurar o simulador para depuração especificando um multiplicador de velocidade.
  1. Encontre um ID de lugar que será seu destino. O ideal é que ele não esteja muito longe da localização do usuário. Use o utilitário de pesquisa de ID de lugar da Plataforma Google Maps ou receba um ID de lugar de uma chamada de API Places.

Se você estiver simulando a navegação, poderá definir a localização do usuário no código ou usar a do dispositivo conectado. O codelab vai presumir que você está simulando um local em Londres, Reino Unido.

  1. Adicione um objeto complementar à classe MainActivity para armazenar um local de início e um ID de lugar. O codelab vai usar um local de início em Londres e o ID de lugar da Trafalgar Square:
companion object{
   const val TRAFALGAR_SQUARE ="ChIJH-tBOc4EdkgRJ8aJ8P1CUxo" //London, UK
   val startLocation = LatLng(51.345678, -0.1234456)
}
  1. Adicione uma chamada ao método navigateToPlace() do callback onNavigatorReady dentro do método initializeNavigationApi e adicione uma ramificação de lógica que será executada no modo de depuração e definirá a localização do usuário:
// Disables the guidance notifications and shuts down the app and background service
// when the user dismisses/swipes away the app from Android's recent tasks.
navigator.setTaskRemovedBehavior(Navigator.TaskRemovedBehavior.QUIT_SERVICE)

mNavigator = navigator

if (BuildConfig.DEBUG) {
   mNavigator?.simulator?.setUserLocation(MainActivity.startLocation)
}
//listen for events en route
registerNavigationListeners()

navView.getMapAsync {
   googleMap  ->
   googleMap.followMyLocation(GoogleMap.CameraPerspective.TILTED)
}

//navigate to a destination
navigateToPlace(MainActivity.TRAFALGAR_SQUARE)

10. Criar e executar o código

Na primeira vez que você executar o app, será necessário conceder permissões de localização e aceitar os Termos de Uso do SDK Navigation.

Observação: ao executar o app, o método setDestinations() é chamado, o que gera uma cobrança após os primeiros 1.000 destinos usados. Consulte Uso e faturamento para mais informações.

93aa433000a14dfc.png

A caixa de diálogo dos termos do usuário final do SDK Navigation.

Definir o local

Por padrão, o local do dispositivo emulado pode ser definido como o campus do Google em Mountain View, Califórnia, a menos que você tenha definido um local no código ou usando a caixa de diálogo de propriedades do emulador.

Se for o caso, talvez o app não consiga encontrar um trajeto até o ID do lugar configurado (por padrão, Sydney Opera House, Sydney, Austrália). Isso será indicado por uma mensagem "Nenhuma rota encontrada", exibida pelo seu método showToast().

A visualização do mapa do app Navegação mostrando o escritório do Google em Mountain View, Califórnia.

Codificação fixa do local de início

Para definir um local diferente no código, adicione a seguinte linha ao método navigateToPlace() em MainActivity.kt, antes da chamada para mNavigator.startGuidance():

mNavigator?.simulator?.setUserLocation(startLocation)

Iniciar o emulador em um local padrão de sua escolha

Para definir um local diferente no emulador de dispositivo, inicie o emulador se ele ainda não estiver em execução e clique no menu de três pontos com a dica "Controles estendidos". A caixa de diálogo aberta tem uma opção de menu para "Localização".

Por exemplo, se você estiver usando o ID de lugar da Casa de Ópera de Sydney como destino, escolha um local em Sydney, Austrália. Por exemplo, pesquise "Praia de Bondi", selecione uma sugestão e clique em "Salvar local" no canto inferior direito da caixa de diálogo. Você também pode clicar em "Salvar ponto" para adicionar o local a uma lista salva para uso futuro.

A caixa de diálogo &quot;Controles estendidos&quot; no Gerenciador de dispositivos Android, mostrando um seletor de lugar e um mapa centralizado na praia de Bondi, na Austrália.

Se você definir um ID de lugar diferente como destino, escolha um local próximo para que o trajeto simulado seja realista e não muito longo para facilitar a depuração.

Reinicie o app. Ele vai navegar até o destino.

Uma captura de tela do aplicativo de navegação fornecendo instruções para chegar ao destino.

11. Parabéns!

Você concluiu este codelab. Parabéns, você chegou ao destino! Boa programação :-)

55812f33256c0596.png

12. Como ir além

Se quiser ir além no desenvolvimento de apps, confira os tópicos a seguir para se inspirar.