L'API di Google Maps per Android offre alcuni modi semplici per aggiungere forme alle mappe al fine di personalizzarle per la tua applicazione.
- Un
Polyline
è una serie di segmenti di linee connesse che possono formare qualsiasi forma desiderata e possono essere utilizzati per contrassegnare percorsi e percorsi sulla mappa. Polygon
è una forma chiusa che può essere utilizzata per contrassegnare le aree sulla mappa.- Una
Circle
è una proiezione geograficamente accurata di un cerchio sulla superficie terrestre tracciata sulla mappa.
Per tutte queste forme, puoi personalizzarne l'aspetto modificando un numero di proprietà.
Esempi di codice
Il tutorial sull'aggiunta di poligoni e polilinee per rappresentare aree e percorsi include tutto il codice per una semplice app per Android.
Inoltre, il repository ApiDemos su GitHub include esempi che dimostrano l'uso delle forme e delle loro caratteristiche:
- CircleDemoActivity (Java / Kotlin): un cerchio
- MetricDemoActivity (Java / Kotlin): poligono
- PolylineDemoActivity (Java / Kotlin): Polyline
Polilinee
La classe Polyline
definisce un insieme di segmenti di linee
connesse sulla mappa. Un oggetto Polyline
è costituito da un insieme di
LatLng
località e crea una serie di segmenti di linee
che collegano tali località in una sequenza ordinata.
Questo video fornisce idee su come aiutare gli utenti a raggiungere la loro destinazione, utilizzando le polilinee per disegnare un percorso sulla mappa.
Per creare una Polyline, crea prima un oggetto PolylineOptions
e aggiungi punti. I punti rappresentano un punto sulla superficie terrestre e sono espressi come oggetti LatLng
. I segmenti della linea vengono disegnati tra i punti in base all'ordine in cui li aggiungi all'oggetto PolylineOptions
.
Per aggiungere punti a un oggetto PolylineOptions
, chiama PolylineOptions.add()
.
Tieni presente che questo metodo utilizza un numero variabile di parametri in modo da poter aggiungere più punti contemporaneamente (puoi anche chiamare PolylineOptions.addAll(Iterable<LatLng>)
se i punti sono già in un elenco).
A questo punto puoi aggiungere la polilinea su una mappa chiamando
GoogleMap.addPolyline(PolylineOptions)
. Il metodo restituisce un oggetto Polyline
con cui puoi modificare la polilinea in un secondo momento.
Il seguente snippet di codice illustra come aggiungere un rettangolo a una mappa:
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)
Il rettangolo viene visualizzato sulla mappa, come mostrato di seguito:
Per modificare la forma della polilinea dopo averla aggiunta, puoi chiamare
Polyline.setPoints()
e fornire un nuovo elenco di punti per la polilinea.
Puoi personalizzare l'aspetto della polilinea sia prima che dopo averla aggiunta alla mappa e dopo averla aggiunta. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.
Personalizzazione di Polyline
Esistono diversi modi per personalizzare l'aspetto delle polilinee:
- Le polilinee multicolori impostano i segmenti polilineali in colori diversi.
- Le polilinee del gradiente colorano una polilinea utilizzando una sfumatura di due colori.
- Le polilinee con timestamp delineano una polilinea utilizzando bitmap ripetute.
Per utilizzare le personalizzazioni di Polyline, devi utilizzare la versione 18.1.0 o successiva dell'SDK Maps per Android e usare il più recente renderer di Maps SDK for Android.
Creazione di una polilinea multicolore
Puoi utilizzare le durate per colorare singolarmente i segmenti di una polilinea, creando oggetti StyleSpan
e aggiungendoli a PolylineOptions
utilizzando i metodi addSpan()
o addSpans()
. Per impostazione predefinita, ogni elemento nell'array imposta il colore del segmento di riga corrispondente. L'esempio seguente mostra l'impostazione dei colori del segmento per creare una polilinea con segmenti rossi e verdi:
Java
Polyline line = map.addPolyline(new PolylineOptions() .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693)) .addSpan(new StyleSpan(Color.RED)) .addSpan(new StyleSpan(Color.GREEN)));
Kotlin
val line = map.addPolyline( PolylineOptions() .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693)) .addSpan(StyleSpan(Color.RED)) .addSpan(StyleSpan(Color.GREEN)) )
Creazione di una polilinea gradiente
Puoi definire un gradiente specificando due numeri interi alfa-rosso-verde-blu (ARGB) a 32 bit, per specificare i colori di inizio e fine del tratto. Imposta questa proprietà sull'oggetto opzioni della forma chiamando PolylineOptions.addSpan()
.
L'esempio seguente mostra la creazione di una polilinea dal gradiente rosso al giallo dallo zoo di Wooddland a Kirkland, WA.
Java
Polyline line = map.addPolyline(new PolylineOptions() .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693)) .addSpan(new StyleSpan(StrokeStyle.gradientBuilder(Color.RED, Color.YELLOW).build())));
Kotlin
val line = map.addPolyline( PolylineOptions() .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693)) .addSpan( StyleSpan( StrokeStyle.gradientBuilder( Color.RED, Color.YELLOW ).build() ) ) )
Creazione di una polilinea stampata
Puoi impostare l'aspetto di una polilinea su una texture di bitmap ricorrente. Per farlo, crea un StampStyle
di TextureStyle
, quindi imposta questa proprietà sull'oggetto delle opzioni della forma chiamando PolylineOptions.addSpan()
come mostrato qui:
Java
StampStyle stampStyle = TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build(); StyleSpan span = new StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build()); map.addPolyline(new PolylineOptions() .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693)) .addSpan(span));
Kotlin
val stampStyle = TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build() val span = StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build()) map.addPolyline( PolylineOptions() .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693)) .addSpan(span) )
Eventi Polilinea
Per impostazione predefinita, le polilinee non sono cliccabili. Puoi abilitare e disabilitare la cliccabilità chiamando Polyline.setClickable(boolean)
.
Utilizza OnPolylineClickListener
per ascoltare gli eventi su una polilinea cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnPolylineClickListener(OnPolylineClickListener)
.
Quando un utente fa clic su una polilinea, ricevi un callback onPolylineClick(Polyline)
.
Poligoni
Gli oggetti Polygon
sono simili agli oggetti Polyline
in quanto sono costituiti da una serie di coordinate in una sequenza ordinata. Tuttavia, invece di essere aperti, i poligoni sono progettati per definire le regioni all'interno di un anello chiuso con l'interno riempito.
Puoi aggiungere una Polygon
alla mappa nello stesso modo in cui aggiungi
un Polyline
. Innanzitutto, crea un oggetto PolygonOptions
e aggiungi alcuni punti. Questi punti forniranno il contorno del poligono.
Poi aggiungi il poligono alla mappa chiamando
GoogleMap.addPolygon(PolygonOptions)
per restituire
un oggetto Polygon
.
Il seguente snippet di codice aggiunge un rettangolo a una mappa.
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)
Per modificare la forma del poligono dopo averlo aggiunto, puoi chiamare Polygon.setPoints()
e fornire un nuovo elenco di punti per il contorno del poligono.
Puoi personalizzare l'aspetto del poligono prima di aggiungerlo alla mappa e dopo che è stato aggiunto alla mappa. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.
Completamento automatico poligono
Il poligono nell'esempio riportato sopra è composto da cinque coordinate, ma tieni presente che la prima e l'ultima coordinate sono nella stessa posizione, cosa che definisce il loop. In pratica, tuttavia, poiché i poligoni definiscono le aree chiuse, non è necessario definire quest'ultima coordinata. Se l'ultima coordinata è diversa dalla prima, l'API "chiude" automaticamente il poligono aggiungendo la prima coordinata alla fine della sequenza di coordinate.
I due poligoni seguenti sono equivalenti e la chiamata a polygon.getPoints()
per ciascuno di essi restituirà tutti e 4 i punti.
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) )
Crea un poligono vuoto
È possibile combinare più percorsi in un singolo oggetto Polygon
per
creare forme complesse, come anelli pieni o "ciambelle" (dove le aree poligonali
vengono visualizzate all'interno del poligono come "isole"). Le forme complesse sono sempre
la composizione di più percorsi, più semplici.
È necessario definire due percorsi nella stessa area. La più grande delle due regioni definisce l'area di riempimento ed è un semplice poligono senza opzioni aggiuntive.
Passa quindi un secondo percorso al metodo addHole()
. Quando il secondo percorso più piccolo è racchiuso dal percorso più grande, sembrerà che una parte del poligono sia stata rimossa. Se il foro si interseca con il contorno del poligono, quest'ultimo verrà visualizzato senza alcun riempimento.
Lo snippet di seguito creerà un singolo rettangolo con un foro rettangolare più piccolo.
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) )
Il poligono cavo appare sulla mappa come mostrato di seguito:
Eventi poligonali
Per impostazione predefinita, non è possibile fare clic sui poligoni. Puoi abilitare e disabilitare la cliccabilità chiamando Polygon.setClickable(boolean)
.
Utilizza una OnPolygonClickListener
per
ascoltare gli eventi relativi a un poligono cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnPolygonClickListener(OnPolygonClickListener)
.
Quando un utente fa clic su un poligono, riceverai un callback onPolygonClick(Polygon)
.
Cerchi
Oltre a una classe generica Polygon
, l'API di Google Maps include anche classi specifiche per gli oggetti Circle
, per semplificarne la costruzione.
Per costruire un cerchio, devi specificare le due proprietà seguenti:
center
comeLatLng
.radius
metri.
Un cerchio viene quindi definito come l'insieme di tutti i punti della superficie terrestre che distano radius
metri dalla center
specificata. A causa del modo in cui la proiezione di Mercatore utilizzata dall'API di Google Maps esegue il rendering di una sfera su una superficie piana, verrà visualizzata come un cerchio quasi perfetto sulla mappa quando si trova vicino all'equatore e apparirà sempre più non circolare (sullo schermo) quando il cerchio si allontana dall'equatore.
Per modificare la forma del cerchio dopo averlo aggiunto, puoi chiamare
Circle.setRadius()
o Circle.setCenter()
e fornire nuovi valori.
Puoi personalizzare l'aspetto del cerchio prima di aggiungerlo alla mappa e dopo che è stato aggiunto alla mappa. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.
Il seguente snippet di codice aggiunge un cerchio alla mappa mediante la creazione di un oggetto
CircleOptions
e la chiamata
GoogleMap.addCircle(CircleOptions)
:
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)
Eventi nel cerchio
Per impostazione predefinita, non è possibile fare clic sulle cerchie. Puoi abilitare e disabilitare la cliccabilità chiamando GoogleMap.addCircle()
con CircleOptions.clickable(boolean)
o chiamando Circle.setClickable(boolean)
.
Utilizza una OnCircleClickListener
per
ascoltare gli eventi di clic su un cerchio cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnCircleClickListener(OnCircleClickListener)
.
Quando un utente fa clic su un cerchio, riceverai un callback onCircleClick(Circle)
, come mostrato nell'esempio di codice seguente:
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 }
Personalizzare gli aspetti
Puoi modificare l'aspetto di una forma prima di averla aggiunta alla mappa (specificando la proprietà desiderata nell'oggetto opzioni) o dopo averla aggiunta alla mappa. Anche i getter sono esposti per tutte le proprietà, in modo da poter accedere facilmente allo stato attuale della forma.
Lo snippet seguente aggiunge una polilinea spessa blu con segmenti geodetici da Mezzanotte a Perth. Nelle sezioni che seguono vengono descritte in modo più dettagliato queste proprietà.
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) )
La mappa viene visualizzata come mostrato di seguito:
Nota: la maggior parte di queste forme può essere applicata a qualsiasi forma descritta, ma alcune proprietà potrebbero non avere senso per determinate forme (ad es. una polilinea non può avere un colore di riempimento perché non ha interni).
Colore tratto
Il colore del tratto è un numero intero alfa-rosso-verde-blu (ARGB) a 32 bit che specifica l'opacità e il colore del tratto. Imposta questa proprietà sull'oggetto opzioni della forma chiamando *Options.strokeColor()
(o PolylineOptions.color()
nel caso di una polilinea). Se non viene specificato, il colore predefinito del tratto è nero (Color.BLACK
).
Dopo che la forma è stata aggiunta alla mappa, il colore del tratto è accessibile chiamando getStrokeColor()
(o getColor()
per una polilinea) e può essere modificato chiamando setStrokeColor()
(setColor() for a polyline
).
Colore riempimento
Il colore di riempimento si applica solo a poligoni e cerchi. Non si applica alle polilinee, in quanto non hanno interni definiti. Per un poligono, le regioni all'interno dei suoi fori non fanno parte dell'interno del poligono e non vengono colorate se viene impostato un colore di riempimento.
Il colore di riempimento è un numero intero alfa-rosso-verde-blu (ARGB) a 32 bit che specifica l'opacità e il colore dell'interno della forma. Imposta questa proprietà sull'oggetto opzioni della forma chiamando *Options.fillColor()
. Se non viene specificato, il colore predefinito del tratto è trasparente (Color.TRANSPARENT
).
Dopo aver aggiunto la forma alla mappa, è possibile accedere al colore di riempimento chiamando getFillColor()
e cambiarlo chiamando setFillColor()
.
Ampiezza tratto
La larghezza del tratto di linea, sotto forma di numero in pixel
(px). La larghezza non viene ridotta quando la mappa viene ingrandita (ovvero, una forma avrà
la stessa larghezza del tratto a tutti i livelli di zoom). Imposta questa proprietà sull'oggetto opzione della forma chiamando *Options.strokeWidth()
(o PolylineOptions.width()
per una polilinea). Se il valore non è specificato, il tratto predefinito è 10 pixel.
Dopo aver aggiunto la forma alla mappa, è possibile accedere alla larghezza del tratto chiamando getStrokeWidth()
(o getWidth()
per una polilinea) e modificare la chiamata chiamando setStrokeWidth()
(setWidth() for a polyline
).
Fantasia
Lo schema tratto predefinito è una linea continua per le polilinee e per il contorno di
poligoni e cerchi. Puoi specificare un pattern di tratto personalizzato degli oggetti PatternItem
, in cui ogni elemento è un trattino, un punto o un intervallo.
Il seguente esempio imposta lo schema per una polilinea su una sequenza ripetuta di un punto, seguita da uno spazio di 20 pixel, un trattino di 30 pixel e un altro spazio di 20 pixel.
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
Il pattern si ripete lungo la linea, iniziando con il primo elemento del pattern al primo vertice specificato per la forma.
Tipi di giunti
Per le polilinee e i contorni dei poligoni, puoi specificare uno smusso o una cornice tonda
JointType
per sostituire il tipo di giunzione fissa predefinita.
Il seguente campione applica un tipo di giunto rotondo a una polilinea:
Java
polyline.setJointType(JointType.ROUND);
Kotlin
polyline.jointType = JointType.ROUND
Il tipo di giunto incide sulle curve interne della linea. Se la linea ha un motivo di tratto che include trattini, il tipo di giunzione si applica anche quando un trattino si trova a cavallo di un giunto. I tipi di giunto non hanno effetto sui punti, poiché sono sempre circolari.
Limiti di riga
Puoi specificare uno stile Cap
per ciascuna estremità di una polilinea. Le opzioni sono Butt (predefinito), quadrato, rotondo o una bitmap personalizzata.
Imposta lo stile in PolylineOptions.startCap
e PolylineOptions.endCap
o utilizza i metodi getter e setter appropriati.
Il seguente snippet specifica un limite di forma tondo all'inizio di una polilinea.
Java
polyline.setStartCap(new RoundCap());
Kotlin
polyline.startCap = RoundCap()
Il seguente snippet specifica una bitmap personalizzata per l'immagine statica finale:
Java
polyline.setEndCap( new CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16));
Kotlin
polyline.endCap = CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16F)
Quando utilizzi una bitmap personalizzata, devi specificare la larghezza del tratto di riferimento in pixel. L'API scala la bitmap di conseguenza. La larghezza del tratto di riferimento è la larghezza del tratto che hai utilizzato durante la progettazione dell'immagine bitmap per il limite, in base alla dimensione originale dell'immagine. La larghezza di riferimento predefinita è di 10 pixel. Suggerimento: per determinare la larghezza del tratto di riferimento, apri l'immagine bitmap con uno zoom del 100% in un editor di immagini e traccia la larghezza desiderata del tratto di linea rispetto all'immagine.
Se utilizzi
BitmapDescriptorFactory.fromResource()
per creare la bitmap, assicurati di utilizzare una risorsa indipendente dalla densità
(nodpi).
Segmenti geodetici
L'impostazione geodetica si applica solo alle polilinee e ai poligoni. Non si applica alle cerchie perché non sono definite come una raccolta di segmenti.
L'impostazione geodetica determina il modo in cui vengono tracciati i segmenti della linea tra i vertici consecutivi della polilinea/poligono. I segmenti geodetici sono quelli che seguono il percorso più breve lungo la superficie della Terra (una sfera) e spesso appaiono come linee curve su una mappa con una proiezione di Mercatore. I segmenti non geodetici sono tracciati come linee rette sulla mappa.
Imposta questa proprietà sull'oggetto opzione della forma chiamando
*Options.geodesic()
dove true
indica che i segmenti devono essere tracciati come
geodetica e false
indica che i segmenti devono essere tracciati come linee rette.
Se non specificati, il valore predefinito è i segmenti non geografici (false
).
Dopo aver aggiunto la forma alla mappa, è possibile accedere all'impostazione geodetica
chiamando isGeodesic()
e modificarla modificando setGeodesic()
.
Z-index
Lo z-index specifica l'ordine di stack di questa forma, rispetto agli altri overlay (altre forme, overlay del suolo e overlay del riquadro) sulla mappa. Un overlay con un indice z elevato viene disegnato sopra gli overlay con z-index inferiori. Due overlay con lo stesso z-index vengono disegnati in ordine arbitrario.
Tieni presente che gli indicatori sono sempre disegnati sopra gli altri overlay, indipendentemente dallo z-index degli altri overlay.
Imposta questa proprietà sull'oggetto opzioni della forma chiamando *Options.zIndex()
.
Se non specificato, lo z-index predefinito è 0
. Dopo che la forma è stata aggiunta alla mappa, è possibile accedere allo z-index chiamando getZIndex()
e cambiarlo chiamando setZIndex()
.
Visibilità
La visibilità specifica se la forma deve essere tracciata sulla mappa, dove
true
indica che deve essere tracciata e false
indica che non deve essere tracciata. Ti consente di non visualizzare temporaneamente una forma sulla mappa. Per rimuovere definitivamente
la forma dalla mappa, chiama remove()
su quella forma.
Imposta questa proprietà sull'oggetto opzioni della forma chiamando
*Options.visible()
. Se non è specificato, la visibilità predefinita è true
.
Dopo aver aggiunto la forma alla mappa, la visibilità è accessibile chiamando isVisible()
e può essere modificata chiamando setVisible()
.
Associare i dati a una forma
Puoi archiviare un oggetto dati arbitrario con una polilinea, un poligono o un cerchio
utilizzando il metodo setTag()
della forma e recuperare l'oggetto utilizzando getTag()
.
Ad esempio, chiama Polyline.setTag()
per archiviare un oggetto dati con una polilinea e chiama Polyline.getTag()
per recuperare l'oggetto dati.
Il codice seguente definisce un tag arbitrario (A
) per la polilinea specificata:
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"
Ecco alcuni esempi di scenari quando è utile archiviare e recuperare dati con forme:
- L'app può adattarsi a diversi tipi di forme e tu vuoi trattarle in modo diverso quando l'utente fa clic sulle forme.
- Potresti visualizzare l'interfaccia con un sistema dotato di identificatori univoci, in cui le forme rappresentano record specifici del sistema.
- I dati della forma possono indicare una priorità per determinare lo z-index per la forma.