Kształty

Interfejs API Map Google na Androida zapewnia proste sposoby na dodawanie kształtów do map w celu dostosowania ich do aplikacji.

• Polyline to seria połączonych odcinków, które mogą tworzyć dowolny kształt i mogą być używane do oznaczania ścieżek i tras na mapie.
• Polygon to zamknięty kształt, którego można używać do zaznaczania obszarów na mapie.
• Circle to dokładne geograficznie odwzorowanie okręgu na powierzchni Ziemi narysowane na mapie.

Możesz dostosować wygląd wszystkich tych kształtów przez zmianę szeregu właściwości.

Przykładowe fragmenty kodu

Samouczek dotyczący dodawania wielokątów i linii łamanych do przedstawiania obszarów i tras zawiera cały kod prostej aplikacji na Androida.

Dodatkowo repozytorium ApiDemos na GitHubie zawiera przykłady pokazujące, jak używać kształtów i ich funkcji:

• CircleDemoActivity (Java / Kotlin): okrąg
• PolygonDemoActivity (Java / Kotlin): wielokąt
• PolylineDemoActivity (Java / Kotlin): linia łamana

Linie łamane

Klasa Polyline definiuje zbiór połączonych odcinków linii na mapie. Obiekt Polyline składa się ze zbioru lokalizacji LatLng i tworzy serię odcinków, które łączą te lokalizacje w uporządkowaną sekwencję.

Z tego filmu dowiesz się, jak pomóc użytkownikom dotrzeć do celu, rysując ścieżkę na mapie za pomocą linii łamanych.

Aby utworzyć obiekt Polyline, najpierw utwórz obiekt PolylineOptions i dodaj do niego punkty. Punkty reprezentują punkt na powierzchni Ziemi i są wyrażone jako obiekt LatLng. Odcinki są rysowane między punktami w kolejności, w jakiej dodajesz je do obiektu PolylineOptions.

Aby dodać punkty do obiektu PolylineOptions, wywołaj PolylineOptions.add(). Zauważ, że ta metoda przyjmuje zmienną liczbę parametrów, dzięki czemu możesz dodać wiele punktów naraz (możesz też wywołać PolylineOptions.addAll(Iterable<LatLng>), jeśli punkty są już na liście).

Następnie możesz dodać linię łamaną do mapy, wywołując funkcję GoogleMap.addPolyline(PolylineOptions). Metoda zwraca obiekt Polyline, za pomocą którego możesz później zmienić polilinię.

Poniższy fragment kodu pokazuje, jak dodać prostokąt do mapy:

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

      

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

      

Prostokąt pojawi się na mapie, jak pokazano poniżej:

Aby zmienić kształt polilinii po jej dodaniu, możesz wywołać metodę Polyline.setPoints() i podać nową listę punktów polilinii.

Wygląd linii łamanej możesz dostosować zarówno przed dodaniem jej do mapy, jak i po jej dodaniu. Więcej informacji znajdziesz w sekcji Dostosowywanie wyglądu poniżej.

Dostosowywanie linii łamanej

Wygląd linii łamanych możesz dostosować na kilka sposobów:

• Wielokolorowe linie łamane ustawiają segmenty linii łamanej na różne kolory.
• Polilinie gradientowe kolorują linię łamaną za pomocą gradientu składającego się z 2 kolorów.
• Linie łamane ze wzorem to linie łamane, które są stylizowane za pomocą powtarzających się bitmap.

Aby korzystać z dostosowywania linii łamanych, użyj pakietu Maps SDK na Androida w wersji 18.1.0 lub nowszej i najnowszego mechanizmu renderowania pakietu Maps SDK na Androida.

Tworzenie wielokolorowej linii łamanej

Możesz użyć rozpiętości, aby indywidualnie pokolorować segmenty linii łamanej, tworząc obiekty StyleSpan i dodając je do PolylineOptions za pomocą metod addSpan() lub addSpans(). Domyślnie każdy element w tablicy ustawia kolor odpowiedniego segmentu linii. W przykładzie poniżej pokazujemy, jak ustawić kolory segmentów, aby utworzyć linię łamaną z czerwonymi i zielonymi segmentami:

val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(StyleSpan(Color.RED))
        .addSpan(StyleSpan(Color.GREEN)),
)

      

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

      

Tworzenie linii łamanej z gradientem

Gradient możesz zdefiniować, podając 2 32-bitowe liczby całkowite ARGB (alfa-czerwony-zielony-niebieski), które określają początkowy i końcowy kolor obrysu. Ustaw tę właściwość w obiekcie opcji kształtu, wywołując PolylineOptions.addSpan(). W przykładzie poniżej pokazujemy, jak utworzyć linię łamaną z gradientem od czerwonego do żółtego, która prowadzi z ZOO Woodland Park do Kirkland, WA.

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

      

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

      

Tworzenie linii łamanej ze stemplem

Możesz ustawić wygląd linii łamanej jako powtarzającą się teksturę bitmapową. W tym celu utwórz obiekt StampStyle typu TextureStyle, a następnie ustaw tę właściwość w obiekcie opcji kształtu, wywołując metodę PolylineOptions.addSpan(), jak pokazano poniżej:

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

      

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

      

Zdarzenia dotyczące linii łamanej

Domyślnie polilinii nie można klikać. Możesz włączyć i wyłączyć klikalność, wywołując funkcję Polyline.setClickable(boolean).

Użyj OnPolylineClickListener, aby nasłuchiwać zdarzeń kliknięcia na klikalnej linii łamanej. Aby ustawić ten detektor na mapie, wywołaj GoogleMap.setOnPolylineClickListener(OnPolylineClickListener). Gdy użytkownik kliknie linię łamaną, otrzymasz wywołanie zwrotne onPolylineClick(Polyline).

Wielokąty

Obiekty Polygon są podobne do obiektów Polyline, ponieważ składają się z serii współrzędnych w uporządkowanej sekwencji. Jednak w odróżnieniu od linii łamanych wielokąty są zaprojektowane tak, aby definiować regiony w zamkniętej pętli z wypełnionym wnętrzem.

Możesz dodać Polygon do mapy w taki sam sposób, jak dodajesz Polyline. Najpierw utwórz obiekt PolygonOptions i dodaj do niego kilka punktów. Te punkty będą tworzyć kontur wielokąta. Następnie dodajesz wielokąt do mapy, wywołując metodę GoogleMap.addPolygon(PolygonOptions), która zwraca obiekt Polygon.

Poniższy fragment kodu dodaje prostokąt do mapy.

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

      

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

      

Aby zmienić kształt wielokąta po jego dodaniu, możesz wywołać funkcję Polygon.setPoints() i podać nową listę punktów dla konturu wielokąta.

Wygląd wielokąta możesz dostosować zarówno przed dodaniem go do mapy, jak i po dodaniu. Więcej informacji znajdziesz w sekcji Dostosowywanie wyglądu poniżej.

Autouzupełnianie wielokątów

Wielokąt w powyższym przykładzie składa się z 5 współrzędnych, ale zwróć uwagę, że pierwsza i ostatnia współrzędna to ta sama lokalizacja, która definiuje pętlę. W praktyce jednak, ponieważ wielokąty definiują zamknięte obszary, nie musisz definiować tej ostatniej współrzędnej. Jeśli ostatnia współrzędna różni się od pierwszej, interfejs API automatycznie „zamknie” wielokąt, dodając pierwszą współrzędną na końcu sekwencji współrzędnych.

Poniższe 2 wielokąty są równoważne, a wywołanie funkcji polygon.getPoints() dla każdego z nich zwróci wszystkie 4 punkty.

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

      

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

      

Tworzenie wielokąta z otworem

W jednym obiekcie Polygon można połączyć wiele ścieżek, aby utworzyć złożone kształty, takie jak wypełnione pierścienie lub „pączki” (gdzie obszary wielokątne pojawiają się wewnątrz wielokąta jako „wyspy”). Złożone kształty zawsze składają się z wielu prostszych ścieżek.

W tym samym obszarze muszą być zdefiniowane 2 ścieżki. Większy z tych 2 regionów definiuje obszar wypełnienia i jest prostym wielokątem bez dodatkowych opcji. Następnie przekaż drugą ścieżkę do metody addHole(). Gdy druga, mniejsza ścieżka jest całkowicie zamknięta w większej ścieżce, wygląda to tak, jakby fragment wielokąta został usunięty. Jeśli otwór przecina kontur wielokąta, wielokąt zostanie wyrenderowany bez wypełnienia.

Poniższy fragment kodu utworzy pojedynczy prostokąt z mniejszym prostokątnym otworem.

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

      

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

      

Pusty wielokąt pojawi się na mapie w sposób pokazany poniżej:

Zdarzenia Polygon

Domyślnie wielokąty nie są klikalne. Możesz włączyć i wyłączyć klikalność, wywołując funkcję Polygon.setClickable(boolean).

Użyj OnPolygonClickListener, aby nasłuchiwać zdarzeń kliknięcia na klikalnym wielokącie. Aby ustawić ten detektor na mapie, wywołaj GoogleMap.setOnPolygonClickListener(OnPolygonClickListener). Gdy użytkownik kliknie wielokąt, otrzymasz wywołanie zwrotne onPolygonClick(Polygon).

Kręgi

Oprócz ogólnej klasy Polygon interfejs API Map Google zawiera też klasy przeznaczone dla obiektów Circle, co upraszcza ich tworzenie.

Aby utworzyć okrąg, musisz określić te 2 właściwości:

• center jako LatLng.
• radius w metrach.

Okrąg jest definiowany jako zbiór wszystkich punktów na powierzchni Ziemi, które znajdują się w odległości radius metrów od danego punktu center. Ze względu na sposób, w jaki odwzorowanie walcowe równokątne używane przez interfejs API Map Google renderuje kulę na płaskiej powierzchni, okrąg będzie wyglądał na mapie jak niemal idealny, gdy będzie znajdował się w pobliżu równika, i będzie coraz mniej okrągły (na ekranie), gdy będzie się od niego oddalał.

Aby zmienić kształt okręgu po jego dodaniu, możesz wywołać funkcję Circle.setRadius() lub Circle.setCenter() i podać nowe wartości.

Wygląd okręgu możesz dostosować zarówno przed dodaniem go do mapy, jak i po dodaniu. Więcej informacji znajdziesz w sekcji Dostosowywanie wyglądu poniżej.

Poniższy fragment kodu dodaje okrąg do mapy, tworząc obiekt CircleOptions i wywołując GoogleMap.addCircle(CircleOptions):

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

      

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

      

Wydarzenia w kręgu

Domyślnie kółka nie są klikalne. Możesz włączyć lub wyłączyć możliwość klikania, wywołując GoogleMap.addCircle() z CircleOptions.clickable(boolean) lub wywołując Circle.setClickable(boolean).

Użyj OnCircleClickListener, aby nasłuchiwać zdarzeń kliknięcia na klikalnym okręgu. Aby ustawić ten detektor na mapie, wywołaj GoogleMap.setOnCircleClickListener(OnCircleClickListener).

Gdy użytkownik kliknie okrąg, otrzymasz wywołanie zwrotne onCircleClick(Circle), jak pokazano w tym przykładowym kodzie:

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
}

      

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

      

Dostosowywanie wyglądu

Wygląd kształtu możesz zmienić zarówno przed dodaniem go do mapy (przez określenie odpowiedniej właściwości w obiekcie opcji), jak i po dodaniu go do mapy. Dla wszystkich właściwości są też dostępne metody pobierające, dzięki czemu można łatwo uzyskać dostęp do bieżącego stanu kształtu.

Poniższy fragment kodu dodaje grubą niebieską linię łamaną z segmentami geodezyjnymi z Melbourne do Perth. W sekcjach poniżej znajdziesz więcej informacji o tych właściwościach.

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

      

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

      

Mapa wygląda tak:

Uwaga: większość z nich można zastosować do dowolnego z opisanych kształtów, ale niektóre właściwości mogą nie mieć sensu w przypadku niektórych kształtów (np. łamana nie może mieć koloru wypełnienia, ponieważ nie ma wnętrza).

Kolor kreski

Kolor obrysu to 32-bitowa liczba całkowita ARGB (alfa-czerwony-zielony-niebieski) określająca przezroczystość i kolor obrysu kształtu. Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.strokeColor() (lub PolylineOptions.color() w przypadku linii łamanej). Jeśli nie określono inaczej, domyślny kolor obrysu to czarny (Color.BLACK).

Po dodaniu kształtu do mapy możesz uzyskać dostęp do koloru obrysu, wywołując funkcję getStrokeColor() (lub getColor() w przypadku linii łamanej), i zmienić go, wywołując funkcję setStrokeColor() (setColor() for a polyline).

Kolor wypełnienia

Kolor wypełnienia dotyczy tylko wielokątów i okręgów. Nie dotyczy to linii łamanych, ponieważ nie mają one zdefiniowanych wnętrz. W przypadku wielokąta regiony wewnątrz jego otworów nie są częścią jego wnętrza i nie zostaną pokolorowane, jeśli ustawiony jest kolor wypełnienia.

Kolor wypełnienia to 32-bitowa liczba całkowita w formacie ARGB (alfa-czerwony-zielony-niebieski) określająca przezroczystość i kolor wnętrza kształtu. Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.fillColor(). Jeśli nie określono inaczej, domyślny kolor obrysu jest przezroczysty (Color.TRANSPARENT).

Po dodaniu kształtu do mapy możesz uzyskać dostęp do koloru wypełnienia, wywołując metodę getFillColor(), i zmienić go, wywołując metodę setFillColor().

Szerokość kreski

Szerokość linii jako liczba zmiennoprzecinkowa w pikselach (px). Szerokość nie zmienia się, gdy mapa jest powiększana (tzn. kształt będzie miał taką samą szerokość obrysu na wszystkich poziomach powiększenia). Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.strokeWidth() (lub PolylineOptions.width() w przypadku linii łamanej). Jeśli nie zostanie określona, domyślna szerokość obrysu to 10 pikseli.

Po dodaniu kształtu do mapy szerokość obrysu można uzyskać, wywołując funkcję getStrokeWidth() (lub getWidth() w przypadku linii łamanej), i zmienić, wywołując funkcję setStrokeWidth() (setWidth() for a polyline).

Wzór obrysu

Domyślny wzór obrysu to linia ciągła w przypadku linii łamanych oraz konturów wielokątów i okręgów. Możesz określić niestandardowy wzór obrysu obiektów PatternItem, gdzie każdy element jest kreską, kropką lub przerwą.

Poniższy przykład ustawia wzór linii łamanej na powtarzającą się sekwencję kropki, po której następuje odstęp o długości 20 pikseli, kreska o długości 30 pikseli i kolejny odstęp o długości 20 pikseli.

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

      

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

      

Wzór powtarza się wzdłuż linii, zaczynając od pierwszego elementu wzoru w pierwszym wierzchołku określonym dla kształtu.

Typy połączeń

W przypadku linii łamanych i konturów wielokątów możesz określić ścięcie lub zaokrąglenie JointType, aby zastąpić domyślny stały typ połączenia pod kątem.

W tym przykładzie do polilinii zastosowano zaokrąglone połączenie:

polyline?.jointType = JointType.ROUND

      

polyline.setJointType(JointType.ROUND);

      

Typ połączenia wpływa na wewnętrzne zagięcia linii. Jeśli linia ma wzór obrysu, który zawiera kreski, typ połączenia jest stosowany również wtedy, gdy kreska znajduje się na połączeniu. Typy połączeń nie mają wpływu na kropki, ponieważ są one zawsze okrągłe.

Zakończenia linii

Możesz określić styl Cap dla każdego końca linii łamanej. Dostępne opcje to: płaskie (domyślnie), kwadratowe, okrągłe lub niestandardowa bitmapa. Ustaw styl w PolylineOptions.startCap i PolylineOptions.endCap lub użyj odpowiednich metod pobierających i ustawiających.

Poniższy fragment kodu określa okrągłe zakończenie na początku linii łamanej.

polyline?.startCap = RoundCap()

      

polyline.setStartCap(new RoundCap());

      

Ten fragment kodu określa niestandardową bitmapę dla zakończenia:

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

      

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

      

Jeśli używasz niestandardowej mapy bitowej, musisz określić szerokość obrysu odniesienia w pikselach. Interfejs API odpowiednio skaluje bitmapę. Referencyjna szerokość obrysu to szerokość obrysu użyta podczas projektowania obrazu bitmapowego dla zakończenia w oryginalnym wymiarze obrazu. Domyślna szerokość linii odniesienia to 10 pikseli. Wskazówka: aby określić referencyjną szerokość obrysu, otwórz obraz bitmapowy w edytorze obrazów w powiększeniu 100% i narysuj żądaną szerokość obrysu linii względem obrazu.

Jeśli do utworzenia bitmapy używasz BitmapDescriptorFactory.fromResource(), upewnij się, że używasz zasobu niezależnego od gęstości (nodpi).

Segmenty geodezyjne

Ustawienie geodezyjne dotyczy tylko linii łamanych i wielokątów. Nie dotyczy to okręgów, ponieważ nie są one zdefiniowane jako zbiór segmentów.

Ustawienie geodezyjne określa sposób rysowania odcinków linii między kolejnymi wierzchołkami linii łamanej lub wielokąta. Odcinki geodezyjne to takie, które podążają najkrótszą ścieżką wzdłuż powierzchni Ziemi (kuli) i często pojawiają się jako zakrzywione linie na mapie z odwzorowaniem Mercatora. Segmenty niegeodezyjne są rysowane na mapie jako linie proste.

Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.geodesic(), gdzie true oznacza, że segmenty powinny być rysowane jako linie geodezyjne, a false oznacza, że segmenty powinny być rysowane jako linie proste. Jeśli nie zostanie określony, domyślnie będą to segmenty niegeodezyjne (false).

Po dodaniu kształtu do mapy można uzyskać dostęp do ustawienia geodezyjnego, wywołując funkcję isGeodesic(), i zmienić je, wywołując funkcję setGeodesic().

Kolejność nakładania elementów

Indeks z określa kolejność stosu tego kształtu względem innych nakładek (innych kształtów, nakładek naziemnych i nakładek kafelkowych) na mapie. Nakładka o wysokim indeksie Z jest rysowana nad nakładkami o niższych indeksach Z. Dwie nakładki o tym samym indeksie Z są rysowane w dowolnej kolejności.

Pamiętaj, że znaczniki są zawsze rysowane nad innymi nakładkami, niezależnie od indeksu Z tych nakładek.

Ustaw tę właściwość w obiekcie opcji kształtu, wywołując funkcję *Options.zIndex(). Jeśli nie określono inaczej, domyślny indeks Z to 0. Po dodaniu kształtu do mapy można uzyskać dostęp do indeksu Z, wywołując metodę getZIndex(), i zmienić go, wywołując metodę setZIndex().

Widoczność

Widoczność określa, czy kształt ma być narysowany na mapie, gdzie true oznacza, że powinien być narysowany, a false, że nie. Umożliwia tymczasowe ukrycie kształtu na mapie. Aby trwale usunąć kształt z mapy, wywołaj remove() na tym kształcie.

Ustaw tę właściwość w obiekcie opcji kształtu, wywołując funkcję *Options.visible(). Jeśli nie określono inaczej, domyślna widoczność to true. Po dodaniu kształtu do mapy można uzyskać dostęp do widoczności, wywołując isVisible(), i zmienić ją, wywołując setVisible().

Powiązywanie danych z kształtem

Możesz przechowywać dowolny obiekt danych z linią łamaną, wielokątem lub okręgiem, używając metody setTag() kształtu, i pobierać obiekt za pomocą metody getTag(). Na przykład wywołaj Polyline.setTag(), aby zapisać obiekt danych z linią łamaną, i wywołaj Polyline.getTag(), aby pobrać obiekt danych.

Poniższy kod definiuje dowolny tag (A) dla określonej linii łamanej:

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"

      

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

      

Oto kilka przykładów sytuacji, w których warto przechowywać i pobierać dane za pomocą kształtów:

• Twoja aplikacja może obsługiwać różne typy kształtów i możesz chcieć traktować je inaczej, gdy użytkownik je kliknie.
• Możesz korzystać z systemu, który ma unikalne identyfikatory rekordów, gdzie kształty reprezentują konkretne rekordy w tym systemie.
• Dane kształtu mogą wskazywać priorytet, który określa indeks Z kształtu.