Einfache Android-Navigations-App mit dem Google Maps Platform Navigation SDK erstellen

1. Vorbereitung

In diesem Codelab erfahren Sie, wie Sie eine einfache Android-App erstellen, die mit dem Navigation SDK von Google Maps Platform zu einem vorkonfigurierten Ziel führt.

So sollte Ihre App dann aussehen.

b6c535afde7abd20.png

Voraussetzungen

  • Grundkenntnisse der Entwicklung von Android-Apps in Kotlin
  • Grundlegende Kenntnisse der grundlegenden Konzepte des Google Maps SDK wie Karten, Orte und Koordinaten

Aufgaben in diesem Lab

  • Anleitung zum Erstellen einer einfachen Android-App, die mithilfe des Navigation SDK zu einem Ziel navigiert
  • Navigation SDK aus dem Remote-Maven-Repository von Google einbinden
  • Standortberechtigungen und Nutzervereinbarung mit den Nutzungsbedingungen für das Navigation SDK verwalten
  • SDK initialisieren
  • So legen Sie ein Ziel fest und starten die Navigation.

Voraussetzungen

  • Die neueste stabile Version von Android Studio ist installiert. Dieses Codelab wurde mit Android Studio Jellyfish erstellt. Wenn Sie eine andere Version verwenden, können Aussehen und Layout der Benutzeroberfläche und der Komponenten variieren.
  • Ein Google-Konto und ein Projekt mit aktivierter Abrechnung.
  • Ein Android-Gerät im Entwicklermodus mit aktiviertem USB-Debugging oder ein Android-Emulator Die von Ihnen ausgewählte Version muss die Mindestanforderungen für das Navigation SDK erfüllen.

2. Einrichten

Falls Sie noch kein Google Cloud Platform-Konto und noch kein Projekt mit aktivierter Abrechnung haben, richten Sie Ihr Google Cloud-Projekt ein. Folgen Sie dazu der Anleitung für die ersten Schritte mit der Google Maps Platform: https://developers.google.com/maps/gmp-get-started.

Wählen Sie Ihr Google Cloud-Projekt in der Console aus.

Klicken Sie in der Cloud Console auf das Drop-down-Menü „Projekt“ und wählen Sie das Projekt aus, das Sie für dieses Codelab verwenden möchten.

Das Drop-down-Menü für die Projektauswahl in der Google Cloud Console.

Aktivieren Sie das Navigation SDK in Ihrem Projekt.

Aktivieren Sie die für dieses Codelab erforderlichen Google Maps Platform APIs und SDKs im Google Cloud Marketplace.

Gehen Sie in der Google Cloud Console zu „APIs und Dienste“ > „Bibliothek“ und suchen Sie nach „Navigation SDK“.

Es sollte ein Suchergebnis angezeigt werden.

Der Bildschirm „API-Bibliothek“ in der Google Cloud Console mit der Seite „Navigation SDK“.

Klicken Sie auf das Navigation SDK-Ergebnis, um die Seite mit den Produktdetails zu öffnen. Klicken Sie auf die Schaltfläche „Aktivieren“, um das SDK für Ihr Projekt zu aktivieren.

Wiederholen Sie diesen Vorgang für das Google Maps SDK for Android.

API-Schlüssel erstellen

Generieren Sie in der Cloud Console auf der Seite Anmeldedaten einen API-Schlüssel. Sie können der Anleitung in Schritt 3 der Kurzanleitung unter Erste Schritte mit der Google Maps Platform folgen. Für alle Anfragen an die Google Maps Platform ist ein API-Schlüssel erforderlich.

3. Beispielprojektdateien abrufen

In diesem Abschnitt wird beschrieben, wie Sie ein einfaches leeres Android Studio-Projekt einrichten, indem Sie Dateien aus dem GitHub-Repository für dieses Codelab klonen. Das GitHub-Repository enthält Vorher- und Nachher-Versionen des Codelab-Codes. Das Codelab beginnt mit einer leeren Projektvorlage und führt Sie bis zum fertigen Zustand. Sie können das abgeschlossene Projekt im Repository als Referenz verwenden, falls Sie nicht weiterkommen.

Klonen Sie dieses GitHub-Repository, um den Code für dieses Codelab abzurufen.

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

Wenn Git nicht installiert ist, klicken Sie auf diese Schaltfläche, um den Code abzurufen:

Damit Sie so schnell wie möglich loslegen können, enthält das Repository im Ordner Starter Startcode, mit dem Sie dieses Codelab ausführen können. Das Starterprojekt bietet eine grundlegende App-Benutzeroberfläche und Build-Konfiguration, aber es ist kein Navigations-SDK hinzugefügt. Es gibt auch ein fertiges Solution-Projekt, falls Sie vorspringen oder Ihren Fortschritt jederzeit prüfen möchten.

Geklontes Repository in Android Studio öffnen

Nachdem Sie das Repository lokal geklont haben, öffnen Sie den Ordner Starter in Android Studio als vorhandenes Projekt.

  1. Klicken Sie im Dialogfeld „Willkommen bei Android Studio“ auf die Schaltfläche „Open“ (Öffnen).
  2. Rufen Sie den Ordner auf, in dem Sie das geklonte Repository gespeichert haben, und wählen Sie auf der obersten Ebene „codelab-navigation-101-android-kotlin“ den Ordner Starter aus Ordner.
  3. Prüfen Sie, ob das Projekt erstellt und ausgeführt wird.

Virtuelles Gerät hinzufügen oder Hardwaregerät verbinden

Wenn Sie ein Android-Gerät mit Ihrem Computer verbinden möchten, folgen Sie der Anleitung in Android Studio zum Ausführen von Apps auf einem Hardwaregerät. Alternativ können Sie ein virtuelles Gerät mit dem Android Virtual Device (AVD) Manager konfigurieren. Beim Auswählen eines Emulators sollten Sie ein Image angeben, das die Google-APIs enthält.

Klicken Sie in Android Studio auf die Menüoption Run oder das Wiedergabesymbol. Wählen Sie ein Gerät aus, wenn Sie dazu aufgefordert werden.

4. Fügen Sie Ihrer App das Navigation SDK hinzu.

Fügen Sie Ihrem Projekt die Navigation SDK-Bibliothek und Ihren API-Schlüssel hinzu.

Wenn Sie Ihrer App die Navigation SDK-Bibliothek hinzufügen möchten, müssen Sie build.gradle.kts auf App-Ebene ändern, um das Navigation SDK aus dem Google Maven-Repository abzurufen und eine Versionsnummer zu konfigurieren.

Erstellen Sie in Ihrer Build-Konfiguration eine Variable, um die Versionsnummer des Navigation SDK zu speichern.

Richten Sie eine Variable in build.gradle.kts auf App-Ebene ein, die den Wert der Version des Navigation SDK enthält, die in Ihrer App verwendet wird. So können Sie später einfach zur neuesten Version wechseln.

Die aktuelle Versionsnummer finden Sie in den Versionshinweisen zum Navigation SDK.

val navSdkVersion by extra("6.0.0")

Sie können die Werte dieser und anderer Variablen auch über das Dialogfeld unter „File > Projektstruktur > Variablen:

668332736b67dc82.png

Abhängigkeit zur Build-Konfiguration hinzufügen

Fügen Sie dem Abhängigkeitsblock in der Datei build.gradle.kts. auf App-Ebene die folgende API-Abhängigkeit hinzu. Als Version wird der Wert von ${navSdkVersion} verwendet, den Sie gerade in der Datei build.gradle.kts auf App-Ebene festgelegt haben:

dependencies {

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

...

API-Schlüssel hinzufügen

API-Schlüssel mit dem Secrets Gradle-Plug-in verwalten

Wir empfehlen, das Secrets Gradle-Plug-in zu verwenden, um den API-Schlüssel in Ihrer App sicher zu verwalten. Das Plug-in wurde der ursprünglichen Projektvorlage als Abhängigkeit in der obersten build.gradle.kts-Datei hinzugefügt.

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

Öffnen Sie die Datei secrets.properties im Verzeichnis der obersten Ebene und ersetzen Sie YOUR_API_KEY durch Ihren API-Schlüssel. Speichern Sie den Schlüssel in dieser Datei, da secrets.properties nicht in ein Versionsverwaltungssystem eingecheckt werden kann.

MAPS_API_KEY=YOUR_API_KEY

Weitere Informationen zu diesem Thema finden Sie in der Navigation SDK-Dokumentation unter API-Schlüssel zur App hinzufügen.

Inhalt von „local.defaults.properties“ prüfen

Das leere Projekt enthält auch eine local.defaults.properties-Datei im Verzeichnis der obersten Ebene, im selben Ordner wie die secrets.properties-Datei. Öffnen Sie es und sehen Sie sich den folgenden Code an.

MAPS_API_KEY=DEFAULT_API_KEY

Dieser Wert dient als Ersatzwert für die Property MAPS_API_KEY, falls secrets.properties dem Projekt nicht hinzugefügt wird, damit Builds nicht fehlschlagen. Diese Datei muss nicht bearbeitet werden. Wenn die secrets.properties-Definition von MAPS_API_KEY nicht gefunden wird, wird die App bei der Laufzeit aufgrund des Standardwerts mit einem API-Schlüsselfehler beendet.

Prüfen, ob das Android-Manifest den von Ihnen angegebenen API-Schlüssel verwendet

Öffnen Sie „app/src/main/AndroidManifest.xml“. Wie Sie sehen, wird das Attribut MAPS_API_KEY verwendet, um den API-Schlüssel für die Anwendung festzulegen:

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

Öffne die Datei build.gradle.kts auf App-Ebene und suche nach dem Attribut secrets.

Die Einstellung propertiesFileName des Plug-ins sollte auf secrets.properties und defaultPropertiesFileName auf local.defaults.properties festgelegt sein.

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

Speichere alle Dateien und synchronisiere dein Projekt mit Gradle.

5. App-Berechtigungen konfigurieren und eine einfache Benutzeroberfläche hinzufügen

Berechtigung zur genauen Standortermittlung anfordern

Das Navigations-SDK benötigt GPS-Signale, um zu funktionieren. Ihre App muss den Nutzer daher um Zugriff auf genaue Standortdaten bitten. Fügen Sie die Berechtigung für den Zugriff auf den genauen Standort als untergeordnetes Element des Elements <manifest> in der Datei „AndroidManifest.xml“ hinzu.

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

Weitere Informationen zu Android-Standortberechtigungen finden Sie in der Android-Entwicklerdokumentation im Abschnitt Standortberechtigungen anfordern.

Wenn Sie Ihre App auf einem Android 14-Gerät ausführen möchten, fordern Sie die Berechtigung zur Standortermittlung für Dienste im Vordergrund an. Fügen Sie dazu das folgende uses-permission-Tag an derselben Position wie die Berechtigung für den Zugriff auf genauen Standort ein:

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

Startaktivität mit einer einfachen Benutzeroberfläche hinzufügen

Wenn Ihre App ausgeführt wird, benötigt sie Code, der beim Start ausgeführt wird, um zu prüfen, ob der Nutzer die Berechtigung für den Zugriff auf seinen Standort erteilt hat, und um jedes mögliche Szenario zu bearbeiten und um eine Berechtigung anzufordern, falls diese noch nicht erteilt wurde. Fügen Sie dazu eine einfache Benutzeroberfläche zu Ihrer App hinzu. In diesem Codelab wird die UI verwendet, die beim Erstellen einer neuen, leeren Views-Aktivität in Android Studio erstellt wird. Sie passen diesen Code so an, dass die Berechtigung zur Standortermittlung geprüft wird, bevor der Aktivität Code für die Navigations-UI hinzugefügt wird.

Öffnen Sie die Datei MainActivity.kt im Code-Editor und sehen Sie sich den Code an, der eine einfache Benutzeroberfläche zeigt.

Berechtigungen für den Standortzugriff zur Laufzeit anfordern

Ihre App muss die Anfrage für den Zugriff auf den genauen Standort auslösen, bevor das Navigation SDK initialisiert wird.

Damit diese Prüfung beim Starten Ihrer App erfolgt, fügen Sie der MainActivity-Klasse in der überschriebenen onCreate()-Methode Ihrer Aktivität Code hinzu.

Mit dem folgenden Code wird geprüft, ob der Nutzer eine gültige Berechtigung zur Standortermittlung erteilt hat. Falls nicht, wird die Berechtigung angefordert. Fügen Sie diesen Code in die Methode onCreate() ein.

    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

Fügen Sie der MainActivity-Klasse eine neue Funktion namens onLocationPermissionGranted hinzu, die das Ergebnis verarbeitet, wenn der Nutzer die Berechtigung zum Teilen seines Standorts erteilt. In den nächsten Schritten fügen wir hier Code hinzu, um eine neue Navigationsaktivität zu starten.

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

Erstellen Sie Ihr Projekt. Ermitteln und beheben Sie Build-Fehler.

Führen Sie Ihr Projekt auf einem neuen virtuellen Gerät aus. Das Dialogfeld für die Berechtigungsanfrage sollte angezeigt werden, wenn die App installiert und gestartet wird.

6. Navigationsbenutzeroberfläche hinzufügen

Es gibt zwei Möglichkeiten, eine Navigations-UI hinzuzufügen: SupportNavigationFragment oder NavigationView.

Der Einfachheit halber wird im Codelab eine NavigationView verwendet.

Layout bearbeiten

Bearbeiten Sie res/layout/activity_main.xml, um ein Layout für „NavigationView“ hinzuzufügen.

  1. Öffnen Sie die Datei und wechseln Sie zur Codeansicht.
  2. Ersetzen Sie den gesamten Inhalt der Datei durch ein neues Layout einer NavigationView in einem RelativeLayout wie im Beispiel unten. Da Sie der App nur eine Navigationsansicht hinzufügen, reicht ein einfaches Layout.
  3. Geben Sie Ihrer NavigationView die 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>

Aktivität „Navigation“ einrichten

Öffnen Sie in Android Studio die Datei „MainActivity.kt“ im Editor.

Fügen Sie einige grundlegenden Einrichtungscode hinzu, damit die Navigation in Ihrer App korrekt funktioniert. Nehmen Sie in der Datei MainActivity.kt die folgenden Änderungen vor:

  1. Deklarieren Sie eine Variable in Ihrer MainActivity-Klasse, um auf Ihr NavigationView zu verweisen:
private lateinit var navView: NavigationView
  1. Fügen Sie der Methode onCreate() Code hinzu, um einen Verweis auf die NavigationView zu erhalten:
navView = findViewById(R.id.navigation_view)
navView.onCreate(savedInstanceState)
  1. Fügen Sie der Methode onCreate() Code hinzu, damit der Bildschirm während der Navigation aktiviert bleibt:
// Ensure the screen stays on during nav.
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
  1. Bearbeiten Sie den Code, der ViewCompat.setOnApplyWindowInsetsListener aufruft, um auf die ID Ihres NavigationView zu verweisen.
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. Fügen Sie der Klasse eine showToast()-Methode hinzu, um dem Nutzer Feedback zu geben:
private fun showToast(errorMessage: String) {
   Toast.makeText(this@MainActivity, errorMessage, Toast.LENGTH_LONG).show()
}

7. Navigation SDK initialisieren

Nachdem Sie die grundlegende Einrichtung der Navigationsaktivität abgeschlossen haben, können Sie das Navigations-SDK initialisieren. Fügen Sie dazu den folgenden Code in die Datei MainActivity.kt ein:

/** 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")
               }
           }
       },
   )

}

Mit diesem Code wird eine neue Methode namens initializeNavigationApi() erstellt. Diese Methode ruft einen Verweis auf ein Navigator-Objekt ab, indem sie NavigationApi.getNavigator() aufruft, und implementiert eine NavigatorListener, um den Callback zu verarbeiten.

Wenn die Navigation API initialisiert wird, wird die Methode NavigationListener.onNavigatorReady aufgerufen. Dabei wird ein Navigator-Objekt als Parameter übergeben. Der obige Code aktualisiert die zuvor deklarierte Variable mNavigator mit dem initialisierten Navigator-Objekt, das an diese Methode übergeben wird.

Fügen Sie abschließend einen Aufruf aus der Methode onLocationPermissionGranted der Methode initializeNavigationApi hinzu.

private fun onLocationPermissionGranted() {
   initializeNavigationApi()
}

8. Listener für wichtige Navigationsereignisse hinzufügen

Wenn Ihre Nutzer der Anleitung folgen, löst das Navigation SDK Ereignisse aus, durch die die App über wichtige Änderungen des Schlüsselstatus informiert wird, z. B. wenn der Nutzer das Ziel umleitet oder erreicht. Fügen Sie in der Datei „MainActivity.kt“ Listener zum Bearbeiten dieser Ereignisse hinzu:

  1. Deklarieren Sie innerhalb der MainActivity-Klasse zwei Variablen, die auf Event-Listener-Objekte verweisen:
private var arrivalListener: Navigator.ArrivalListener? = null
private var routeChangedListener: Navigator.RouteChangedListener? = null
  1. Fügen Sie eine registerNavigationListeners()-Methode hinzu, um die Listener beim Initialisieren des Navigationssystems einzurichten. Diese Methode ruft Navigator.clearDestinations() auf, um NavigationView zurückzusetzen, wenn das Ereignis „Ankunft“ ausgelöst wird:
/**
* 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. Fügen Sie einen Aufruf von registerNavigationListeners() aus dem Callback-Code onNavigatorReady in der Methode initializeNavigationApi hinzu:
override fun onNavigatorReady(navigator: Navigator) {
   // store a reference to the Navigator object
   mNavigator = navigator

   //listen for events en route
   registerNavigationListeners()


}
  1. Konfigurieren Sie die Benutzeroberfläche. Sie können verschiedene Aspekte der Navigationsbenutzeroberfläche festlegen, wenn die Navigation aktiv ist. Eine wichtige Anpassung ist die Kameraposition. Fügen Sie der Methode setTaskRemovedBehaviour des in onNavigatorReady zurückgegebenen navigator-Objekts einen Aufruf hinzu. Dadurch werden die Navigation und Benachrichtigung beendet, wenn die App weggewischt wird:
// 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. Fügen Sie einen Aufruf zu GoogleMap.followMyLocation hinzu, um einen CameraPerspective anzugeben. Der Zugriff auf GoogleMap erfolgt über die Methode NavigatorView.getMapAsync():
navView.getMapAsync {
   googleMap  ->
   googleMap.followMyLocation(GoogleMap.CameraPerspective.TILTED)
}
  1. Damit die Navigation während des gesamten App-Lebenszyklus reibungslos funktioniert, solltest du die folgenden Methoden in deiner MainActivity-Klasse implementieren:
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. Ziel festlegen

Sie können jetzt ein Ziel festlegen und die Navigation starten. Nehmen Sie in der Datei „MainActivity.kt“ die folgenden Änderungen vor:

  1. Fügen Sie eine neue navigateToPlace()-Methode hinzu, die das Navigationsziel festlegt und einen placeId-Parameter akzeptiert.
/**
* Requests directions from the user's current location to a specific place (provided by the
* Place ID).
*/
private fun navigateToPlace(placeId: String) {

}
  1. Verwenden Sie in Ihrer navigateToPlace()-Methode die Waypoint.builder()-Methode, um eine Waypoint aus der an die Methode übergebenen Orts-ID zu erstellen. Wenn die Orts-ID nicht zu einer genauen Adresse aufgelöst werden kann, kann die folgende UnsupportedPlaceIdException-Meldung ausgegeben werden:
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. Fügen Sie der navigateToPlace()-Methode den folgenden Code hinzu, um mithilfe des Wegpunkts ein Ziel festzulegen:
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")
   }
}

Das Navigator-Objekt hat eine setDestinations()-Methode, die eine Vielzahl von Parametern annehmen kann. Die einfachste Option ist die Angabe eines Waypoint. Standardmäßig wird der Mobilitätsmodus DRIVING verwendet, der für vierrädrige Autos geeignet ist. Die Methode setDestinations() gibt ein ListenableResultFuture-Objekt zurück, das ein RouteStatus-Objekt enthält. RouteStatus gibt an, ob eine Route zum Ziel gefunden wurde. Falls nicht, können Sie verschiedene Fehlerstatus verarbeiten.

  1. Nehmen Sie weitere Konfigurationsänderungen vor, um die Nutzerfreundlichkeit der Navigation zu verbessern:
// 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)
   )
}

Diese Änderungen umfassen folgende Verbesserungen:

  • Die Aktionsleiste wird ausgeblendet, um mehr Platz für die Navigations-UI zu schaffen.
  • Aktivieren der Sprachnavigation, um Benachrichtigungen und Navigationsanweisungen vorzulesen.
  • Sie können den Simulator für die Fehlerbehebung einrichten, indem Sie einen Geschwindigkeitsmultiplikator angeben.
  1. Suchen Sie eine Orts-ID, die als Ziel dienen soll. Idealerweise sollte dieser nicht zu weit vom Standort des Nutzers entfernt sein. Verwenden Sie das Dienstprogramm „Place ID Finder“ der Google Maps Platform oder rufen Sie eine Orts-ID über einen Places API-Aufruf ab.

Wenn Sie die Navigation simulieren, können Sie den Nutzerstandort im Code festlegen oder von Ihrem verbundenen Gerät übernehmen. In diesem Codelab wird davon ausgegangen, dass Sie einen Standort in London, Vereinigtes Königreich, simulieren.

  1. Fügen Sie Ihrer MainActivity-Klasse ein Begleitobjekt hinzu, um einen Startort und eine Orts-ID zu speichern. Im Codelab wird ein Startort in London und die Orts-ID des Trafalgar Square verwendet:
companion object{
   const val TRAFALGAR_SQUARE ="ChIJH-tBOc4EdkgRJ8aJ8P1CUxo" //London, UK
   val startLocation = LatLng(51.345678, -0.1234456)
}
  1. Fügen Sie in der Methode initializeNavigationApi einen Aufruf der Methode navigateToPlace() über den onNavigatorReady-Callback hinzu und fügen Sie einen Logikzweig hinzu, der im Debug-Modus ausgeführt wird und den Nutzerstandort festlegt:
// 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. Code erstellen und ausführen

Wenn Sie die App zum ersten Mal ausführen, müssen Sie der App Berechtigungen zur Standortermittlung erteilen und die Nutzungsbedingungen des Navigation SDKs akzeptieren.

Hinweis: Wenn Sie die App ausführen, wird die Methode „setDestinations()“ aufgerufen. Nach den ersten 1.000 verwendeten Zielen fallen Gebühren an. Weitere Informationen finden Sie unter Nutzung und Abrechnung.

93aa433000a14dfc.png

Das Dialogfeld mit den Nutzungsbedingungen für Endnutzer des Navigation SDK

Standort festlegen

Standardmäßig ist der Standort des emulierten Geräts auf den Google-Campus in Mountain View, Kalifornien, festgelegt, es sei denn, Sie haben im Code einen Standort festgelegt oder verwenden das Dialogfeld mit den Emulatoreigenschaften.

In diesem Fall kann die App möglicherweise keine Route zu der von Ihnen konfigurierten Orts-ID finden (standardmäßig das Opernhaus Sydney, Sydney, Australien). In diesem Fall wird von der showToast()-Methode die Meldung „Keine Route gefunden“ angezeigt.

Die Kartenansicht der App „Navigation“ mit der Google-Niederlassung in Mountain View, Kalifornien.

Startort hart codieren

Wenn Sie einen anderen Speicherort im Code festlegen möchten, fügen Sie in der navigateToPlace()-Methode in MainActivity.kt vor dem Aufruf von mNavigator.startGuidance() die folgende Zeile hinzu:

mNavigator?.simulator?.setUserLocation(startLocation)

Emulator an einem beliebigen Standardspeicherort starten

Wenn Sie einen anderen Speicherort im Geräteemulator festlegen möchten, starten Sie den Emulator, falls er noch nicht ausgeführt wird, und klicken Sie auf das Dreipunkt-Menü mit der Kurzinfo „Erweiterte Steuerelemente“. Das Dialogfeld enthält die Menüoption „Standort“.

Wenn Sie beispielsweise die Orts-ID des Sydney Opera House als Ziel verwenden, wählen Sie einen Ort in Sydney, Australien, aus. Suchen Sie beispielsweise nach „Bondi Beach“, wählen Sie einen Vorschlag aus und klicken Sie rechts unten im Dialogfeld auf „Ort speichern“. Sie können auch auf „Punkt speichern“ klicken, um den Standort einer gespeicherten Liste hinzuzufügen.

Das Dialogfeld „Erweiterte Einstellungen“ im Android-Gerätemanager mit einer Ortsauswahl und einer Karte, die auf den Bondi Beach in Australien ausgerichtet ist.

Wenn Sie eine andere Orts-ID als Ziel festlegen, wählen Sie einen Ort in der Nähe aus, damit die simulierte Route realistisch und nicht zu lang ist, um das Debuggen zu erleichtern.

Starten Sie die App neu. Sie sollte jetzt zum Ziel navigieren.

Screenshot der Navigations-App, die eine Wegbeschreibung zum Ziel anzeigt.

11. Glückwunsch!

Sie haben dieses Codelab abgeschlossen. Gut gemacht – Sie sind am Ziel angekommen! Viel Spaß beim Programmieren :-)

55812f33256c0596.png

12. Weitere Schritte

Wenn Sie Ihre App-Entwicklung vorantreiben möchten, finden Sie in den folgenden Themen Anregungen.

  • Auf weitere Navigationsereignisse warten Fügen Sie Code hinzu, um eine Nachricht anzuzeigen, wenn der Fahrer die Route ändert oder wenn er ankommt.
  • Navigationsoberfläche anpassen
  • Wenn Sie sich einer größeren Herausforderung stellen möchten, versuchen Sie, ein Places API-Steuerelement für die Ortsauswahl hinzuzufügen, damit der Nutzer das Ziel festlegen kann. Hinweis: Die Navigation SDK-Demo-Apps auf GitHub enthalten eine Beispielimplementierung.
  • Sie können potenzielle Probleme beim asynchronen Aufrufen der Navigator- und GoogleMap-Objekte vermeiden, indem Sie den Ansatz der Navigation SDK-Demo-Apps auf GitHub verwenden. In komplexeren Anwendungsszenarien ist die Initialisierung dieser Objekte möglicherweise noch nicht abgeschlossen, wenn der Code ausgeführt wird. Tipp: Sie können die Klasse InitializedNavScope am Ende der Datei „MainActivity.kt“ hinzufügen, um eine sehr schnelle Implementierung zu ermöglichen.