Kartenobjekte

Karten werden in der API durch die Klassen GoogleMap und SupportMapFragment dargestellt.

Karte in eine Android-App einbinden

Im Startleitfaden ist eine schnelle Möglichkeit beschrieben, eine App mit der Google Maps-Vorlage in Android Studio zu erstellen.

Das Hinzufügen einer Karte umfasst die folgenden grundlegenden Schritte:

1. (Dieser Schritt muss nur ein einziges Mal ausgeführt werden.) Befolge die Anleitung im Leitfaden zur Projektkonfiguration, um den API-Schlüssel und die Gradle-Abhängigkeiten festzulegen.
2. Füge dem Activity-Element ein Fragment-Objekt hinzu, mit dem die Karte verarbeitet wird. Das geht am einfachsten, indem du der Layoutdatei für Activity ein <fragment>-Element hinzuzufügst.
3. Implementiere die Schnittstelle OnMapReadyCallback und verwende die Callback-Methode onMapReady(GoogleMap), um einen Handle für das Objekt GoogleMap zu erhalten. Das Objekt GoogleMap ist die interne Darstellung der eigentlichen Karte. Ändere das zur Karte gehörige Objekt GoogleMap, um die entsprechenden Ansichtsoptionen festzulegen.
4. Rufe getMapAsync() für das Fragment auf, um den Callback zu registrieren.

Nachfolgend erhältst du ausführlichere Informationen zu den einzelnen Schritten.

Fragment hinzufügen

Füge der Layoutdatei der Aktivität ein <fragment>-Element hinzu, um ein Fragment-Objekt zu definieren. Lege in diesem Element das android:name-Attribut auf "com.google.android.gms.maps.SupportMapFragment fest. Dadurch wird automatisch ein SupportMapFragment-Element an die Aktivität angefügt.

Die folgende Layoutdatei enthält ein <fragment>-Element:

<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:name="com.google.android.gms.maps.SupportMapFragment"
    android:id="@+id/map"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

Du kannst auch ein SupportMapFragment einem Activity-Element im Code hinzufügen. Dazu erstellst du eine neue SupportMapFragment-Instanz und rufst dann FragmentTransaction.add() auf, um das Fragment dem aktuellen Activity-Element hinzuzufügen.

Java

SupportMapFragment mapFragment = SupportMapFragment.newInstance();
getSupportFragmentManager()
    .beginTransaction()
    .add(R.id.my_container, mapFragment)
    .commit();
      

Kotlin

val mapFragment = SupportMapFragment.newInstance()
supportFragmentManager
    .beginTransaction()
    .add(R.id.my_container, mapFragment)
    .commit()
      

Kartencode hinzufügen

Um mit der Karte in deiner App zu arbeiten, musst du die Schnittstelle OnMapReadyCallback implementieren und eine Instanz des Callbacks in einem SupportMapFragment- oder MapView-Objekt definieren. In dieser Anleitung wird SupportMapFragment verwendet, weil das die gängigste Methode zum Hinzufügen einer Karte ist. Im ersten Schritt implementierst du die Callback-Schnittstelle:

Java

class MainActivity extends AppCompatActivity implements OnMapReadyCallback {
    // ...
}
      

Kotlin

class MainActivity : AppCompatActivity(), OnMapReadyCallback {

    // ...
}
      

Lege in der onCreate()-Methode von Activity die Layoutdatei als Inhaltsansicht fest. Wenn die Layoutdatei beispielsweise den Namen main.xml hat, verwende diesen Code:

Java

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
}
      

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.main)
}
      

Erstelle einen Handle zum Fragment, indem du FragmentManager.findFragmentById() aufrufst und die Ressourcen-ID des <fragment>-Elements übergibst. Die Ressourcen-ID R.id.map wird dem Android-Projekt automatisch hinzugefügt, wenn du die Layoutdatei erstellst.

Verwende dann getMapAsync(), um den Callback für das Fragment festzulegen.

Java

SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
    .findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
      

Kotlin

val mapFragment = supportFragmentManager
    .findFragmentById(R.id.map) as SupportMapFragment
mapFragment.getMapAsync(this)
      

Hinweis: Für das Maps SDK for Android ist API-Level 12 oder höher erforderlich, damit MapFragment-Objekte unterstützt werden. Wenn du Code für eine Anwendung vor API-Level 12 entwickelst, kannst du über die Klasse SupportMapFragment auf dieselben Funktionen zugreifen. Außerdem musst du die Android Support Library hinzufügen.

Hinweis: getMapAsync() muss aus dem Hauptthread aufgerufen werden und der Callback wird im Hauptthread ausgeführt. Wenn Google Play-Dienste nicht auf dem Gerät des Nutzers installiert ist, wird der Callback erst ausgelöst, nachdem der Nutzer Google Play-Dienste installiert hat.

Verwende die Callback-Methode onMapReady(GoogleMap), um einen Handle zum Objekt GoogleMap zu erhalten. Der Callback wird ausgelöst, sobald die Karte einsatzbereit ist. Er stellt eine Nicht-NULL-Instanz von GoogleMap bereit. Du kannst das Objekt GoogleMap verwenden, um Ansichtsoptionen für die Karte festzulegen oder eine Markierung hinzuzufügen.

Java

@Override
public void onMapReady(GoogleMap googleMap) {
    googleMap.addMarker(new MarkerOptions()
        .position(new LatLng(0, 0))
        .title("Marker"));
}
      

Kotlin

override fun onMapReady(googleMap: GoogleMap) {
    googleMap.addMarker(
        MarkerOptions()
            .position(LatLng(0.0, 0.0))
            .title("Marker")
    )
}
      

Kartenobjekt

Mit dem Maps SDK for Android kannst du eine Google-Karte in deiner Android-Anwendung darstellen. Diese Karten sehen genauso aus wie in der mobilen App von Google Maps und die API stellt viele derselben Funktionen bereit. Zwischen der GMM-Anwendung und den vom Maps SDK for Android dargestellten Karten gibt es zwei Hauptunterschiede:

• Von der API angezeigte Kartenkacheln enthalten keine personalisierten Inhalte, z. B. personalisierte intelligente Symbole.
• Nicht alle Symbole auf der Karte sind anklickbar. Beispielsweise kann nicht auf Symbole für Haltestellen öffentlicher Verkehrsmittel geklickt werden. Der Nutzer kann jedoch auf Markierungen klicken, die du der Karte hinzufügst. Die API hat eine Listener-Callback-Schnittstelle für verschiedene Markierungsinteraktionen.

Zusätzlich zur Kartendarstellungsfunktion unterstützt die API auch zahlreiche Interaktionen, die mit dem Android-UI-Modell kompatibel sind. Damit Nutzer mit einer Karte interagieren können, kannst du zum Beispiel Listener definieren, die auf Touch-Gesten reagieren.

Die wichtigste Klasse bei einem Kartenobjekt ist die Klasse GoogleMap. GoogleMap modelliert das Kartenobjekt innerhalb deiner App. Auf deiner UI wird eine Karte entweder durch ein SupportMapFragment- oder MapView-Objekt dargestellt.

GoogleMap verarbeitet die folgenden Vorgänge automatisch:

• Verbindung zum Google Maps-Dienst herstellen
• Kartenkacheln herunterladen
• Kacheln auf dem Gerätebildschirm anzeigen
• Verschiedene Steuerelemente z. B. zum Schwenken und Zoomen anzeigen
• Auf Gesten zum Schwenken und Zoomen reagieren, indem die Karte verschoben oder vergrößert bzw. verkleinert wird

Zusätzlich zu diesen automatischen Vorgängen kannst du die Funktionsweise von Karten auch mit Objekten und Methoden der API steuern. Beispielsweise umfasst GoogleMap Callback-Methoden, die auf Tastaturanschläge und Touch-Gesten auf der Karte reagieren. Außerdem kannst du auf deiner Karte Markierungssymbole einrichten und diese durch Overlays ergänzen. Dazu verwendest du Objekte, die du für GoogleMap bereitstellst.

SupportMapFragment

Mit SupportMapFragment, einer abgeleiteten Klasse der Android-Klasse Fragment, kannst du eine Karte in einem Android-Fragment platzieren. SupportMapFragment-Objekte fungieren als Container für die Karte und bieten Zugriff auf das GoogleMap-Objekt.

Im Unterschied zu View stellt Fragment eine Funktionsweise oder einen Teil der Benutzeroberfläche (UI) in einer Aktivität dar. Du kannst mehrere Fragmente in einer einzigen Aktivität kombinieren, um eine UI mit mehreren Fensterbereichen zu erstellen und ein Fragment in mehreren Aktivitäten wiederzuverwenden. Weitere Informationen findest du in der Android-Dokumentation zu Fragmenten.

MapView

Mit MapView, einer abgeleiteten Klasse der Android-Klasse View, kannst du eine Karte in einer Android-View platzieren. Ein View-Element repräsentiert einen rechteckigen Bereich des Bildschirms und ist ein Grundbaustein für Android-Apps und ‑Widgets. Ähnlich wie SupportMapFragment fungiert MapView als Container für die Karte und stellt grundlegende Kartenfunktionen über das GoogleMap-Objekt bereit.

Wird die API im vollständig interaktiven Modus verwendet, müssen Nutzer der Klasse MapView die folgenden Methoden des Aktivitätslebenszyklus an die entsprechenden Methoden in der Klasse MapView weiterleiten: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy(), onSaveInstanceState() und onLowMemory(). Das ApiDemos-Repository auf GitHub enthält ein Beispiel (Java/Kotlin), das zeigt, wie die Methoden des Aktivitätslebenszyklus weitergeleitet werden. Wenn die API im Lite-Modus eingesetzt wird, ist das Weiterleiten von Lebenszyklusereignissen optional. Weitere Informationen findest du in der Dokumentation zum Lite-Modus.

Kartentypen

Im Maps SDK for Android sind viele verschiedene Kartentypen verfügbar. Der Typ einer Karte ist entscheidend für ihre Gesamtdarstellung. Beispielsweise enthält ein Atlas meist politische Karten, mit denen in erster Linie Grenzen dargestellt werden, während auf Straßenkarten vor allem die Straßen einer Stadt oder Region zu sehen sind.

Das Maps SDK for Android umfasst vier Kartentypen sowie die Option zum Verzicht auf jegliche Karten:

Normal

Typische Straßenkarte. Straßen, einige von Menschen geschaffene Merkmale und wichtige Landschaftsmerkmale wie Flüsse werden angezeigt. Die dazugehörigen Labels sind ebenfalls sichtbar.

Hybrid

Enthält Satellitenfotodaten mit zusätzlichen Straßenkarten. Die dazugehörigen Labels sind ebenfalls sichtbar.

Satellit

Enthält Satellitenfotodaten. Straßen und sonstige Merkmale sind nicht beschriftet.

Gelände

Enthält topografische Daten. Die Karte umfasst Farben, Höhenlinien und Labels sowie perspektivische Schattierungen. Außerdem werden einige Straßen und Labels dargestellt.

–

Enthält keine Kacheln. Diese Karte wird als leeres Raster ohne geladene Kacheln gerendert.

Kartentyp ändern

Um den Typ einer Karte festzulegen, rufst du die setMapType()-Methode des GoogleMap-Objekts auf und übergibst eine der Typkonstanten, die in GoogleMap definiert sind. Eine Satellitenkarte lässt sich beispielsweise so aufrufen:

Java

// Sets the map type to be "hybrid"
map.setMapType(GoogleMap.MAP_TYPE_HYBRID);
      

Kotlin

// Sets the map type to be "hybrid"
map.mapType = GoogleMap.MAP_TYPE_HYBRID
      

Die folgende Abbildung zeigt einen Vergleich der Kartentypen „Normal“, „Hybrid“ und „Gelände“ für denselben Ort:

Indoor-Karten

Bei einem hohen Zoomfaktor sind auf der Karte Gebäudepläne für Innenbereiche wie z. B. Flughäfen, Einkaufszentren, große Geschäfte und Bahnhöfe zu sehen. Diese Gebäudepläne, auch als Indoor-Karten bezeichnet, werden für die Kartentypen „Normal“ und „Satellit“ (GoogleMap.MAP_TYPE_NORMAL und GoogleMap.MAP_TYPE_SATELLITE) angezeigt. Sie werden automatisch aktiviert, wenn der Nutzer heranzoomt, und ausgeblendet, wenn er wieder herauszoomt.

Hinweis zur Einstellung: In einem zukünftigen Release werden Indoor-Karten nur für den Kartentyp normal verfügbar sein. Indoor-Karten vom Typ satellite, terrain und hybrid werden dann nicht mehr unterstützt. Auch wenn sie nicht unterstützt werden, wird isIndoorEnabled() weiterhin den Wert zurückgeben, der über setIndoorEnabled() festgelegt wurde. Standardmäßig ist setIndoorEnabled auf true festgelegt. Ab wann die Unterstützung für Indoor-Karten dieser Typen eingestellt wird, werden wir in den Versionshinweisen mitteilen.

Mit Indoor-Karten in der API arbeiten

Die API bietet für Indoor-Karten folgende Funktionen:

• Du kannst Indoor-Karten durch den Aufruf von GoogleMap.setIndoorEnabled(false) deaktivieren. Standardmäßig sind Indoor-Karten aktiviert. Indoor-Karten werden jeweils auf einer Karte angezeigt. Das ist standardmäßig die erste Karte, die deiner App hinzugefügt wird. Wenn Indoor-Karten auf einer anderen Karte erscheinen sollen, deaktiviere sie auf der ersten Karte und rufe setIndoorEnabled(true) auf der zweiten Karte auf.
• Um die Standardauswahl für die Ebene (Etagenauswahl) zu deaktivieren, rufst du GoogleMap.getUiSettings().setIndoorLevelPickerEnabled(false) auf. Weitere Informationen findest du unter Mit der Karte interagieren.
• Mithilfe der Schnittstelle OnIndoorStateChangeListener in GoogleMap kannst du einen Listener festlegen, der aufgerufen wird, wenn ein neues Gebäude fokussiert oder eine neue Etage in einem Gebäude aktiviert wird. Weitere Informationen findest du unter Mit der Karte interagieren.
• Mit GoogleMap.getFocusedBuilding() wird das Gebäude abgerufen, das derzeit im Fokus ist. Anschließend kannst du die derzeit aktive Ebene durch Aufrufen von IndoorBuilding.getActiveLevelIndex() ermitteln. In der Referenzdokumentation findest du alle Informationen, die in den Objekten IndoorBuilding und IndoorLevel verfügbar sind.

Der Stil der Basiskarte wirkt sich nicht auf Indoor-Karten aus.

Gebäudepläne hinzufügen

Indoor-Karten (Gebäudepläne) sind an ausgewählten Orten verfügbar. Wenn für ein Gebäude, das du in deiner App hervorheben möchtest, keine Gebäudeplandaten verfügbar sind, hast du folgende Möglichkeiten:

• Du kannst Gebäudepläne direkt zu Google Maps hinzufügen. Damit stehen sie allen Nutzern von Google Maps zur Verfügung.
• Du kannst einen Gebäudeplan als Boden-Overlay oder Kachel-Overlay anzeigen lassen. Dann können nur Nutzer deiner App deine Gebäudepläne sehen.

Verkehrsebene

Du kannst den Nutzern die Möglichkeit geben, eine Karte mit darüber gelagerten Informationen zur Verkehrsdichte zu sehen. Das ist eine visuelle Zusammenfassung der lokalen Verkehrssituation. Du kannst die Verkehrsebene aktivieren und deaktivieren, indem du die setTrafficEnabled()-Methode aufrufst. Mit der Methode isTrafficEnabled() lässt sich feststellen, ob die Verkehrsebene derzeit aktiviert ist. Das folgende Beispiel zeigt, wie die Verkehrsebene auf einer Karte aussehen könnte.

Anfangszustand konfigurieren

Mithilfe der Google Maps API kannst du den Anfangszustand der Karte an die Anforderungen deiner App anpassen. Du kannst Folgendes festlegen:

• Die Kameraposition, einschließlich Position, Zoomfaktor, Ausrichtung und Neigung; weitere Informationen zur Positionierung der Kamera unter Kamera und Ansicht
• Den Kartentyp
• Ob die Zoomschaltflächen und/oder der Kompass auf dem Bildschirm angezeigt werden
• Mit welchen Touch-Gesten Nutzer die Kamera ändern können
• Ob der Lite-Modus aktiviert ist oder nicht; Karte im Lite-Modus: Bitmapbild einer Karte, die eine Teilmenge der Funktionen unterstützt, die von der vollständigen API zur Verfügung werden

Du kannst den Anfangszustand der Karte entweder programmatisch konfigurieren oder über XML, wenn du die Karte der Layoutdatei deiner Aktivität hinzugefügt hast.

XML-Attribute verwenden

In diesem Abschnitt wird beschrieben, wie der Anfangszustand der Karte festgelegt wird, wenn du eine Karte mithilfe einer XML-Layoutdatei deiner App hinzugefügt hast.

In der Google Maps API ist eine Gruppe benutzerdefinierter XML-Attribute für SupportMapFragment oder MapView definiert, mit denen du den Anfangszustand der Karte direkt über die Layoutdatei konfigurieren kannst. Folgende Attribute sind derzeit definiert:

• mapType. Mit diesem Attribut kannst du den Typ der anzuzeigenden Karte definieren. Zulässige Werte: none, normal, hybrid, satellite und terrain
• cameraTargetLat, cameraTargetLng, cameraZoom, cameraBearing, cameraTilt. Mit diesen Attributen kannst du die Anfangsposition der Kamera definieren. Weitere Details zur Position der Kamera und ihren Eigenschaften findest du hier.
• uiZoomControls, uiCompass. Damit kannst du angeben, ob die Zoomsteuerelemente und der Kompass auf der Karte angezeigt werden sollen. Unter UiSettings findest du weitere Details.
• uiZoomGestures, uiScrollGestures, uiRotateGestures, uiTiltGestures. Damit kannst du angeben, welche Touch-Gesten für die Interaktion mit der Karte aktiviert bzw. deaktiviert sind. Unter UiSettings findest du weitere Details.
• zOrderOnTop. Damit kannst du festlegen, ob die Oberfläche der Kartenansicht über dem Kartenfenster platziert wird. Weitere Details findest du unter SurfaceView.setZOrderOnTop(boolean). Dadurch werden alle anderen Ansichten verdeckt, die auf der Karte vorhanden sein könnten, z. B. die Zoomsteuerelemente und die Schaltfläche „Mein Standort“.
• useViewLifecycle. Nur gültig mit SupportMapFragment. Dieses Attribut gibt an, ob der Lebenszyklus der Karte an die Ansicht des Fragments oder an das Fragment selbst gebunden sein soll. Weitere Informationen findest du hier.
• liteMode. Mit dem Wert true wird die Karte auf den Lite-Modus festgelegt. Eine Karte im Lite-Modus ist ein Bitmapbild einer Karte, die eine Teilmenge der Funktionen unterstützt, die von der vollständigen API bereitgestellt werden. Der Standardwert dieses Attributs ist false.

Um diese benutzerdefinierten Attribute innerhalb deiner XML-Layoutdatei verwenden zu können, musst du zuerst die folgende Namespace-Deklaration hinzufügen. Du kannst einen beliebigen Namensraum auswählen. Es muss nicht map sein:

xmlns:map="http://schemas.android.com/apk/res-auto"

Anschließend kannst du die Attribute mit dem Präfix map: deinen Layoutkomponenten hinzufügen, so wie du es auch bei standardmäßigen Android-Attributen machst.

Das folgende XML-Code-Snippet zeigt, wie ein SupportMapFragment-Element mit einigen benutzerdefinierten Optionen konfiguriert wird (dieselben Attribute können auch auf ein MapView-Element angewendet werden).

<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"
  map:cameraBearing="112.5"
  map:cameraTargetLat="-33.796923"
  map:cameraTargetLng="150.922433"
  map:cameraTilt="30"
  map:cameraZoom="13"
  map:mapType="normal"
  map:uiCompass="false"
  map:uiRotateGestures="true"
  map:uiScrollGestures="false"
  map:uiTiltGestures="true"
  map:uiZoomControls="false"
  map:uiZoomGestures="true"/>

Hinweis: Wenn du das Maps SDK for Android mit einem Premium-Tarif für Google Maps Platform verwendest, muss jedem Attribut m4b_ vorangestellt werden. Wenn du beispielsweise das Kartentyp-Attribut angibst, verwende m4b_mapType anstelle von mapType. Oder verwende beim Festlegen von Zoomsteuerelementen m4b_uiZoomControls statt uiZoomControls und so weiter.

Programmatisch

In diesem Abschnitt wird beschrieben, wie der Anfangszustand der Karte festgelegt wird, wenn du eine Karte deiner App programmatisch hinzugefügt hast.

Wenn du programmatisch ein SupportMapFragment oder eine MapView hinzugefügt hast, kannst du den Anfangszustand konfigurieren, indem du ein GoogleMapOptions-Objekt mit den angegebenen Optionen übergibst. Die verfügbaren Optionen sind genau dieselben wie beim Hinzufügen per XML. So kannst du ein GoogleMapOptions-Objekt erstellen:

Java

GoogleMapOptions options = new GoogleMapOptions();
      

Kotlin

val options = GoogleMapOptions()
      

Anschließend konfigurierst du das Objekt so:

Java

options.mapType(GoogleMap.MAP_TYPE_SATELLITE)
    .compassEnabled(false)
    .rotateGesturesEnabled(false)
    .tiltGesturesEnabled(false);
      

Kotlin

options.mapType(GoogleMap.MAP_TYPE_SATELLITE)
    .compassEnabled(false)
    .rotateGesturesEnabled(false)
    .tiltGesturesEnabled(false)
      

Um diese Optionen beim Erstellen einer Karte anzuwenden, führst du einen der folgenden Schritte aus:

• Falls du SupportMapFragment verwendest, erstelle das Fragment mithilfe der statischen Fabrikmethode SupportMapFragment.newInstance(GoogleMapOptions options) und übergib die benutzerdefinierten Optionen, die du konfiguriert hast.
• Wenn du MapView verwendest, nutze den Konstruktor MapView(Context, GoogleMapOptions) und übergib die von dir konfigurierten benutzerdefinierten Optionen.

Karte mit Innenrand versehen

In diesem Video siehst du ein Beispiel für das Hinzufügen eines Karteninnenrands.

Eine Google-Karte füllt standardmäßig den gesamten Bereich aus, der von ihrem Containerelement – in der Regel eine MapView oder ein SupportMapFragment – definiert wird. Verschiedene Aspekte der Darstellung und des Verhaltens der Karte werden durch die Abmessungen des Kartencontainers definiert:

• Das Ziel der Kamera entspricht der Mitte des abgesetzten Bereichs.
• Kartensteuerelemente werden relativ zu den Rändern der Karte positioniert.
• Rechtliche Informationen wie Urheberrechtsangaben oder das Google-Logo werden am unteren Rand der Karte angezeigt.

Du kannst mithilfe von GoogleMap an der Kartenaußenseite einen Innenrand hinzufügen.setPadding()-Methode. Die Karte füllt weiterhin den gesamten Container aus, aber die Positionierung von Text und Steuerelementen, Touch-Gesten für die Kartensteuerung und Kamerabewegung verhalten sich so, als wenn die Karte in einem kleineren Bereich platziert worden wäre. Das führt zu folgenden Änderungen:

• Kamerabewegungen über API-Aufrufe oder die Betätigung von Schaltflächen (z. B. der Kompassschaltfläche, der Schaltfläche „Mein Standort“ oder der Zoomschaltflächen) erfolgen relativ zum abgesetzten Bereich.
• getCameraPosition() gibt die Mitte des abgesetzten Bereichs zurück.
• Projection.getVisibleRegion() gibt den abgesetzten Bereich zurück.
• UI-Steuerelemente werden um die angegebene Anzahl von Pixeln vom Rand des Containers entfernt platziert.

Ein Innenrand kann beim Entwerfen von UI-Elementen hilfreich sein, die sich mit einem Teil der Karte überschneiden. Auf dem Bild unten wurden zum Beispiel Innenränder entlang des oberen und rechten Rands der Karte festgelegt. Sichtbare Kartensteuerelemente und rechtliche Informationen werden entlang der Ränder des abgesetzten Bereichs (grün) angezeigt. Die Karte füllt aber weiterhin den gesamten Container (blau) aus. In diesem Beispiel kannst du rechts auf der Karte ein Menü einblenden, ohne die Kartensteuerelemente zu verdecken.

Hinweis: Gemäß den Google Maps Platform-Nutzungsbedingungen dürfen das Google-Logo und die Urheberrechtshinweise in deiner App weder entfernt noch verdeckt werden. Mithilfe eines Innenrands auf der Karte kannst du diese Elemente bei Bedarf neu positionieren. Wenn du unten auf der Karte eine benutzerdefinierte UI anzeigen lässt, legst du einen Innenrand vom unteren Kartenrand fest, damit das Logo und die rechtlichen Hinweise immer sichtbar sind.

Karte lokalisieren

Wenn du deiner App eine MapView oder ein SupportMapFragment hinzufügst, werden Textelemente auf der Karte in der Sprache angezeigt, die den Einstellungen und dem Standort des Nutzergeräts entsprechen. Du kannst die in deiner App verfügbaren Sprachen auf eine Teilmenge aller unterstützten Sprachen beschränken, indem du deiner Gradle-Datei ein resConfigs-Element hinzufügst. Das ist nützlich, um nicht verwendete Sprachen zu entfernen und die Binärgröße der App zu reduzieren. Beispiel:

defaultConfig {
    resConfigs "en", "fr", "es", "zh", "de", "ja", "ru", "ko", "pt", "in"
}

Weitere Informationen zur Lokalisierung deiner Android-App