Crea una semplice app di navigazione per Android con l'SDK di navigazione Google Maps Platform

1. Prima di iniziare

Questo codelab ti insegna a creare una semplice app per Android che utilizza l'SDK Navigation di Google Maps Platform per raggiungere una destinazione preconfigurata.

Ecco l'aspetto dell'app al termine.

b6c535afde7abd20.png

Prerequisiti

  • Conoscenza di base dello sviluppo di app per Android in Kotlin
  • Una certa familiarità con i concetti di base di Google Maps SDK, come mappe, località e coordinate.

Cosa imparerai a fare

  • Come creare una semplice app per Android che utilizza l'SDK Navigation per raggiungere una destinazione.
  • Come integrare l'SDK Navigation dal repository Maven remoto di Google
  • Come gestire le autorizzazioni di accesso alla posizione e il contratto con l'utente in base ai termini per l'utente finale dell'SDK Navigation
  • Come inizializzare l'SDK
  • Come impostare una destinazione e avviare le indicazioni stradali.

Che cosa ti serve

  • L'ultima versione stabile di Android Studio installata. Questo codelab è stato creato utilizzando Android Studio Jellyfish. Se utilizzi una versione diversa, l'aspetto e il layout dell'interfaccia e dei componenti potrebbero variare.
  • Un account Google e un progetto con la fatturazione abilitata.
  • Un dispositivo Android in modalità sviluppatore con il debug USB attivato o un emulatore Android. Qualunque tu scelga, deve soddisfare i requisiti minimi per l'SDK Navigation.

2. Configurazione

Se non hai ancora un account Google Cloud Platform e un progetto con la fatturazione abilitata, configura il tuo progetto Google Cloud seguendo le istruzioni per iniziare a utilizzare la piattaforma Google Maps https://developers.google.com/maps/gmp-get-started

Seleziona il tuo progetto Google Cloud nella console.

Nella console Cloud, fai clic sul menu a discesa del progetto e seleziona il progetto che vuoi utilizzare per questo codelab.

Il menu a discesa del selettore di progetti nella console Google Cloud.

Attivare l'SDK Navigation nel progetto

Abilita le API e gli SDK di Google Maps Platform richiesti per questo codelab in Google Cloud Marketplace.

Vai ad API e servizi > Libreria nella console Google Cloud e cerca "Navigation SDK".

Dovresti visualizzare un risultato di ricerca.

La schermata Libreria API nella console Google Cloud, che mostra la pagina Navigation SDK.

Fai clic sul risultato dell'SDK Navigation per aprire la pagina Dettagli prodotto. Fai clic sul pulsante Abilita per attivare l'SDK nel tuo progetto.

Ripeti questa procedura per Google Maps SDK for Android.

Crea una chiave API

Genera una chiave API nella pagina Credenziali di Cloud Console. Puoi seguire i passaggi del passaggio 3 della sezione Guida rapida in Inizia a utilizzare Google Maps Platform. Tutte le richieste a Google Maps Platform richiedono una chiave API.

3. Ottieni i file di progetto di esempio

Questa sezione descrive come configurare un progetto Android Studio vuoto di base clonando i file dal repository GitHub per questo codelab. Il repository GitHub contiene le versioni del codice del codelab prima e dopo la modifica. Il codelab inizierà con un modello di progetto vuoto e verrà creato fino allo stato finale. Se hai difficoltà, puoi utilizzare il progetto completato nel repository come riferimento.

Clona questo repository GitHub per ottenere il codice per questo codelab.

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

Se non hai installato git, fai clic su questo pulsante per ottenere il codice:

Per iniziare il più rapidamente possibile, il repository contiene del codice iniziale nella cartella Starter per aiutarti a seguire questo codelab. Il progetto iniziale fornisce una configurazione di build e un'interfaccia utente di base dell'app, ma non include l'SDK Navigation. È disponibile anche un progetto Solution completato nel caso in cui tu voglia andare avanti o controllare i tuoi progressi in qualsiasi momento.

Apri il repository clonato in Android Studio

Dopo aver clonato il repository in locale, utilizza Android Studio per aprire la cartella Starter come progetto esistente.

  1. Nella finestra di dialogo Benvenuto in Android Studio, fai clic sul pulsante Apri.
  2. Vai alla cartella in cui hai salvato il repository clonato e seleziona la cartella Starter all'interno della cartella di primo livello "codelab-navigation-101-android-kotlin".
  3. Verifica che il progetto venga compilato ed eseguito.

Aggiungere un dispositivo virtuale o collegare un dispositivo hardware

Per connettere un dispositivo Android al computer, segui le istruzioni di Android Studio su come eseguire app su un dispositivo hardware. In alternativa, puoi configurare un dispositivo virtuale utilizzando Gestione AVD (Android Virtual Device). Quando scegli un emulatore, assicurati di selezionare un'immagine che includa le API di Google.

In Android Studio, fai clic sull'opzione di menu Esegui o sull'icona del pulsante Riproduci. Scegli un dispositivo come richiesto.

4. Aggiungere l'SDK Navigation alla tua app

Aggiungi la libreria dell'SDK Navigation e la tua chiave API al progetto

Per aggiungere la libreria dell'SDK Navigation alla tua app, devi modificare il file build a livello di app build.gradle.kts per recuperare l'SDK Navigation dal repository Maven di Google e configurare un numero di versione.

Crea una variabile nella configurazione della build per archiviare il numero di versione dell'SDK Navigation.

Configura una variabile nel tuo build.gradle.kts a livello di app in modo che contenga il valore della versione di Navigation SDK utilizzata nella tua app, in modo da poter passare facilmente alla versione più recente in futuro.

Controlla le note di rilascio dell'SDK Navigation per conoscere il numero di versione più recente.

val navSdkVersion by extra("6.0.0")

Puoi anche modificare i valori di questa e di altre variabili utilizzando la finestra di dialogo disponibile in File > Struttura progetto > Variabili:

668332736b67dc82.png

Aggiungi una dipendenza alla configurazione di compilazione

Ora aggiungi la seguente dipendenza API al blocco delle dipendenze nel file build.gradle.kts. a livello di app. La versione utilizzata sarà il valore di ${navSdkVersion} che hai appena impostato nel file build.gradle.kts a livello di app:

dependencies {

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

...

Aggiungere la chiave API

Utilizza il plug-in Secrets Gradle per gestire la chiave API

Ti consigliamo di utilizzare il plug-in Secrets Gradle per gestire in modo sicuro la chiave API nella tua app. Il plug-in è stato aggiunto al modello di progetto iniziale come dipendenza nel file build.gradle.kts di primo livello.

// 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
}

Apri il file secrets.properties nella directory di primo livello e sostituisci YOUR_API_KEY con la tua chiave API. Memorizza la chiave in questo file perché secrets.properties è escluso dal controllo in un sistema di controllo delle versioni.

MAPS_API_KEY=YOUR_API_KEY

Per saperne di più su questo argomento, consulta Aggiungere la chiave API all'app nella documentazione dell'SDK Navigation.

Verifica i contenuti di local.defaults.properties

Il progetto vuoto contiene anche un file local.defaults.properties nella directory di primo livello, la stessa cartella del file secrets.properties. Apri il file e osserva il codice seguente.

MAPS_API_KEY=DEFAULT_API_KEY

Esiste per fornire un valore di backup per la proprietà MAPS_API_KEY nel caso in cui secrets.properties non venga aggiunto al progetto, in modo che le build non non vadano in errore. Non è necessario modificare questo file. Se la definizione di secrets.properties di MAPS_API_KEY non viene trovata, il valore predefinito interromperà l'esecuzione dell'app in fase di runtime, con un errore della chiave API.

Verifica che il file manifest di Android utilizzi la chiave API che hai specificato

Apri app/src/main/AndroidManifest.xml. Noterai che la proprietà MAPS_API_KEY viene utilizzata per impostare la chiave API per l'applicazione:

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

Apri il file build.gradle.kts a livello di app e trova la proprietà secrets.

L'impostazione propertiesFileName del plug-in deve essere impostata su secrets.properties e defaultPropertiesFileName deve essere impostato su 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"
}

Salva tutti i file e sincronizza il progetto con Gradle.

5. Configurare le autorizzazioni dell'app e aggiungere un'interfaccia utente di base

Richiedere l'autorizzazione di accesso alla posizione esatta

L'SDK Navigation dipende dai segnali GPS per funzionare, quindi la tua app dovrà chiedere all'utente di concedere l'accesso ai dati di geolocalizzazione esatti. Aggiungi l'autorizzazione per accedere alla posizione esatta come elemento secondario dell'elemento <manifest> in 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>

Puoi scoprire di più sulle autorizzazioni di accesso alla posizione di Android nella sezione Richiedere autorizzazioni di accesso alla posizione della documentazione per gli sviluppatori Android.

Per eseguire l'app su un dispositivo Android 14, richiedi l'autorizzazione di accesso alla posizione del servizio in primo piano aggiungendo il seguente tag uses-permission nella stessa posizione dell'autorizzazione di accesso alla posizione esatta:

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

Aggiungere un'attività di avvio con una UI di base

Quando la tua app viene eseguita, avrà bisogno di codice che viene eseguito all'avvio per verificare se l'utente ha concesso l'autorizzazione ad accedere alla sua posizione e gestire ogni possibile scenario, richiedendo l'autorizzazione se non è ancora stata concessa. Per farlo, aggiungi un'interfaccia utente di base alla tua app. Questo codelab utilizza l'interfaccia utente creata quando crei una nuova attività Views vuota in Android Studio. Adatterai questo codice per eseguire il controllo dell'autorizzazione di accesso alla posizione prima di aggiungere il codice all'attività per la UI di navigazione.

Apri il file MainActivity.kt nell'editor di codice e controlla il codice, che mostra una UI di base.

Richiedere le autorizzazioni di accesso alla posizione in fase di runtime

La tua app dovrà attivare la richiesta di accesso alla posizione esatta prima dell'inizializzazione dell'SDK Navigation.

Per assicurarti che questo controllo venga eseguito all'avvio dell'app, aggiungi del codice alla classe MainActivity, nel metodo onCreate() sottoposto a override dell'attività.

Il seguente codice verifica se l'utente ha concesso l'autorizzazione di accesso alla posizione esatta. In caso contrario, richiede l'autorizzazione. Aggiungi questo codice all'interno del metodo 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

Aggiungi una nuova funzione alla classe MainActivity, chiamata onLocationPermissionGranted, che gestirà il risultato quando l'utente concede l'autorizzazione a condividere la propria posizione. Nei passaggi successivi aggiungeremo qui il codice per avviare una nuova attività di navigazione.

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

Crea il tuo progetto. Se si verificano errori di compilazione, trovali e correggili.

Esegui il progetto su un nuovo dispositivo virtuale. Dovresti visualizzare la finestra di dialogo di richiesta di autorizzazione quando l'app viene installata e avviata.

6. Aggiungere un'interfaccia utente di navigazione

Esistono due modi per aggiungere un'interfaccia utente di navigazione: SupportNavigationFragment o NavigationView.

Per semplicità, il codelab utilizza un NavigationView.

Modificare il layout

Modifica res/layout/activity_main.xml per aggiungere un layout per un NavigationView.

  1. Apri il file e passa alla Vista codice.
  2. Sostituisci l'intero contenuto del file con un nuovo layout di un NavigationView all'interno di un RelativeLayout, come nell'esempio seguente. Poiché aggiungerai solo una visualizzazione di navigazione all'app, un layout semplice sarà sufficiente.
  3. Assegna a NavigationView un 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>

Configurare l'attività di navigazione

In Android Studio, apri il file MainActivity.kt nell'editor.

Aggiungi del codice di configurazione di base per assicurarti che l'esperienza di navigazione funzioni correttamente nella tua app. Nel file MainActivity.kt, apporta le seguenti modifiche:

  1. Dichiara una variabile nella classe MainActivity per fare riferimento a NavigationView:
private lateinit var navView: NavigationView
  1. Aggiungi del codice al metodo onCreate() per ottenere un riferimento a NavigationView:
navView = findViewById(R.id.navigation_view)
navView.onCreate(savedInstanceState)
  1. Aggiungi del codice al metodo onCreate() per assicurarti che lo schermo rimanga acceso durante le indicazioni stradali:
// Ensure the screen stays on during nav.
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
  1. Modifica il codice che chiama ViewCompat.setOnApplyWindowInsetsListener per fare riferimento all'ID del tuo 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. Aggiungi un metodo showToast() alla classe per mostrare il feedback all'utente:
private fun showToast(errorMessage: String) {
   Toast.makeText(this@MainActivity, errorMessage, Toast.LENGTH_LONG).show()
}

7. Inizializza l'SDK Navigation

Ora che hai completato la configurazione di base dell'attività di navigazione, puoi inizializzare l'SDK Navigation. Per farlo, aggiungi il seguente codice al file 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")
               }
           }
       },
   )

}

Questo codice crea un nuovo metodo denominato initializeNavigationApi(). Questo metodo ottiene un riferimento a un oggetto Navigator chiamando NavigationApi.getNavigator() e implementa un NavigatorListener per gestire il callback.

Tieni presente che quando viene inizializzata l'API Navigation, viene richiamato il metodo NavigationListener.onNavigatorReady, con un oggetto Navigator passato come parametro. Il codice riportato sopra aggiornerà la variabile mNavigator dichiarata in precedenza con l'oggetto Navigator inizializzato passato a questo metodo.

Infine, aggiungi una chiamata al metodo initializeNavigationApi dal metodo onLocationPermissionGranted.

private fun onLocationPermissionGranted() {
   initializeNavigationApi()
}

8. Aggiungere listener per gli eventi di navigazione chiave

Quando gli utenti seguono le indicazioni, l'SDK Navigation attiva eventi che possono notificare all'app le modifiche chiave dello stato durante il percorso, ad esempio quando l'utente cambia percorso o arriva a destinazione. Nel file MainActivity.kt, aggiungi i listener per gestire questi eventi:

  1. All'interno della classe MainActivity, dichiara due variabili per fare riferimento agli oggetti listener di eventi:
private var arrivalListener: Navigator.ArrivalListener? = null
private var routeChangedListener: Navigator.RouteChangedListener? = null
  1. Aggiungi un metodo registerNavigationListeners() per configurare i listener all'inizializzazione di Navigator. Questo metodo chiama Navigator.clearDestinations() per reimpostare NavigationView quando viene attivato l'evento Arrival:
/**
* 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. Aggiungi una chiamata a registerNavigationListeners() dal codice di callback onNavigatorReady nel metodo initializeNavigationApi:
override fun onNavigatorReady(navigator: Navigator) {
   // store a reference to the Navigator object
   mNavigator = navigator

   //listen for events en route
   registerNavigationListeners()


}
  1. Configura l'interfaccia utente. Puoi controllare vari aspetti dell'interfaccia utente di navigazione durante l'esecuzione della guida. Una personalizzazione importante è la posizione della videocamera. Aggiungi una chiamata al metodo setTaskRemovedBehaviour dell'oggetto navigator restituito in onNavigatorReady nel seguente modo. Se l'app viene chiusa, la guida e le notifiche verranno interrotte:
// 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. Aggiungi una chiamata a GoogleMap.followMyLocation per specificare un CameraPerspective. Si accede a GoogleMap tramite il metodo NavigatorView.getMapAsync() come segue:
navView.getMapAsync {
   googleMap  ->
   googleMap.followMyLocation(GoogleMap.CameraPerspective.TILTED)
}
  1. Per garantire che la navigazione funzioni senza problemi durante il ciclo di vita dell'app, implementa i seguenti metodi nella 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. Impostare una destinazione

Ora puoi impostare una destinazione e avviare le indicazioni stradali. Nel file MainActivity.kt, apporta le seguenti modifiche:

  1. Aggiungi un nuovo metodo navigateToPlace() che imposta la destinazione di navigazione e accetta un parametro placeId.
/**
* Requests directions from the user's current location to a specific place (provided by the
* Place ID).
*/
private fun navigateToPlace(placeId: String) {

}
  1. Nel metodo navigateToPlace(), utilizza il metodo Waypoint.builder() per creare un Waypoint dall'ID luogo passato al metodo. Gestisci l'UnsupportedPlaceIdException che può essere generato, per le situazioni in cui l'ID luogo non corrisponde a un indirizzo 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. Aggiungi il seguente codice al metodo navigateToPlace() per impostare una destinazione utilizzando il waypoint:
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")
   }
}

L'oggetto Navigator ha un metodo setDestinations() che può accettare una serie di parametri. L'opzione più semplice è fornire un Waypoint. La modalità di viaggio predefinita sarà DRIVING, adatta alle auto a quattro ruote. Il metodo setDestinations() restituisce un oggetto ListenableResultFuture contenente un oggetto RouteStatus. Il RouteStatus indicherà se è stato trovato un percorso per la destinazione e ti consentirà di gestire vari stati di errore in caso contrario.

  1. Apporta modifiche di configurazione aggiuntive per migliorare l'esperienza utente di navigazione:
// 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)
   )
}

Queste modifiche includono i seguenti miglioramenti:

  • Nascondere la barra delle azioni per massimizzare lo spazio per la UI di navigazione.
  • Attivazione della guida audio per la lettura di avvisi e istruzioni di navigazione.
  • Configurazione del simulatore per il debug specificando un moltiplicatore di velocità.
  1. Trova un ID luogo che fungerà da destinazione. Idealmente, non dovrebbe essere troppo lontano dalla posizione dell'utente. Utilizza l'utilità di ricerca dell'ID luogo di Google Maps Platform o ottieni un ID luogo da una chiamata all'API Places.

Se stai simulando la navigazione, puoi impostare la posizione dell'utente nel codice o prelevarla dal dispositivo connesso. Il codelab presuppone che tu stia simulando una posizione a Londra, nel Regno Unito.

  1. Aggiungi un oggetto companion alla classe MainActivity per memorizzare una posizione iniziale e un ID luogo. Il codelab utilizzerà una posizione iniziale a Londra e l'ID luogo di Trafalgar Square:
companion object{
   const val TRAFALGAR_SQUARE ="ChIJH-tBOc4EdkgRJ8aJ8P1CUxo" //London, UK
   val startLocation = LatLng(51.345678, -0.1234456)
}
  1. Aggiungi una chiamata al metodo navigateToPlace() dal callback onNavigatorReady all'interno del metodo initializeNavigationApi e aggiungi un ramo della logica che verrà eseguito in modalità di debug, che imposta la posizione dell'utente:
// 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. Crea ed esegui il codice

La prima volta che esegui l'app, devi concedere le autorizzazioni di accesso alla posizione e accettare i termini di servizio dell'SDK Navigation.

Nota: l'esecuzione dell'app chiamerà il metodo setDestinations(), che comporta un addebito dopo le prime 1000 destinazioni utilizzate. Per ulteriori informazioni, vedi Utilizzo e fatturazione.

93aa433000a14dfc.png

La finestra di dialogo dei termini per l&#39;utente finale dell&#39;SDK Navigation.

Impostare la posizione

Per impostazione predefinita, la posizione del dispositivo emulato potrebbe essere impostata sul campus di Google a Mountain View, in California, a meno che tu non abbia impostato una posizione nel codice o utilizzando la finestra di dialogo delle proprietà dell'emulatore.

In questo caso, potresti scoprire che l'app non riesce a trovare un percorso per l'ID luogo che hai configurato (per impostazione predefinita, la Sydney Opera House, Sydney, Australia). Ciò verrà indicato da un messaggio che indica "Nessun percorso trovato", visualizzato dal tuo metodo showToast().

La visualizzazione della mappa dell&#39;app Navigazione che mostra l&#39;ufficio Google a Mountain View, in California.

Codifica hardcoded della posizione di partenza

Per impostare una posizione diversa nel codice, aggiungi la seguente riga nel metodo navigateToPlace() in MainActivity.kt, prima della chiamata a mNavigator.startGuidance():

mNavigator?.simulator?.setUserLocation(startLocation)

Avviare l'emulatore in una posizione predefinita a tua scelta

Per impostare una posizione diversa nell'emulatore di dispositivi, avvialo se non è già in esecuzione e fai clic sul menu con tre puntini con la descrizione comando "Controlli estesi". La finestra di dialogo che si apre include un'opzione di menu per la "Posizione".

Ad esempio, se utilizzi l'ID luogo della Sydney Opera House come destinazione, scegli una località a Sydney, in Australia. Ad esempio, cerca "Spiaggia di Bondi", seleziona un suggerimento e fai clic su "Salva posizione" in basso a destra nella finestra di dialogo. Puoi anche fare clic su "Salva punto" per aggiungere la posizione a un elenco salvato per utilizzarla in futuro.

La finestra di dialogo Controlli estesi in Android Device Manager, che mostra un selettore di luoghi e una mappa centrata sulla spiaggia di Bondi in Australia.

Se imposti un ID luogo diverso come destinazione, scegli una posizione vicina in modo che l'itinerario simulato sia realistico e non troppo lungo per facilitare il debug.

Riavvia l'app e ora dovrebbe navigare verso la destinazione.

Uno screenshot dell&#39;app di navigazione che fornisce indicazioni per la destinazione.

11. Complimenti!

Hai completato questo codelab. Ben fatto, hai raggiunto la tua destinazione. Buona programmazione :-)

55812f33256c0596.png

12. Vuoi di più?

Se vuoi sviluppare ulteriormente la tua app, dai un'occhiata agli argomenti riportati di seguito per trovare ispirazione.