Forme

Seleziona la piattaforma: Android iOS JavaScript

L'API Google Maps per Android offre alcuni semplici modi per aggiungere forme alle mappe al fine di personalizzarle per la tua applicazione.

• Un Polyline è una serie di segmenti di linee collegate che possono formare qualsiasi forma tu voglia e possono essere utilizzati per contrassegnare percorsi e percorsi sulla mappa.
• Un Polygon è una forma chiusa che può essere utilizzata per contrassegnare aree sulla mappa.
• L'elemento Circle è la proiezione geograficamente accurata di un cerchio sulla superficie terrestre disegnato sulla mappa.

Puoi personalizzare l'aspetto di tutte queste forme modificando una serie 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 mostrano l'utilizzo delle forme e delle loro funzionalità:

• CircleDemoActivity (Java / Kotlin): Circle
• PolygonDemoActivity (Java / Kotlin): Polygon
• PolylineDemoActivity (Java / Kotlin): Polyline

Polilinee

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

Questo video offre idee su come aiutare gli utenti a raggiungere la destinazione desiderata, utilizzando le polilinee per tracciare un percorso sulla mappa.

Per creare una polilinea, devi prima creare un oggetto PolylineOptions e aggiungere punti. I punti rappresentano un punto sulla superficie terrestre e sono espressi come oggetto LatLng. I segmenti di linea vengono tracciati tra i punti secondo l'ordine in cui li aggiungi all'oggetto PolylineOptions.

Per aggiungere punti a un oggetto PolylineOptions, chiama PolylineOptions.add(). Tieni presente che questo metodo richiede un numero variabile di parametri, in modo da poter aggiungere più punti alla volta (puoi anche chiamare PolylineOptions.addAll(Iterable<LatLng>) se i punti sono già in un elenco).

Dopodiché potrai aggiungere la polilinea a una mappa richiamando 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:

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)

      

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);

      

Il rettangolo viene visualizzato sulla mappa come mostrato di seguito:

Per modificare la forma della polilinea dopo averla aggiunta, puoi richiamare Polyline.setPoints() e fornire un nuovo elenco di punti per la polilinea.

Puoi personalizzare l'aspetto della polilinea sia prima di aggiungerla alla mappa sia dopo che è stata aggiunta alla mappa. Per ulteriori dettagli, consulta la sezione sulla personalizzazione dell'aspetto di seguito.

Personalizzazione polilinea

Esistono diversi modi per personalizzare l'aspetto delle polilinee:

• Polilinee multicolore imposta i segmenti delle polilinee su colori diversi.
• Polilinee con sfumature colorano una polilinea utilizzando una sfumatura di due colori.
• Le polilinee stampate assegnano uno stile a una polilinea mediante bitmap ripetute.

Per utilizzare le personalizzazioni di Polyline, devi utilizzare la versione 18.1.0 o versioni successive di Maps SDK for Android e l'ultima versione del renderer di Maps SDK for Android.

Creazione di una polilinea multicolore

Puoi utilizzare gli intervalli per colorare singolarmente i segmenti di una polilinea, creando oggetti StyleSpan e aggiungendoli a PolylineOptions con i metodi addSpan() o addSpans(). Per impostazione predefinita, ogni elemento nell'array imposta il colore del segmento corrispondente. L'esempio seguente mostra l'impostazione dei colori dei segmenti per creare una polilinea con segmenti rossi e verdi:

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))
)

      

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)));

      

Creazione di una polilinea sfumata

Puoi definire un gradiente specificando due numeri interi ARGB (alfa-rosso-verde-blu) 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 sfumata da rosso a giallo da Woodland Park Zoo a Kirkland, WA.

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()
            )
        )
)

      

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())));

      

Creazione di una polilinea stampata

Puoi impostare l'aspetto di una polilinea su una texture bitmap ripetuta. Per farlo, crea un StampStyle di TextureStyle, poi imposta questa proprietà nell'oggetto opzioni della forma chiamando PolylineOptions.addSpan() come mostrato qui:

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)
)

      

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));

      

Eventi polilinea

Per impostazione predefinita, non è possibile fare clic sulle polilinee. Puoi abilitare e disabilitare la cliccabilità richiamando Polyline.setClickable(boolean).

Utilizza un OnPolylineClickListener per ascoltare gli eventi relativi ai 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ù forme o overlay (indicatori, polilinee, poligoni, cerchi e/o overlay al suolo) vengono sovrapposti, l'evento di clic viene prima attraversato il gruppo di indicatori, quindi viene attivato per altri overlay o forme cliccabili in base ai relativi 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 più bassi. Scopri di più sugli eventi z-index degli indicatori e sui clic.

Poligoni

Gli oggetti Polygon sono simili agli oggetti Polyline in quanto sono costituiti da una serie di coordinate in una sequenza ordinata. Tuttavia, anziché essere aperti, i poligoni sono progettati per definire regioni all'interno di un anello chiuso con l'interno riempito.

Puoi aggiungere un Polygon alla mappa nello stesso modo in cui aggiungi un Polyline. Innanzitutto crea un oggetto PolygonOptions a cui aggiungi alcuni punti. Questi punti formeranno il contorno del poligono. Successivamente, aggiungi il poligono alla mappa richiamando GoogleMap.addPolygon(PolygonOptions), che restituirà un oggetto Polygon.

Il seguente snippet di codice consente di aggiungere un rettangolo a una mappa.

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

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)

      

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);

      

Per modificare la forma del poligono dopo averlo aggiunto, puoi richiamare Polygon.setPoints() e fornire un nuovo elenco di punti per il contorno del poligono.

Puoi personalizzare l'aspetto del poligono sia prima di aggiungerlo alla mappa sia dopo che è stato aggiunto alla mappa. Per ulteriori dettagli, consulta la sezione sulla personalizzazione dell'aspetto di seguito.

Completamento automatico poligono

Nell'esempio precedente, il poligono è costituito da cinque coordinate, ma tieni presente che la prima e l'ultima coordinate corrispondono, il che definisce l'anello. In pratica, tuttavia, poiché i poligoni definiscono 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 richiamando polygon.getPoints() per ognuno di essi verranno restituiti tutti e 4 i punti.

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)
)

      

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));

      

Creare un poligono vuoto

È possibile combinare più percorsi in un singolo oggetto Polygon per creare forme complesse, come anelli pieni o "donut" (in cui le aree poligonali vengono visualizzate all'interno del poligono come "isole"). Le forme complesse sono sempre la composizione di più percorsi più semplici.

Devono essere definiti due percorsi nella stessa area. La più grande tra le due regioni definisce l'area di riempimento ed è un semplice poligono senza opzioni aggiuntive. Quindi, passa un secondo percorso al metodo addHole(). Quando il secondo percorso più piccolo è completamente racchiuso da quello più grande, avrà l'aspetto di una parte del poligono rimossa. Se il foro interseca il contorno del poligono, quest'ultimo verrà visualizzato senza riempimento.

Lo snippet seguente creerà un singolo rettangolo con un foro rettangolare più piccolo.

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)
)

      

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));

      

Il poligono vuoto viene visualizzato sulla mappa come mostrato di seguito:

Eventi Polygon

Per impostazione predefinita, i poligoni non sono cliccabili. Puoi abilitare e disabilitare la cliccabilità richiamando Polygon.setClickable(boolean).

Utilizza un OnPolygonClickListener per ascoltare gli eventi relativi ai clic in 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ù forme o overlay (indicatori, polilinee, poligoni, cerchi e/o overlay al suolo) vengono sovrapposti, l'evento di clic viene prima attraversato il gruppo di indicatori, quindi viene attivato per altri overlay o forme cliccabili in base ai relativi 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 più bassi. Scopri di più sugli eventi z-index degli indicatori e sui clic.

Cerchi

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

Per creare un cerchio, devi specificare queste due proprietà:

• center come LatLng.
• radius in metri.

Un cerchio è quindi l'insieme di tutti i punti sulla superficie terrestre che si trovano a radius metri di distanza dal valore center specificato. Grazie al modo in cui la proiezione di Mercatore utilizzata dall'API di Google Maps mostra una sfera su una superficie piana, questa apparirà come un cerchio quasi perfetto sulla mappa quando si trova vicino all'equatore e apparirà sempre più non circolare (sullo schermo) man mano che 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 sia prima di aggiungerlo alla mappa sia dopo che è stato aggiunto alla mappa. Per ulteriori dettagli, consulta la sezione sulla personalizzazione dell'aspetto di seguito.

Il seguente snippet di codice aggiunge un cerchio alla mappa costruendo un oggetto CircleOptions e chiamando GoogleMap.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)

      

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);

      

Eventi cerchia

Per impostazione predefinita, non è possibile fare clic sui cerchi. Puoi abilitare e disabilitare la cliccabilità chiamando GoogleMap.addCircle() con CircleOptions.clickable(boolean) o chiamando Circle.setClickable(boolean).

Utilizza un OnCircleClickListener per ascoltare gli eventi relativi ai clic in un cerchio cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnCircleClickListener(OnCircleClickListener).

Quando un utente fa clic su una cerchia, ricevi un callback onCircleClick(Circle), come mostrato nel seguente esempio di codice:

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
}

      

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);
    }
});

      

Nota: se più forme o overlay (indicatori, polilinee, poligoni, cerchi e/o overlay al suolo) vengono sovrapposti, l'evento di clic viene prima attraversato il gruppo di indicatori, quindi viene attivato per altri overlay o forme cliccabili in base ai relativi 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 più bassi. Scopri di più sugli eventi z-index degli indicatori e sui clic.

Personalizzazione dell'aspetto

Puoi modificare l'aspetto di una forma sia prima che venga aggiunta alla mappa (specificando la proprietà desiderata nell'oggetto opzioni) sia dopo che sia stata aggiunta alla mappa. Inoltre, 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 blu spessa con segmenti geodetici da Melbourne a Perth. Le sezioni seguenti spiegano queste proprietà in modo più dettagliato.

Kotlin

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

      

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));

      

La mappa viene visualizzata come mostrato di seguito:

Nota: sebbene la maggior parte di queste opzioni possa essere applicata a qualsiasi forma descritta, alcune proprietà potrebbero non essere adatte per determinate forme (ad es. una polilinea non può avere un colore di riempimento perché è priva di un interno).

Colore tratto

Il colore del tratto è un numero intero ARGB a 32 bit alfa-rosso-verde-blu che specifica l'opacità e il colore del tratto della forma. Imposta questa proprietà sull'oggetto opzioni della forma richiamando *Options.strokeColor() (o PolylineOptions.color() nel caso di una polilinea). Se non specificato, il colore predefinito del tratto è nero (Color.BLACK).

Dopo che la forma è stata aggiunta alla mappa, è possibile accedere al colore del tratto 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 ai poligoni e ai cerchi. Non si applica alle polilinee, in quanto non hanno interni definiti. 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 ARGB (alfa-rosso-verde-blu) 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 specificato, il colore predefinito del tratto è trasparente (Color.TRANSPARENT).

Dopo che la forma è stata aggiunta alla mappa, è possibile accedere al colore di riempimento chiamando getFillColor() e può essere modificato chiamando setFillColor().

Ampiezza tratto

La larghezza del tratto di linea, espressa come numero in virgola mobile in pixel (px). La larghezza non viene ridimensionata se viene ingrandito sulla mappa (ad esempio, una forma avrà lo stesso spessore 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 non specificato, il tratto predefinito è di 10 pixel.

Dopo che la forma è stata aggiunta alla mappa, è possibile accedere allo spessore del tratto chiamando getStrokeWidth() (o getWidth() per una polilinea) e può essere modificata chiamando setStrokeWidth() (setWidth() for a polyline).

Sequenza tratto

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

Il seguente esempio imposta il pattern di una polilinea in una sequenza ripetuta di un punto, seguita da uno spazio vuoto di 20 pixel, da un trattino di 30 pixel e da un altro spazio di 20 pixel.

Kotlin

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

      

Java

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

      

Il pattern si ripete lungo la linea, a partire dal primo elemento di pattern al primo vertice specificato per la forma.

Tipi di giunti

Per le polilinee e i contorni dei poligoni, puoi specificare uno smusso o un rotondo JointType per sostituire il tipo di giunzione a mitra fissa predefinita.

Il seguente esempio applica un tipo di giunzione rotondo a una polilinea:

Kotlin

polyline.jointType = JointType.ROUND

      

Java

polyline.setJointType(JointType.ROUND);

      

Il tipo di giunzione influisce sulle curve interne della linea. Se la linea ha uno schema del tratto che include trattini, il tipo di giunzione si applica anche quando un trattino è a cavallo di un'articolazione. I tipi di giunture non influiscono sui punti, poiché sono sempre circolari.

Limiti di riga

Puoi specificare uno stile Cap per ciascuna estremità di una polilinea. Le opzioni sono di testa (predefinita), quadrata, rotondo o bitmap personalizzata. Imposta lo stile in PolylineOptions.startCap e PolylineOptions.endCap oppure utilizza i metodi getter e setter appropriati.

Il seguente snippet specifica un limite rotondo all'inizio di una polilinea.

Kotlin

polyline.startCap = RoundCap()

      

Java

polyline.setStartCap(new RoundCap());

      

Lo snippet seguente specifica una bitmap personalizzata per l'immagine statica finale:

Kotlin

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

      

Java

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

      

Quando utilizzi una bitmap personalizzata, devi specificare lo spessore del tratto di riferimento in pixel. L'API scala la bitmap di conseguenza. Lo spessore del tratto di riferimento è lo spessore del tratto utilizzato durante la progettazione dell'immagine bitmap per il limite, nella dimensione originale dell'immagine. La larghezza del tratto di riferimento predefinita è di 10 pixel. Suggerimento: per determinare lo spessore del tratto di riferimento, apri l'immagine bitmap con lo zoom al 100% in un editor di immagini e traccia la larghezza desiderata del tratto di linea relativa 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 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 o del poligono. I segmenti geodetici sono quelli che seguono il percorso più breve lungo la superficie terrestre (una sfera) e spesso vengono visualizzati come linee curve su una mappa con una proiezione di Mercatore. I segmenti non geodetici vengono disegnati 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 geodetiche e false indica che i segmenti devono essere disegnati come linee rette. Se non specificati, il valore predefinito è rappresentato dai segmenti non geografici (false).

Dopo che la forma è stata aggiunta alla mappa, è possibile accedere all'impostazione geodetica chiamando isGeodesic() e può essere modificata chiamando setGeodesic().

Z-index

Lo z-index specifica l'ordine di sovrapposizione di questa forma rispetto ad altri overlay (altre forme, overlay al suolo e overlay di riquadri) sulla mappa. Un overlay con uno z-index elevato viene disegnato sopra gli overlay con z-index più bassi. Due overlay con lo stesso z-index vengono tracciati in un ordine arbitrario.

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, il valore predefinito dello z-index è 0. Dopo che la forma è stata aggiunta alla mappa, è possibile accedere allo z-index chiamando getZIndex() e può essere modificato chiamando setZIndex().

Visibilità

La visibilità specifica se la forma deve essere disegnata sulla mappa, dove true indica che deve essere tracciata, mentre false indica che non deve essere tracciata. 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 richiamando *Options.visible(). Se non specificato, la visibilità predefinita è true. Dopo che la forma è stata aggiunta alla mappa, la visibilità è accessibile chiamando isVisible() e può essere modificata chiamando setVisible().

Associare 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:

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"

      

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");

      

Di seguito sono riportati alcuni esempi di scenari in cui è utile archiviare e recuperare dati con forme:

• La tua app può adattarsi a diversi tipi di forme e vuoi trattarle in modo diverso quando l'utente le fa clic.
• Potresti interfacciarti con un sistema che ha identificatori di record univoci in cui le forme rappresentano record specifici.
• I dati di forma possono indicare una priorità per determinare lo z-index per la forma.