Hier erfahren Sie, wie Sie eine Basiskarte in eine Android-App einbinden, nachdem Sie das Projekt für das Maps SDK for Android konfiguriert haben. Nachdem die Karte erfolgreich eingebunden wurde, können Sie Kartentyp und ‑elemente ändern.
Übersicht
Das Maps SDK for Android bietet mehrere Klassen, mit denen in Ihrer App der Lebenszyklus, die Funktionen und die Daten einer Karte verwaltet werden können. Die Klassen ermöglichen Nutzerinteraktionen basierend auf dem Android-UI-Modell. So kann die App beispielsweise den Anfangszustand der Karte festlegen oder während der Laufzeit auf Touch-Gesten reagieren.
Die wichtigsten Schnittstellen und Klassen für die Verarbeitung von Karten sind:
GoogleMap– der Einstiegspunkt zum Verwalten der zugrunde liegenden Kartenelemente und ‑daten. Die App kann erst auf einGoogleMap-Objekt zugreifen, nachdem es aus einemSupportMapFragment- oderMapView-Objekt abgerufen wurde.SupportMapFragment– ein Fragment, mit dem der Lebenszyklus einesGoogleMap-Objekts verwaltet wird.MapView– eine Ansicht, mit der der Lebenszyklus einesGoogleMap-Objekts verwaltet wird.OnMapReadyCallback– eine Callback-Oberfläche, über die Ereignisse und Nutzerinteraktionen für dasGoogleMap-Objekt verarbeitet werden.
Ein GoogleMap-Objekt führt automatisch folgende Vorgänge aus:
- Verbindung zum Google Maps-Dienst herstellen
- Kartenkacheln herunterladen
- Kacheln auf dem Gerätebildschirm anzeigen
- Verschiedene Steuerelemente anzeigen, z. B. zum Schwenken und Zoomen
- Auf Touch-Gesten zum Schwenken und Zoomen reagieren, indem die Karte verschoben oder heran- bzw. herausgezoomt wird
Wenn Sie ein GoogleMap-Objekt in Ihrer App einsetzen möchten, müssen Sie ein SupportMapFragment- oder ein MapView-Objekt als Containerobjekt für die Karte verwenden und dann das GoogleMap-Objekt aus dem Container abrufen. Die Containerklassen werden entweder aus einem Android-Fragment oder einer Android-Ansicht abgeleitet. Sie stellen daher für die Karte die Funktionen für die UI sowie für die Lebenszyklusverwaltung ihrer Android-Basisklassen zur Verfügung.
Die SupportMapFragment-Klasse ist der modernere und meist verwendete Container für ein GoogleMap-Objekt.
Code ansehen
Der folgende Code stammt aus der vollständigen Java-Aktivität, die in diesem Artikel verwendet wird, um ein statisches Fragment hinzuzufügen. Das Android-Projekt wurde anhand der leeren Projektvorlage erstellt und dann entsprechend der Anleitung unter Android Studio-Projekt einrichten aktualisiert. Nachdem Sie die hier aufgeführten Schritte ausgeführt haben, kann Ihr Code je nach Projektvorlage variieren.
package com.example.mapsetup;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
// Implement OnMapReadyCallback.
public class MainActivity extends AppCompatActivity implements OnMapReadyCallback {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Set the layout file as the content view.
setContentView(R.layout.activity_main);
// Get a handle to the fragment and register the callback.
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
.findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
}
// Get a handle to the GoogleMap object and display marker.
@Override
public void onMapReady(GoogleMap googleMap) {
googleMap.addMarker(new MarkerOptions()
.position(new LatLng(0, 0))
.title("Marker"));
}
}
Karte hinzufügen
In diesem Abschnitt wird beschrieben, wie Sie eine Basiskarte einbinden. Als Kartencontainer dient hier ein Fragment, Sie können aber auch eine Ansicht verwenden. Ein Beispiel ist auf GitHub in der RawMapViewDemoActivity verfügbar.
Grundlegende Schritte:
Um das SDK zu erhalten, müssen Sie einen API-Schlüssel anfordern und die erforderlichen Frameworks hinzufügen. Folgen Sie dazu den Anleitungen unter:
Fügen Sie der Aktivität, mit der die Karte verarbeitet wird, ein
SupportMapFragment-Objekt hinzu. Das Fragment kann statisch oder dynamisch eingebunden werden.Implementieren Sie die
OnMapReadyCallback-Schnittstelle.Legen Sie die Layoutdatei als Inhaltsansicht fest.
Wenn Sie das Fragment statisch hinzugefügt haben, rufen Sie einen Handle dafür ab.
Registrieren Sie den Callback.
Rufen Sie einen Handle für das
GoogleMap-Objekt ab.
SupportMapFragment-Objekt hinzufügen
Ein SupportMapFragment-Objekt kann statisch oder dynamisch in die App eingebunden werden.
Die statische Variante ist am einfachsten. Wenn Sie das Fragment dynamisch hinzufügen, können Sie weitere Aktionen dafür durchführen und es z. B. während der Laufzeit entfernen oder ersetzen.
Fragment statisch hinzufügen
Führen Sie in der Layoutdatei der Aktivität, mit der die Karte verarbeitet wird, folgende Schritte aus:
- Fügen Sie ein
fragment-Element hinzu. - Geben Sie die folgende Namensdeklaration an:
xmlns:map="http://schemas.android.com/apk/res-auto". Dadurch können benutzerdefinierte XML-Attribute vonmapsverwendet werden. - Legen Sie im
fragment-Element das Attributandroid:nameaufcom.google.android.gms.maps.SupportMapFragmentfest. - Fügen Sie im
fragment-Element das Attributandroid:idhinzu und legen Sie es auf die Ressourcen-ID von „R.id.map“ (@+id/map) fest.
Hier ein Beispiel einer vollständigen Layoutdatei mit einem fragment-Element:
<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:map="http://schemas.android.com/apk/res-auto"
android:name="com.google.android.gms.maps.SupportMapFragment"
android:id="@+id/map"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
Fragment dynamisch hinzufügen
Führen Sie in der Aktivität folgende Schritte aus:
- Erstellen Sie eine
SupportMapFragment-Instanz. - Führen Sie den Commit einer Transaktion durch, mit der das Fragment zur Aktivität hinzugefügt wird. Weitere Informationen finden Sie im Artikel zu Fragment-Transaktionen.
Beispiel:
Kotlin
val mapFragment = SupportMapFragment.newInstance()
supportFragmentManager
.beginTransaction()
.add(R.id.my_container, mapFragment)
.commit()
Java
SupportMapFragment mapFragment = SupportMapFragment.newInstance();
getSupportFragmentManager()
.beginTransaction()
.add(R.id.my_container, mapFragment)
.commit();
OnMapReadyCallback-Oberfläche implementieren
Ändern Sie die Deklaration der Aktivität folgendermaßen:
Kotlin
class MainActivity : AppCompatActivity(), OnMapReadyCallback {
// ...
}
Java
class MainActivity extends AppCompatActivity implements OnMapReadyCallback {
// ...
}
Inhaltsansicht festlegen
Rufen Sie in der onCreate-Methode der Aktivität die setContentView-Methode auf und legen Sie die Layoutdatei als Inhaltsansicht fest.
In diesem Beispiel wird main.xml als Name der Layoutdatei angenommen:
Kotlin
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.main)
}
Java
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
Handle für Fragment abrufen und Callback registrieren
Rufen Sie die
FragmentManager.findFragmentById-Methode auf und übergeben Sie die Ressourcen-ID des Fragments in der Layoutdatei, um einen Handle zum Fragment zu erhalten. Wenn Sie das Fragment dynamisch hinzugefügt haben, überspringen Sie diesen Schritt, da Sie den Handle bereits abgerufen haben.Rufen Sie die
getMapAsync-Methode auf, um den Callback für das Fragment festzulegen.
In diesem Beispiel wird angenommen, dass das Fragment statisch hinzugefügt wurde:
Kotlin
val mapFragment = supportFragmentManager
.findFragmentById(R.id.map) as SupportMapFragment
mapFragment.getMapAsync(this)
Java
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
.findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
Handle für das GoogleMap-Objekt abrufen
Verwenden Sie die Callback-Methode onMapReady, um einen Handle für das GoogleMap-Objekt zu erhalten. Der Callback wird ausgelöst, sobald Nutzereingaben auf der Karte ausgeführt werden können. Mit dem Callback wird eine Nicht-Null-Instanz der GoogleMap-Klasse bereitgestellt, mit der sich die Karte aktualisieren lässt.
In diesem Beispiel ruft der Callback onMapReady einen Handle zum GoogleMap-Objekt ab. Daraufhin wird der Karte eine Markierung hinzugefügt:
Kotlin
override fun onMapReady(googleMap: GoogleMap) {
googleMap.addMarker(
MarkerOptions()
.position(LatLng(0.0, 0.0))
.title("Marker")
)
}
Java
@Override
public void onMapReady(GoogleMap googleMap) {
googleMap.addMarker(new MarkerOptions()
.position(new LatLng(0, 0))
.title("Marker"));
}
Wenn Sie die App richtig erstellen und ausführen, ist dort nun eine Karte mit einer Markierung auf Null Island (Punkt auf der Erde mit den Breiten- und Längengradkoordinaten 0°N 0°E) zu sehen.
Code der vollständigen Aktivität ansehen:
Vollständige Aktivität ansehen
Nächste Schritte
Nachdem Sie die Schritte oben abgeschlossen haben, können Sie die Karteneinstellungen konfigurieren.