Formen

Die Google Maps API für Android bietet diverse einfache Optionen zum Hinzufügen von Formen zu deinen Karten, um sie für deine App anzupassen.

  • Eine Polyline besteht aus einer Gruppe verbundener Liniensegmente, die du zu einer beliebigen Form zusammenfügen kannst, um Wege und Routen auf einer Karte zu kennzeichnen.
  • Ein Polygon ist eine geschlossene Form, mit der du Bereiche auf der Karte kennzeichnen kannst.
  • Ein Circle ist eine geografisch genaue Projektion eines Kreises auf der Erdoberfläche, die auf der Karte gezeichnet wird.

Bei allen diesen Formen kannst du die Darstellung anpassen, indem du eine Reihe von Eigenschaften änderst.

Codebeispiele

Die Anleitung zum Hinzufügen von Polygonen und Polylinien zur Darstellung von Bereichen und Routen enthält den gesamten Code für eine einfache Android-App.

Darüber hinaus enthält das ApiDemos-Repository in GitHub Beispiele, die die Verwendung von Formen und ihren Funktionen veranschaulichen:

Polylinien

Die Klasse Polyline definiert eine Gruppe miteinander verbundener Liniensegmente auf der Karte. Ein Polyline-Objekt besteht aus einer Gruppe von LatLng-Standorten und erstellt eine Folge von Liniensegmenten, die diese Standorte in einer geordneten Reihenfolge miteinander verbinden.

Im nachfolgenden Video wird gezeigt, wie du deine Nutzer dabei unterstützt, den Weg zu ihrem Ziel zu finden, indem du mit Polylinien einen Weg auf der Karte zeichnest.

Erstelle für eine Polylinie zuerst das Objekt PolylineOptions und füge ihm Punkte hinzu. Die Punkte stehen für einen Ort auf der Erdoberfläche und werden als LatLng-Objekt ausgedrückt. Die Liniensegmente werden in der Reihenfolge zwischen den Punkten gezeichnet, in der sie dem PolylineOptions-Objekt hinzugefügt wurden. Rufe PolylineOptions.add() auf, um einem PolylineOptions-Objekt Punkte hinzuzufügen. Für diese Methode wird eine variable Anzahl von Parametern benötigt, damit du mehrere Punkte gleichzeitig hinzufügen kannst. Du kannst auch PolylineOptions.addAll(Iterable<LatLng>) aufrufen, wenn sich die Punkte bereits in einer Liste befinden.

Anschließend kannst du die Polylinie einer Karte hinzufügen, indem du GoogleMap.addPolyline(PolylineOptions) aufrufst. Die Methode gibt ein Polyline-Objekt zurück, mit dem du die Polylinie zu einem späteren Zeitpunkt ändern kannst.

Im folgenden Codebeispiel wird einer Karte ein Rechteck hinzugefügt:

Java

// Instantiates a new Polyline object and adds points to define a rectangle
PolylineOptions polylineOptions = new PolylineOptions()
    .add(new LatLng(37.35, -122.0))
    .add(new LatLng(37.45, -122.0))  // North of the previous point, but at the same longitude
    .add(new LatLng(37.45, -122.2))  // Same latitude, and 30km to the west
    .add(new LatLng(37.35, -122.2))  // Same longitude, and 16km to the south
    .add(new LatLng(37.35, -122.0)); // Closes the polyline.

// Get back the mutable Polyline
Polyline polyline = map.addPolyline(polylineOptions);

Kotlin

// Instantiates a new Polyline object and adds points to define a rectangle
val polylineOptions = PolylineOptions()
    .add(LatLng(37.35, -122.0))
    .add(LatLng(37.45, -122.0)) // North of the previous point, but at the same longitude
    .add(LatLng(37.45, -122.2)) // Same latitude, and 30km to the west
    .add(LatLng(37.35, -122.2)) // Same longitude, and 16km to the south
    .add(LatLng(37.35, -122.0)) // Closes the polyline.

// Get back the mutable Polyline
val polyline = map.addPolyline(polylineOptions)

Die Polylinienform kann nach dem Hinzufügen geändert werden, indem du Polyline.setPoints() aufrufst und eine neue Liste mit Punkten für die Polylinie vorgibst.

Die Darstellung der Polylinie kann sowohl vor als auch nach dem Hinzufügen zur Karte angepasst werden. Nähere Einzelheiten findest du unten im Abschnitt Darstellung anpassen.

Polylinienereignisse

Polylinien sind standardmäßig nicht anklickbar. Das kann durch Aufrufen von Polyline.setClickable(boolean) aktiviert oder deaktiviert werden.

Mithilfe von OnPolylineClickListener lassen sich Klickereignisse auf eine anklickbare Polylinie beobachten. Rufe GoogleMap.setOnPolylineClickListener(OnPolylineClickListener) auf, um diesen Listener auf der Karte festzulegen. Wenn ein Nutzer auf eine Polylinie klickt, erhältst du einen onPolylineClick(Polyline)-Callback.

Polygone

Polygon-Objekte ähneln Polyline-Objekten insofern, als sie aus einer Reihe von Koordinaten in einer geordneten Reihenfolge bestehen. Allerdings sind Polygone nicht offen, sondern umschließen bestimmte Bereiche und besitzen eine Füllung.

Du kannst der Karte ein Polygon auf dieselbe Weise hinzufügen, wie du ein Polyline hinzufügst. Erstelle zuerst ein PolygonOptions-Objekt und füge einige Punkte hinzu. Diese Punkte bilden dann den Rahmen des Polygons. Füge das Polygon dann der Karte hinzu, indem du GoogleMap.addPolygon(PolygonOptions) aufrufst, wodurch ein Polygon-Objekt zurückgegeben wird.

Mit dem folgenden Codebeispiel wird einer Karte ein Rechteck hinzugefügt (weil wir keine Füllfarbe definiert haben und die Standardfüllfarbe transparent ist, erfolgt das in exakt derselben Weise wie das Hinzufügen der Polylinie aus dem Codebeispiel im vorherigen Abschnitt):

Java

// Instantiates a new Polygon object and adds points to define a rectangle
PolygonOptions polygonOptions = new PolygonOptions()
    .add(new LatLng(37.35, -122.0),
        new LatLng(37.45, -122.0),
        new LatLng(37.45, -122.2),
        new LatLng(37.35, -122.2),
        new LatLng(37.35, -122.0));

// Get back the mutable Polygon
Polygon polygon = map.addPolygon(polygonOptions);

Kotlin

// Instantiates a new Polygon object and adds points to define a rectangle
val rectOptions = PolygonOptions()
    .add(
        LatLng(37.35, -122.0),
        LatLng(37.45, -122.0),
        LatLng(37.45, -122.2),
        LatLng(37.35, -122.2),
        LatLng(37.35, -122.0)
    )

// Get back the mutable Polygon
val polygon = map.addPolygon(rectOptions)

Du kannst die Form des Polygons nach dem Hinzufügen ändern, indem du Polygon.setPoints() aufrufst und eine neue Liste mit Punkten für den Umriss des Polygons bereitstellst.

Die Darstellung des Polygons kann sowohl vor als auch nach dem Hinzufügen zur Karte angepasst werden. Nähere Einzelheiten findest du unten im Abschnitt Darstellung anpassen.

Autovervollständigen von Polygonen

Das Polygon im Beispiel oben besteht aus fünf Koordinaten. Beachte, dass die erste und die letzte Koordinate auf derselben Position liegen, sodass eine abgeschlossene Einheit entsteht. Die letzte Koordinate musst du in der Praxis jedoch nicht festlegen, da Polygone immer einen geschlossenen Bereich umfassen. Wenn die letzte Koordinate sich von der ersten unterscheidet, „schließt“ die API automatisch das Polygon, indem die erste Koordinate am Ende der Koordinatensequenz angefügt wird.

Die nachfolgenden beiden Polygone sind äquivalent. Wenn polygon.getPoints() für beide Polygone aufgerufen wird, werden alle 4 Punkte zurückgegeben.

Java

Polygon polygon1 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(0, 0))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

Polygon polygon2 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

Kotlin

val polygon1 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(0.0, 0.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)
val polygon2 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)

Hohles Polygon erstellen

In einem einzigen Polygon-Objekt können mehrere Strecken kombiniert werden, um komplexe Formen wie ausgefüllte Ringe oder „Kringel“ zu erstellen. Bei den letzteren erscheinen polygonale Bereiche innerhalb des Polygons als „Inseln“. Komplexe Formen setzen sich immer aus mehreren einfacheren Strecken zusammen.

Zwei Pfade müssen im selben Bereich definiert werden. Der größere der beiden Bereiche bestimmt den Füllbereich und wird durch ein einfaches Polygon ohne zusätzliche Optionen umgesetzt. Übergib dann eine zweite Strecke an die addHole()-Methode. Wenn die zweite, kleinere Strecke ganz von der größeren Strecke umschlossen ist, erscheint es so, als ob ein Teil des Polygons entfernt wurde. Überschneidet sich dieses Loch mit dem Umriss des Polygons, wird das Polygon ohne Füllung dargestellt.

Mit dem folgenden Snippet wird ein einzelnes Rechteck mit einem kleineren rechteckigen Loch erstellt.

Java

List<LatLng> hole = Arrays.asList(new LatLng(1, 1),
    new LatLng(1, 2),
    new LatLng(2, 2),
    new LatLng(2, 1),
    new LatLng(1, 1));
Polygon hollowPolygon = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(3, 0),
        new LatLng(0, 0))
    .addHole(hole)
    .fillColor(Color.BLUE));

Kotlin

val hole = listOf(
    LatLng(1.0, 1.0),
    LatLng(1.0, 2.0),
    LatLng(2.0, 2.0),
    LatLng(2.0, 1.0),
    LatLng(1.0, 1.0)
)
val hollowPolygon = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(3.0, 0.0),
            LatLng(0.0, 0.0)
        )
        .addHole(hole)
        .fillColor(Color.BLUE)
)

Polygonereignisse

Polygone sind standardmäßig nicht anklickbar. Die Anklickbarkeit kann durch Aufrufen von Polygon.setClickable(boolean) aktiviert oder deaktiviert werden.

Mithilfe von OnPolygonClickListener lassen sich Klickereignisse auf ein anklickbares Polygon beobachten. Rufe GoogleMap.setOnPolygonClickListener(OnPolygonClickListener) auf, um diesen Listener auf der Karte festzulegen. Wenn ein Nutzer auf ein Polygon klickt, erhältst du einen onPolygonClick(Polygon)-Callback.

Kreise

Zusätzlich zu einer generischen Polygon-Klasse enthält die Google Maps API auch spezielle Klassen für Circle-Objekte, die das Erstellen von Kreisen vereinfachen.

Um einen Kreis zu konstruieren, definiere die folgenden beiden Eigenschaften:

  • center als LatLng.
  • radius in Metern.

Ein Kreis ist als die Menge der Punkte auf der Erdoberfläche definiert, die radius Meter vom angegebenen Kreismittelpunkt (center) entfernt sind. Aufgrund der Art und Weise, wie die von der Google Maps API verwendete Mercator-Projektion eine Kugel auf einer ebenen Oberfläche darstellt, erscheint diese Form nahe am Äquator wie ein nahezu perfekter Kreis, während sie mit zunehmender Entfernung vom Äquator diese kreisrunde Form auf dem Bildschirm immer mehr einbüßt.

Mit dem folgenden Code-Snippet wird der Karte ein Kreis hinzugefügt. Dazu wird ein CircleOptions-Objekt erstellt und GoogleMap.addCircle(CircleOptions) aufgerufen:

Java

// Instantiates a new CircleOptions object and defines the center and radius
CircleOptions circleOptions = new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000); // In meters

// Get back the mutable Circle
Circle circle = map.addCircle(circleOptions);

Kotlin

// Instantiates a new CircleOptions object and defines the center and radius
val circleOptions = CircleOptions()
    .center(LatLng(37.4, -122.1))
    .radius(1000.0) // In meters

// Get back the mutable Circle
val circle = map.addCircle(circleOptions)

Um die Form des Kreises nach dem Hinzufügen zu ändern, rufe Circle.setRadius() oder Circle.setCenter() auf und gib neue Werte an.

Die Darstellung des Kreises kann sowohl vor als auch nach dem Hinzufügen zur Karte angepasst werden. Nähere Einzelheiten findest du unten im Abschnitt Darstellung anpassen.

Kreisereignisse

Kreise sind standardmäßig nicht anklickbar. Du kannst die Anklickbarkeit aktivieren und deaktivieren, indem du GoogleMap.addCircle() mit CircleOptions.clickable(boolean) aufrufst oder Circle.setClickable(boolean) aufrufst.

Mithilfe von OnCircleClickListener lassen sich Klickereignisse auf einen anklickbaren Kreis beobachten. Rufe GoogleMap.setOnCircleClickListener(OnCircleClickListener) auf, um diesen Listener auf der Karte festzulegen.

Wenn ein Nutzer auf einen Kreis klickt, erhältst du einen onCircleClick(Circle)-Callback, wie im folgenden Codebeispiel gezeigt:

Java

Circle circle = map.addCircle(new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000)
    .strokeWidth(10)
    .strokeColor(Color.GREEN)
    .fillColor(Color.argb(128, 255, 0, 0))
    .clickable(true));

map.setOnCircleClickListener(new GoogleMap.OnCircleClickListener() {
    @Override
    public void onCircleClick(Circle circle) {
        // Flip the r, g and b components of the circle's stroke color.
        int strokeColor = circle.getStrokeColor() ^ 0x00ffffff;
        circle.setStrokeColor(strokeColor);
    }
});

Kotlin

val circle = map.addCircle(
    CircleOptions()
        .center(LatLng(37.4, -122.1))
        .radius(1000.0)
        .strokeWidth(10f)
        .strokeColor(Color.GREEN)
        .fillColor(Color.argb(128, 255, 0, 0))
        .clickable(true)
)
map.setOnCircleClickListener {
    // Flip the r, g and b components of the circle's stroke color.
    val strokeColor = it.strokeColor xor 0x00ffffff
    it.strokeColor = strokeColor
}

Darstellung anpassen

Du kannst die Darstellung der Form sowohl vor – durch Vorgabe der gewünschten Eigenschaft im Optionsobjekt – als auch nach dem Hinzufügen zur Karte ändern. Außerdem werden für alle Eigenschaften Abfragemethoden (Getter) freigeschaltet, damit du ganz einfach auf den aktuellen Status der Form zugreifen kannst.

Mit dem folgenden Snippet wird eine dicke blaue Polylinie mit geodätischen Segmenten von Melbourne nach Perth hinzugefügt. Die entsprechenden Eigenschaften werden in den folgenden Abschnitten näher erläutert.

Java

Polyline polyline = map.addPolyline(new PolylineOptions()
    .add(new LatLng(-37.81319, 144.96298), new LatLng(-31.95285, 115.85734))
    .width(25)
    .color(Color.BLUE)
    .geodesic(true));

Kotlin

val polyline = map.addPolyline(
    PolylineOptions()
        .add(LatLng(-37.81319, 144.96298), LatLng(-31.95285, 115.85734))
        .width(25f)
        .color(Color.BLUE)
        .geodesic(true)
)

Hinweis: Während die meisten dieser Eigenschaften auf beliebige der beschriebenen Formen angewendet werden können, sind einige der Eigenschaften eventuell für bestimmte Formen nicht sinnvoll. Beispielsweise kann eine Polylinie keine Füllfarbe haben, weil sie keinen Innenbereich umfasst.

Strichfarbe

Die Strichfarbe ist eine Alpha-Rot-Grün-Blau-Ganzzahl (ARGB) mit 16 Bit, die die Deckkraft und Farbe der Linie der Form festlegt. Lege diese Eigenschaft für das Optionsobjekt der Form fest, indem *Options.strokeColor() oder im Fall einer Polylinie PolylineOptions.color() aufgerufen wird. Wird kein Wert angegeben, ist Schwarz die Standardstrichfarbe (Color.BLACK).

Nach dem Hinzufügen der Form zur Karte kannst du auf die Strichfarbe zugreifen, indem du getStrokeColor() (oder getColor() für eine Polylinie) aufrufst. Rufe zum Ändern der Strichfarbe setStrokeColor() (setColor() for a polyline) auf.

Füllfarbe

Eine Füllfarbe kann nur auf Polygone und Kreise angewendet werden. Sie ist auf Polylinien nicht anwendbar, weil diese keinen definierten Innenbereich haben. Bei einem Polygon sind die Bereiche innerhalb der Löcher nicht Teil des Innenbereichs des Polygons und werden deshalb bei Vorgabe einer Füllfarbe nicht eingefärbt.

Die Füllfarbe ist eine Alpha-Rot-Grün-Blau-Ganzzahl (ARGB) mit 16 Bit, die die Deckkraft und Farbe des Innenbereichs der Form festlegt. Lege dieses Attribut für das Optionsobjekt der Form fest, indem *Options.fillColor() aufgerufen wird. Wird kein Wert angegeben, wird die Standardfüllfarbe Transparent (Color.TRANSPARENT) verwendet.

Nach dem Hinzufügen der Form zur Karte kannst du auf die Füllfarbe zugreifen, indem du getFillColor() aufrufst. Rufe zum Ändern der Füllfarbe setFillColor() auf.

Strichbreite

Die Linienbreite als Gleitkommazahl in Pixeln (px). Die Breite wird beim Zoomen der Karte nicht skaliert, d. h., die Form weist bei allen Zoomstufen dieselbe Strichbreite auf. Lege diese Eigenschaft im Optionsobjekt der Form fest, indem du *Options.strokeWidth() (oder PolylineOptions.width() für eine Polylinie) aufrufst. Ist kein Wert angegeben, beträgt die Standardstrichbreite 10 Pixel.

Nach dem Hinzufügen der Form zur Karte kannst du auf die Strichbreite zugreifen, indem du getStrokeWidth() (oder getWidth() für eine Polylinie) aufrufst. Rufe zum Ändern der Strichbreite setStrokeWidth() (setWidth() for a polyline) auf.

Strichmuster

Das Standardmuster für Striche ist für Polylinien und für die Umrisse von Polygonen und Kreisen eine durchgezogene Linie. Du kannst ein benutzerdefiniertes Strichmuster von PatternItem-Objekten festlegen, wobei jedes Element ein Bindestrich, ein Punkt oder eine Lücke ist.

Im folgenden Beispiel wird das Muster für eine Polylinie auf eine wiederholte Sequenz eines Punkts, gefolgt von einer Lücke von 20 Pixeln, einem Bindestrich von 30 Pixeln und einer weiteren Abstand von 20 Pixeln festgelegt.

Java

List<PatternItem> pattern = Arrays.asList(
    new Dot(), new Gap(20), new Dash(30), new Gap(20));
polyline.setPattern(pattern);

Kotlin

val pattern = listOf(
    Dot(), Gap(20F), Dash(30F), Gap(20F)
)
polyline.pattern = pattern

Das Muster wiederholt sich auf der Linie, beginnend mit dem ersten Musterelement am ersten Scheitelpunkt, der für die Form angegeben wird.

Verbindungstypen

Für Polylinien und die Umrisse von Polygonen kannst du eine Abschrägung oder einen runden JointType angeben, um den standardmäßigen Gehrungsverbindungstyp zu ersetzen.

Im folgenden Beispiel wird ein runder Verbindungstyp auf eine Polylinie angewendet:

Java

polyline.setJointType(JointType.ROUND);

Kotlin

polyline.jointType = JointType.ROUND

Der Verbindungstyp wirkt sich auf die internen Biegungen in der Linie aus. Wenn die Linie ein Strichmuster hat, das Bindestriche enthält, wird der Verbindungstyp auch angewendet, wenn ein Bindestrich auf einer Verbindung sitzt. Verbindungstypen wirken sich nicht auf Punkte aus, da sie immer kreisförmig sind.

Zeilenumbruch

Du kannst für jedes Ende einer Polylinie den Stil Cap angeben. Die Optionen sind „Butt“ (Standard), „Square“, „Round“ oder „Benutzerdefinierte Bitmap“. Lege den Stil in PolylineOptions.startCap und PolylineOptions.endCap fest oder verwende die entsprechenden Getter- und Setter-Methoden.

Mit dem folgenden Snippet wird eine runde Kappe auf den Anfang einer Polylinie angewendet.

Java

polyline.setStartCap(new RoundCap());

Kotlin

polyline.startCap = RoundCap()

Mit dem folgenden Snippet wird eine benutzerdefinierte Bitmap für die Kappe am Ende festgelegt:

Java

polyline.setEndCap(
    new CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16));

Kotlin

polyline.endCap = CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16F)

Wenn du eine benutzerdefinierte Bitmap verwendest, musst du eine Referenzstrichbreite in Pixeln angeben. Die API skaliert die Bitmap entsprechend. Die Breite des Referenzstrichs ist die Strichbreite, die du beim Entwerfen des Bitmapbilds für die Kappe in den ursprünglichen Abmessungen des Bilds verwendet hast. Die Standardbreite des Referenzstrichs beträgt 10 Pixel. Tipp: Um die Breite des Referenzstrichs zu ermitteln, öffne dein Bitmapbild mit einem Zoomfaktor von 100 % in einem Bildeditor und stelle die gewünschte Breite des Linienstrichs relativ zum Bild grafisch dar.

Wenn du die Bitmap mit BitmapDescriptorFactory.fromResource() erstellst, verwende eine dichteunabhängige Ressource (nodpi).

Geodätische Segmente

Die geodätische Einstellung kann nur für Polylinien und Polygone verwendet werden. Sie ist nicht auf Kreise anwendbar, weil diese nicht als Gruppe von Segmenten definiert sind.

Mit der geodätischen Einstellung wird bestimmt, wie Liniensegmente zwischen aufeinanderfolgenden Scheitelpunkten der Polylinie bzw. des Polygons gezeichnet werden. Geodätische Segmente folgen der kürzesten Strecke entlang der kugelförmigen Erdoberfläche und werden auf einer Karte mit Mercator-Projektion häufig als Bogenlinien dargestellt. Nicht geodätische Segmente werden auf der Karte als gerade Linien gezeichnet.

Lege diese Eigenschaft im Optionsobjekt der Form fest, indem du *Options.geodesic() aufrufst. true gibt an, dass die Segmente geodätisch zu zeichnen sind, und false, dass die Segmente durch gerade Linien dargestellt werden sollen. Wenn keine Vorgabe erfolgt, gilt die Standardeinstellung false für nicht-geodätische Segmente.

Nach dem Hinzufügen der Form zur Karte kannst du auf die geodätische Einstellung zugreifen, indem du isGeodesic() aufrufst. Rufe zum Ändern der geodätischen Einstellung setGeodesic() auf.

Z-Index

Mit dem Z-Index wird die Stapelreihenfolge einer Form in Relation zu anderen Overlays, d. h. anderen Formen, Boden- und Kachel-Overlays, auf der Karte festgelegt. Ein Overlay mit einem hohen Z-Index wird über Overlays mit niedrigeren Z-Indexen gezeichnet. Zwei Overlays mit demselben Z-Index werden in beliebiger Reihenfolge gezeichnet.

Hinweis: Markierungen werden unabhängig von dem Z-Index der anderen Overlays immer über anderen Overlays gezeichnet.

Lege dieses Attribut für das Optionsobjekt der Form fest, indem *Options.zIndex() aufgerufen wird. Erfolgt keine Vorgabe, gilt der Standard-Z-Index 0. Nach dem Hinzufügen der Form zur Karte kannst du auf den Z-Index zugreifen, indem du getZIndex() aufrufst. Rufe zum Ändern des Z-Index setZIndex() auf.

Sichtbarkeit

Mit der Sichtbarkeit wird festgelegt, ob die Form auf der Karte gezeichnet werden soll. Dabei gibt true an, dass die Form gezeichnet werden soll, und false, dass sie nicht erscheinen soll. Du kannst mit dieser Einstellung die Darstellung einer Form auf der Karte vorübergehend unterbinden. Für eine dauerhafte Entfernung der Form aus der Karte rufst du für die Form den Befehl remove() auf.

Lege dieses Attribut für das Optionsobjekt der Form fest, indem *Options.visible() aufgerufen wird. Wenn keine Vorgabe erfolgt, gilt für die Sichtbarkeit die Standardeinstellung true. Nach dem Hinzufügen der Form zur Karte kannst du auf die Sichtbarkeit zugreifen, indem du isVisible() aufrufst. Rufe zum Ändern der Sichtbarkeit setVisible() auf.

Daten mit einer Form verknüpfen

Du kannst ein beliebiges Datenobjekt mit einer Polylinie, einem Polygon oder einem Kreis mit der Methode setTag() der Form speichern und das Objekt mit getTag() abrufen. Rufe beispielsweise Polyline.setTag() auf, um ein Datenobjekt mit einer Polylinie zu speichern, und Polyline.getTag(), um das Datenobjekt abzurufen.

Der folgende Code definiert ein beliebiges Tag (A) für die angegebene Polylinie:

Java

Polyline polyline = map.addPolyline((new PolylineOptions())
    .clickable(true)
    .add(new LatLng(-35.016, 143.321),
        new LatLng(-34.747, 145.592),
        new LatLng(-34.364, 147.891),
        new LatLng(-33.501, 150.217),
        new LatLng(-32.306, 149.248),
        new LatLng(-32.491, 147.309)));

polyline.setTag("A");

Kotlin

val polyline = map.addPolyline(
    PolylineOptions()
        .clickable(true)
        .add(
            LatLng(-35.016, 143.321),
            LatLng(-34.747, 145.592),
            LatLng(-34.364, 147.891),
            LatLng(-33.501, 150.217),
            LatLng(-32.306, 149.248),
            LatLng(-32.491, 147.309)
        )
)
polyline.tag = "A"

Nachfolgend sind einige Beispiele für Szenarien aufgeführt, in denen es nützlich ist, Daten mit Markierungen zu speichern und abzurufen:

  • Deine App deckt möglicherweise verschiedene Arten von Formen ab, die unterschiedlich behandelt werden sollen, wenn der Nutzer darauf klickt.
  • Du verfügst möglicherweise über eine Schnittstelle mit einem System, in dem es eindeutige Datensatzbezeichner gibt, wobei die Formen spezifische Datensätze in diesem System darstellen.
  • Die Formdaten können eine Priorität angeben, um den Z-Index für die Form zu bestimmen.