Shapes

Seleziona piattaforma: Android iOS JavaScript

L'API di Google Maps per Android offre alcuni modi semplici per aggiungere forme alle mappe e personalizzarle per l'applicazione.

• Una Polyline è una serie di segmenti di linee collegate che possono formare qualsiasi forma desiderata e possono essere utilizzati per contrassegnare percorsi e percorsi sulla mappa.
• Una Polygon è una forma racchiusa da utilizzare 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 Android.

Inoltre, il repository APIDemos su GitHub include esempi che dimostrano l'uso delle forme e delle loro funzionalità:

• CircleDemoActivity (Java / Kotlin): cerchio
• MetricDemoActivity (Java / Kotlin): poligono
• PolylineDemoActivity (Java / Kotlin): polilinea

Polilinee

La classe Polyline definisce un insieme di segmenti di linee collegate sulla mappa. Un oggetto Polyline è costituito da un insieme di località LatLng e crea una serie di segmenti di linee che collegano queste località in una sequenza ordinata.

Questo video offre 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 accetta un numero variabile di parametri, quindi puoi aggiungere più punti alla volta (puoi anche chiamare PolylineOptions.addAll(Iterable<LatLng>) se i punti sono già in un elenco).

Puoi quindi aggiungere la polilinea a 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 che è stata aggiunta, puoi chiamare Polyline.setPoints() e fornire un nuovo elenco di punti per la polilinea.

Puoi personalizzare l'aspetto della polilinea sia prima che alla mappa e dopo che è stato aggiunto alla mappa. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.

Personalizzazione di polilinea

Esistono diversi modi per personalizzare l'aspetto delle polilinee:

• Le polilinee multicolori impostano i segmenti polilineali in colori diversi.
• Le polilinee sfumate colorano una polilinea utilizzando un gradiente di due colori.
• polilinee fissate per applicare uno stile a una polilinea utilizzando bitmap ripetute.

Per utilizzare le personalizzazioni di Polyline, devi utilizzare 18.1.0 o versioni successive dell'SDK di Maps per Android e usare il più recente renderer di Maps per l'SDK di Android.

Creazione di una polilinea multicolore

Puoi utilizzare le sezioni per colorare singolarmente i segmenti di una polilinea creando oggetti StyleSpan e aggiungendoli a PolylineOptions mediante i metodi addSpan() o addSpans(). Per impostazione predefinita, ogni elemento dell'array imposta il colore del segmento di linea corrispondente. L'esempio seguente mostra l'impostazione dei colori dei segmenti 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 alfa-rosso-verde-blu (ARGB) a 32 bit per specificare i colori di inizio e fine del tratto. Imposta questa proprietà nell'oggetto opzioni della forma chiamando PolylineOptions.addSpan(). L'esempio seguente mostra come creare una polilinea con gradiente da rosso a giallo da Woodland Park Zoo 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()
            )
        )
)

      

Creare una polilinea stampata

Puoi impostare l'aspetto di una polilinea su una texture bitmap ricorrente. Per farlo, crea una 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 Poliline

Per impostazione predefinita, le polilinee non sono cliccabili. Puoi attivare e disattivare la cliccabilità chiamando Polyline.setClickable(boolean).

Utilizza una OnPolylineClickListener per ascoltare gli eventi di clic 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).

Nota: se più overlay o forme (indicatori, polilinee, poligoni, cerchi e/o overlay del terreno) vengono sovrapposto uno sopra l'altro, l'evento di clic viene visualizzato prima in loop nel cluster di indicatori, poi viene attivato per altri overlay o forme cliccabili in base ai loro valori z-index. Viene attivato al massimo un evento per clic. In altre parole, il clic non viene trasmesso agli overlay o alle forme con valori z-index inferiori. Scopri di più sugli indicatori z-index e sugli eventi di clic.

Poligoni

Gli oggetti Polygon sono simili agli oggetti Polyline in quanto sono costituiti da una serie di coordinate in sequenza ordinata. Tuttavia, invece di essere aperti, i poligoni sono progettati per definire le aree geografiche in un anello chiuso con gli interni riempiti.

Puoi aggiungere Polygon alla mappa nello stesso modo in cui aggiungi Polyline. Per prima cosa, crea un oggetto PolygonOptions e aggiungi alcuni punti. Questi punti forniranno il contorno del poligono. Quindi, 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.

Nota: poiché non hai definito un colore di riempimento e il colore predefinito è trasparente, questo rettangolo viene visualizzato esattamente come il rettangolo della polilinea dello snippet nella sezione precedente.

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 averla aggiunta, 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 averlo aggiunto alla mappa. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.

Completamento automatico per poligono

Nell'esempio precedente il poligono è composto da cinque coordinate, ma nota che la prima e l'ultima sono le stesse coordinate, che definisce il ciclo. In pratica, però, dato che i poligoni definiscono le aree chiuse, non è necessario definire quest'ultima coordinata. Se l'ultima coordinata è diversa dalla prima, l'API "chiuderà" automaticamente il poligono aggiungendo la prima coordinata alla fine della sequenza di coordinate.

I due poligoni seguenti sono equivalenti e se richiami polygon.getPoints() per ciascuno di essi verranno restituiti tutti e quattro 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)
)

      

Creare un poligono vuoto

È possibile combinare più percorsi in un singolo oggetto Polygon per creare forme complesse, come anelli riempiti 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. L'area più grande delle due regioni definisce l'area di riempimento ed è un poligono semplice senza opzioni aggiuntive. Quindi, passa 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 interseca il contorno del poligono, il rendering del poligono verrà eseguito 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 vuoto viene visualizzato sulla mappa come mostrato di seguito:

Eventi per poligoni

Per impostazione predefinita, i poligoni non sono cliccabili. Puoi attivare e disattivare la cliccabilità chiamando Polygon.setClickable(boolean).

Utilizza una OnPolygonClickListener per ascoltare gli eventi di clic su un poligono cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnPolygonClickListener(OnPolygonClickListener). Quando un utente fa clic su un poligono, ricevi un callback onPolygonClick(Polygon).

Nota: se più overlay o forme (indicatori, polilinee, poligoni, cerchi e/o overlay del terreno) vengono sovrapposto uno sopra l'altro, l'evento di clic viene visualizzato prima in loop nel cluster di indicatori, poi viene attivato per altri overlay o forme cliccabili in base ai loro valori z-index. Viene attivato al massimo un evento per clic. In altre parole, il clic non viene trasmesso agli overlay o alle forme con valori z-index inferiori. Scopri di più sugli indicatori z-index e sugli eventi di clic.

Cerchi

Oltre a una classe Polygon generica, l'API di Google Maps include anche classi specifiche per gli oggetti Circle, per semplificarne la realizzazione.

Per costruire un cerchio, devi specificare le due proprietà seguenti:

• center come LatLng.
• radius metri.

Un cerchio viene quindi definito come l'insieme di tutti i punti sulla superficie terrestre che si trovano a radius metri dall'center specificato. 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 verrà visualizzata sempre più non circolare (sullo schermo) quando il cerchio si allontana dall'equatore.

Per modificare la forma del cerchio dopo averla aggiunta, puoi chiamare Circle.setRadius() o Circle.setCenter() e fornire nuovi valori.

Puoi personalizzare l'aspetto del cerchio prima di aggiungerlo alla mappa e dopo averlo 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 creando un oggetto CircleOptions e chiamando 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 attivare e disattivare 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 una cerchia, ricevi una chiamata onCircleClick(Circle), come mostrato nel seguente esempio di codice:

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
}

      

Nota: se più overlay o forme (indicatori, polilinee, poligoni, cerchi e/o overlay del terreno) vengono sovrapposto uno sopra l'altro, l'evento di clic viene visualizzato prima in loop nel cluster di indicatori, poi viene attivato per altri overlay o forme cliccabili in base ai loro valori z-index. Viene attivato al massimo un evento per clic. In altre parole, il clic non viene trasmesso agli overlay o alle forme con valori z-index inferiori. Scopri di più sugli indicatori z-index e sugli eventi di clic.

Personalizzare gli aspetti

Puoi modificare l'aspetto di una forma prima che venga aggiunta alla mappa (specificando la proprietà desiderata nell'oggetto options) o dopo che è stata aggiunta alla mappa. I getter sono esposti anche per tutte le proprietà, così puoi accedere facilmente allo stato attuale della forma.

Lo snippet seguente aggiunge una polilinea spessa blu con segmenti geodetici da Mboubourne a Perth. Le sezioni seguenti spiegano queste proprietà in modo più dettagliato.

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 una qualsiasi delle forme descritte, ma alcune proprietà potrebbero non avere senso per alcune forme (ad esempio, una polilinea non può avere un colore di riempimento perché non ha un interno).

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 della forma. Imposta questa proprietà nell'oggetto delle 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 aver aggiunto la forma alla mappa, è possibile accedere al colore del tratto chiamando getStrokeColor() (o getColor() per una polilinea) e modificando il numero 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 saranno colorate se è impostato un colore di riempimento.

Il colore di riempimento è un numero intero alpha-red-green-blue (ARGB) a 32 bit che specifica l'opacità e il colore dell'interno della forma. Imposta questa proprietà nell'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 modificare il numero setFillColor().

Ampiezza tratto

La larghezza del tratto di linea, come un numero in pixel di pixel (px). La larghezza non viene ridimensionata quando la mappa viene ingrandita, ad es. una forma avrà la stessa larghezza del tratto a tutti i livelli di zoom. Imposta questa proprietà nell'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 chiamando setStrokeWidth() (setWidth() for a polyline).

Sequenza tratto

Il pattern predefinito del tratto è una linea continua per le polilinee e per i contorni di poligoni e cerchi. Puoi specificare uno schema tratto personalizzato di oggetti PatternItem, in cui ogni elemento è un trattino, un punto o uno spazio.

Il seguente esempio imposta il pattern per una polilinea su una sequenza ripetuta di un punto, seguita da uno spazio di 20 pixel, da un trattino di 30 pixel e da 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, a partire dal primo elemento del pattern nel primo vertice specificato per la forma.

Tipi di giunti

Per le polilinee e i contorni dei poligoni, puoi specificare una smussatura o un arrotondamento JointType per sostituire il tipo di giunzione fissa predefinita.

Il seguente campione applica un tipo di giunzione tonda a una polilinea:

Java

polyline.setJointType(JointType.ROUND);

      

Kotlin

polyline.jointType = JointType.ROUND

      

Il tipo di giunzione influisce 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 un incrocio. I tipi di unione non hanno effetto sui punti, dato che 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 bitmap personalizzato. Imposta lo stile in PolylineOptions.startCap e PolylineOptions.endCap oppure utilizza i metodi getter e setter appropriati.

Lo snippet seguente specifica un limite 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 usi una bitmap personalizzata, devi specificare una larghezza del tratto di riferimento in pixel. L'API scala la bitmap di conseguenza. La larghezza del tratto di riferimento è la larghezza del tratto utilizzata per la progettazione dell'immagine bitmap per il limite, nella dimensione originale dell'immagine. La larghezza di riferimento predefinita è 10 pixel. Suggerimento: per determinare la larghezza del tratto di riferimento, apri l'immagine bitmap con uno zoom pari al 100% in un editor di immagini e traccia la larghezza desiderata del tratto della linea relativa all'immagine.

Se usi BitmapDescriptorFactory.fromResource() per creare la bitmap, assicurati di utilizzare una risorsa indipendente dalla densità (nodpi).

Segmenti geodetici

L'impostazione geodetica si applica solo a polilinee e poligoni. Non si applica alle cerchie perché non sono definite come una raccolta di segmenti.

L'impostazione geodetica determina il modo in cui vengono disegnati i segmenti di linea tra vertici consecutivi della polilinea/poligono. I segmenti geodetici sono quelli che seguono il percorso più breve lungo la superficie terrestre (una sfera) e spesso appaiono come linee curve su una mappa con una proiezione di Mercatore. I segmenti non geodetici vengono 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 disegnati come geodetici e false indica che i segmenti devono essere disegnati come linee rette. Se non vengono specificati, i valori predefiniti sono segmenti non geodetici (false).

Dopo aver aggiunto la forma alla mappa, è possibile accedere all'impostazione geodetica chiamando isGeodesic() e modificando setGeodesic().

Z-index

Lo z-index specifica l'ordine di stack di questa forma, rispetto agli altri overlay (altre forme, overlay al suolo e overlay a riquadro) sulla mappa. Gli overlay con uno z-index elevato vengono disegnati sopra gli overlay con z-index più bassi. Due overlay con lo stesso z-index vengono disegnati in ordine arbitrario.

Tieni presente che gli indicatori vengono 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 viene specificato, il valore z-index predefinito è 0. Dopo aver aggiunto la forma alla mappa, è possibile accedere a z-index tramite la chiamata a getZIndex() e l'operazione può essere modificata chiamando setZIndex().

Visibilità

La visibilità specifica se la forma deve essere tracciata sulla mappa, dove true indica che deve essere tracciata e false 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à nell'oggetto opzioni della forma chiamando *Options.visible(). Se non viene specificata, la visibilità predefinita è true. Dopo aver aggiunto la forma alla mappa, la visibilità è accessibile chiamando isVisible() e può essere modificata chiamando setVisible().

Associare dati a una forma

Puoi memorizzare un oggetto di dati arbitrario con una polilinea, un poligono o un cerchio utilizzando il metodo setTag() della forma e recuperarlo 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"

      

Di seguito sono riportati alcuni esempi di scenari utili per archiviare e recuperare dati con le forme:

• L'app può soddisfare diversi tipi di forme e vuoi trattarli in modo diverso quando l'utente fa clic su di essi.
• Potresti interfacciarti con un sistema con identificatori di record univoci, in cui le forme rappresentano record specifici di quel sistema.
• I dati della forma possono indicare una priorità per determinare lo z-index per la forma.