Zuletzt klickt: Noch nichts
Map Plott Dataverse-Zeilen aus einer Ansicht oder Abfrage auf deren Breiten- und Längengraden, neben eigenen Markern, Linien, Flächen und Kreisen. Eine Komponente, dieselbe bei Blazor und React, gezeichnet vom von dir gewählten Anbieter: Azure Maps, Esri, Google, OpenStreetMap oder jeder beliebige MapLibre-Stil.
Zwölf Büros als Markierungen, eine Route, eine Lieferzone und eine Verkaufsregion. Markierungen, die dicht beieinander stehen, bilden Cluster, die beim Anklicken heranzoomen. Klicken Sie auf ein Büro für das Popup, hier der eigene Inhalt der Seite; die Route und die Bereiche öffnen keine, da die Seite selbst auf ihre Klicks antwortet, und die Zeile unter der Karte zeigt, was sie gehört hat.
Zuletzt klickt: Noch nichts
Die aktiven Konten, gefärbt nach ihrem Beziehungstyp oder mit dem Wechsel der Kontakte, werden von einer FetchXML-Abfrage mit den Berechtigungen des Besuchers gelesen und auf ihrem Breiten- und Längengrad platziert. Klicken Sie auf eines für das Popup: die anderen Spalten der Abfrage unter dem Namen der Zeile, wodurch die Seite geöffnet wird. Das Feld über der Karte findet eine Adresse beim Anbieter des Portals und pinnt sie.
Zuletzt klickt: Noch nichts
Adresse gefunden: Suche nach einem im Feld über der Karte
Die Konfiguration des Portals nennt seinen Anbieter und enthält die Schlüssel jedes Anbieters im Abschnitt PowerPortalsPro:Maps , daher muss eine Karte keinen nennen und keine Seite enthält einen Schlüssel. Marker, Cluster, Popups und Klicks funktionieren bei jedem Anbieter gleich:
Esri:ApiKey, und jeder ArcGIS-Basemap-Stil anstelle von Straßen.Google:ApiKey, und eine Karten-ID für eine Karte, die in Google Cloud gestaltet ist.OpenStreetMap:TileUrl für die Produktion.MapLibre:StyleUrl oder MapLibre:TileUrl, wie MapTiler, OpenFreeMap, Stadia oder Ihr eigener Server.// appsettings.json; keep the keys with the portal's other secrets
{
"PowerPortalsPro": {
"Maps": {
"Provider": "AzureMaps",
"AzureMaps": { "ClientId": "the Azure Maps account's client id" },
"Esri": { "ApiKey": "an ArcGIS API key" },
"Google": { "ApiKey": "a Maps JavaScript API key", "MapId": "a map id" }
}
}
}
Die Schlüssel von Esri und Google erreichen den Browser des Betrachters, der sie wie jede Webkarte an den Anbieter weiterleitet. Beschränken Sie jede auf die Adressen Ihres Portals in der Schaltkonsole des Anbieters.
Eine Seite nennt einen Anbieter nur, um einen anderen als den des Portals zu verwenden, und zeigt nur an, wie er aussieht: einen Stil, eine Karten-ID, eine Ansicht umstrittener Grenzen. Was unbestimmt bleibt, stammt von der Konfiguration. Bei einem düsteren Thema wechselt die Karte zum dunklen Stil des Anbieters; UsePortalTheme schaltet diesen aus.
<Map items={items} />
<Map provider={{ name: 'google', mapId: 'a map id' }} items={items} />
<Map provider={{ name: 'esri', styleName: 'arcgis/navigation' }} items={items} />
<Map provider={{ name: 'mapLibre', styleUrl: 'https://tiles.openfreemap.org/styles/liberty' }} items={items} /><Map Items="items" />
<Map Provider="@(new GoogleMapProvider { MapId = "a map id" })" Items="items" />
<Map Provider="@(new EsriMapProvider { StyleName = "arcgis/navigation" })" Items="items" />
<Map Provider="@(new MapLibreMapProvider { StyleUrl = "https://tiles.openfreemap.org/styles/liberty" })" Items="items" />Eine Azure Maps Karte meldet sich mit Entra-Token an, die das Portal an seine eigene Identität ausgibt, also mit der es mit Dataverse verbunden ist, sodass kein Azure Maps-Schlüssel benötigt wird oder den Browser erreicht. Gib dieser Identität die Azure Maps Data Reader-Rolle auf dem Azure Maps-Konto und nichts weiter, und setze AzureMaps:ClientId auf der Authentifizierungsseite des Kontos die Client-ID.
Jeder Betrachter hält den Token, während er läuft, sodass er nur das tun kann, was diese Rolle erlaubt; beschränke auch die erlaubten Ursprünge des Kontos auf die Adressen deines Portals. Die Karte verlangt vor Ablauf eines neuen Tokens. Eine Seite fragt einmal, und ein Betrachter kann 120 Token pro Minute erhalten, sofern PowerPortalsPro:Maps:RateLimit nicht anders angegeben ist; Besucher, die nicht eingeloggt sind, werden nach ihrer Adresse gezählt, die alle hinter der Verbindung eines Büros teilen.
Geben Sie eine Ansicht oder eine FetchXML-Abfrage an, und jede Zeile mit Breitengrad und Längengrad wird zu einem Marker, der nach dem primären Namen der Tabelle benannt ist. Zeilen werden mit den Berechtigungen des Benutzers gelesen, wie es bei einem Raster der Fall ist, und ein Klick auf eine Zeile zeigt die Spalten der Ansicht an.
<Map
viewId={activeAccountsViewId}
latitudeColumn="address1_latitude"
longitudeColumn="address1_longitude"
recordColor="var(--colorPaletteRedBackground3)"
/><Map ViewId="activeAccountsViewId"
LatitudeColumn="address1_latitude"
LongitudeColumn="address1_longitude"
RecordColor="var(--colorPaletteRedBackground3)" />Zeilen ohne beide Koordinaten werden in der Abfrage ausgelassen. Die Karte liest 1.000 Zeilen, sofern MaxRows nichts anderes steht (höchstens 5.000), und notiert auf der Karte, wenn es mehr gibt.
Zeilen ohne Koordinaten können von ihren Adressen aus ausgefüllt werden, sobald sie gespeichert werden: siehe Geocoding.
Mit MultiTable (React: multiTable), zeigt die Karte die Zeilen jeder Tabelle, die der Server für Karten mit ForMapsregistriert, jede Tabelle in ihrer eigenen Farbe mit einer Legende. Die Registrierung nennt die Spalten, die die Breite und Länge einer Zeile enthalten, die immer gelesen werden. DefaultTables wählt die zunächst gezeigten Tabellen und Tables die aus, die überhaupt angezeigt werden dürfen; Regarding schränkt sie auf die Zeilen rund um einen Datensatz ein.
// Program.cs
builder.Services.AddMultiTableSource("account", t => t
.Columns("address1_city")
.ForMaps(latitude: "address1_latitude", longitude: "address1_longitude"));
builder.Services.AddMultiTableSource("contact", t => t
.ForMaps(latitude: "address1_latitude", longitude: "address1_longitude"));
Eine Tabelle, deren Koordinaten mit AddMapCoordinatesregistriert sind, oder mit AddGeocodingausgefüllt werden, wird für Karten mit ForMaps() nur registriert: siehe Geocoding.
<Map multiTable defaultTables={['account']} allowSavedViews /><Map MultiTable="true" DefaultTables="@(["account"])" AllowSavedViews="true" />Eine Symbolleiste über der Karte wählt die Ansicht: jede Tabelle oder eine Ansicht mehrerer Tabellen, die mit und registriert sind AddMultiTableView ForMaps(). ViewIds (React: viewIds) bietet nur die registrierten Ansichten in ihrer Reihenfolge und DefaultViewId (defaultViewId) die, auf der sie geöffnet wird. Sein Filtermenü schaltet Tabellen ein und aus und bearbeitet die Filter jeder Tabelle. Mit AllowSavedViews (React: allowSavedViews) kann ein angemeldeter Benutzer das, was die Karte als eigene Ansicht anzeigt, speichern: siehe Gespeicherte Ansichten.
Mit AllowNearSearch (React: allowNearSearch) hat eine Karte mehrerer Tabellen einen Nah-Button auf ihrer Werkzeugleiste. Sie findet einen Ort – eine Adresse mit der eigenen Suche des Kartenanbieters oder den Standort des Besuchers, den der Browser auffordert zu teilen – und die Karte zeigt dann nur die Zeilen innerhalb der gewählten Entfernung, am nächstliegenden über jeder Tabelle: Der Kreis wird gezeichnet, die Karte darauf angepasst, und das Popup jeder Zeile zeigt an, wie weit sie ist. NearDistances (nearDistances) legt die angebotenen Entfernungen fest: 1, 5, 10, 25, 50 und 100, sofern nicht gesetzt, NearDistance (nearDistance) die Startdistanz, 25 sofern nicht gesetzt, und NearDistanceUnit (nearDistanceUnit) ob sie in Meilen startet, als Standard, oder Kilometer; der Besucher kann wechseln. Siehe es in der Nahen-Demo.
<Map
multiTable
allowNearSearch
nearDistances={[10, 25, 50, 100]}
nearDistance={25}
nearDistanceUnit={DistanceUnits.Kilometers}
/><Map MultiTable="true"
AllowNearSearch="true"
NearDistances="@([10, 25, 50, 100])"
NearDistance="25"
NearDistanceUnit="DistanceUnit.Kilometers" />Jede Tabelle wird mit ihren registrierten Koordinaten gelesen, mit den Erlaubnissen des Besuchers: Der Server liest das Quadrat um den Kreis, hält die Reihen in der Entfernung über dem Boden und gibt die nächstgelegenen zurück. Eine Suche in der Nähe eines Ortes hält höchstens 500 Reihen, die nächstgelegenen, und die Legende der Karte sagt, wann es mehr gab; NearSearchOptions.MaximumMatches erhöht oder senkt das bis zu 5.000. Ein Besucher, der die Koordinaten eines Tisches nicht lesen darf, findet keine seiner Reihen.
// Program.cs
builder.Services.Configure<NearSearchOptions>(options => options.MaximumMatches = 1_000);
Wenn man auf einen Gegenstand, einen Marker oder eine Linie, einen Bereich oder einen Kreis klickt, erscheint OnItemClick das Objekt mit seinen Daten und dem Klickort und öffnet dann ein Popup darüber. Das Popup ist eine Fluent-Karte mit eigenem Inhalt: eine Vorlage auf Blazor, eine Renderfunktion auf React. Ein Klick auf die Karte selbst erhebt OnMapClick sich mit ihrer Position.
<Map
items={items}
onItemClick={({ item, position }) => select(item)}
onMapClick={({ position }) => addStop(position)}
renderPopup={(item) => (
<>
<strong>{item.title}</strong>
<Button onClick={() => open(item)}>Open</Button>
</>
)}
/><Map Items="items" OnItemClick="OnItemClicked" OnMapClick="OnMapClicked">
<PopupTemplate>
<strong>@context.Title</strong>
<FluentButton OnClick="@(() => Open(context))">Open</FluentButton>
</PopupTemplate>
</Map>Um einen Klick auf eigene Weise zu beantworten, öffne zum Beispiel die Seite eines Datensatzes oder wähle eine Region aus, rufe PreventDefault() auf den Klick (preventDefault() auf React) auf, und die Karte öffnet kein Popup dafür. ShowPopups Auf False gestellt wird für jedes Element Popups ausgeschaltet.
<Map
viewId={accountsViewId}
onItemClick={(event) => {
// A row's marker opens its record's page; anything else its popup.
const row = event.item.data as MapRecord | undefined;
if (row?.record) {
event.preventDefault();
navigate(`/accounts/${row.record.id}`);
}
}}
/><Map ViewId="accountsViewId" OnItemClick="OnItemClicked" />
@code {
// A row's marker opens its record's page; anything else its popup.
private void OnItemClicked(MapItemClickEventArgs args)
{
if (args.Item.Record is { } record)
{
args.PreventDefault();
Navigation.NavigateTo($"accounts/{record.Id}");
}
}
}Das Popup-Kommando einer Zeile verweist auf die Seite ihres Datensatzes, die für ihre Tabelle AddRecordPage registriert ist (siehe Datensatzseiten), auf einer Karte einer oder mehreren Tabellen. RecordUrl verknüpft sie an anderer Stelle: Eine URL mit {0} anstelle der ID der Zeile und {1} der ihrer Tabelle. ShowRecordLinks (React: showRecordLinks) auf falsch gesetzt schaltet die Links aus. Ein eigener Eintrag verlinkt zu seinem Url. Auf React onNavigate folgt der Link mit deinem Router.
Marker an einer Stelle, wie die Kontakte an einer Adresse, lösen sich beim Zoomen nie auseinander, daher listet ihr Cluster sie stattdessen auf.
ColorColumn färbt den Marker jeder Zeile nach ihrer Option in einer Spalte Option, Status, Grund oder Ja/Nein: die Farbe, die die Option in Dataverse hat, oder eine der Fluent-Paletten, wenn keine vorhanden ist, mit einer Legende der Optionen auf der Karte. Zeilen ohne Wert sind grau. Für jede andere Regel RecordColorSelector geben auf Blazor und eine Funktion für recordColor React jeder Zeile ihre eigene Farbe.
<Map viewId={accountsViewId} colorColumn="customertypecode" recordUrl="/accounts/{0}" />
<Map viewId={accountsViewId} recordColor={(record) => (isKeyAccount(record) ? 'var(--colorPaletteRedBackground3)' : undefined)} /><Map ViewId="accountsViewId" ColorColumn="customertypecode" RecordUrl="accounts/{0}" />
<Map ViewId="accountsViewId" RecordColorSelector="@(record => IsKeyAccount(record) ? "var(--colorPaletteRedBackground3)" : null)" />ShowAddressSearch legt ein Suchfeld über die Ecke der Karte. Es findet Adressen und Orte mit dem eigenen Anbieter des Portals, Positionen ist zuerst sichtbar und pinnt den ausgewählten; OnAddressSelected gibt der Seite den Ort und Null, sobald die Suche abgeschlossen ist. AddressSearchCountries behält sie auf einige Länder und GoToAddressAsync (im React-Referenz) sucht siegoToAddress aus dem Code.
<Map
viewId={accountsViewId}
showAddressSearch
addressSearchCountries={['US', 'CA']}
onAddressSelected={(place) => setNear(place?.position ?? null)}
/><Map ViewId="accountsViewId"
ShowAddressSearch="true"
AddressSearchCountries="@(["US", "CA"])"
OnAddressSelected="@(place => _near = place?.Position)" />Azure Maps, Esri und Google schlagen Orte vor, wenn der Besucher typiert. Der Google-Schlüssel benötigt die Places API (Neu) aktiviert, und Esris Schlüssel seine Geocoding-Berechtigung. OpenStreetMap- und MapLibre-Karten durchsuchen OpenStreetMaps Nominatim, dessen Nutzungsrichtlinie nur für leichte Nutzung erlaubt ist und niemals beim Tippen, sodass sie suchen, wenn Enter gedrückt wird; nenne deinen eigenen Nominatim-Server in OpenStreetMap:GeocoderUrl oder MapLibre:GeocoderUrl für mehr.
Address(addressin React) zeigt eine Adresse ohne Suchfeld: Die Karte findet sie mit derselben Suche, sobald sie gezeichnet ist, und wieder, wenn sie sich ändert, pinnt sie und zoomt darauf. Ein Spinner zeigt beim Suchen eine Nachricht an, wenn sie nicht gefunden wird. Es ist das, was der Kartenpin öffnet,AddressDisplayValue eine Adresse ohne Koordinaten.
<Map address="1 Microsoft Way, Redmond, WA 98052" height="300px" /><Map Address="1 Microsoft Way, Redmond, WA 98052" Height="300px" />ShowPrintButton (showPrintButton in React) fügt einen Druck-Button hinzu – auf der Werkzeugleiste einer MultiTable Karte, also über der oberen rechten Ecke der Karte –, der die Karte so ausdruckt, wie sie mit ihren Pins, ihrer Legende, dem geöffneten Popup und der Quellenangabe des Anbieters angezeigt wird. PrintTitle ist die Überschrift darüber und PrintEntries listet die Datensätze darunter auf, jede neben dem Label ihres Pins. Ein Marker Label wird auf seinen Pin anstelle des Punktes gezeichnet: gib den Stopps eine Zahl und der Ausdruck liest sich wie ein Routenblatt. PrintAsync() (print() in der React-Referenz – druckt von einem eigenen Button der Seite aus und OnPrintChanged (onPrintChange) gibt an, wann die Karte gedruckt werden kann und ob sie als Bild gespeichert werden kann, damit dieser Button folgt.
const stops: MapMarker[] = [{ kind: 'marker', id: '1', label: '1', title: 'Contoso', position: { latitude: 47.61, longitude: -122.33 } }];
<Map
ref={mapRef}
items={stops}
showPrintButton
printTitle="Tuesday's visits"
printEntries={stops.map((stop) => ({ label: stop.label, title: stop.title ?? '' }))}
/>
// The same from a button of the page's own.
mapRef.current?.print();<Map @ref="_map"
Items="stops"
ShowPrintButton="true"
PrintTitle="Tuesday's visits"
PrintEntries="@stops.Select(stop => new MapPrintEntry(stop.Title!, stop.Label)).ToList()" />
@code {
// A marker's Label is drawn on its pin, and beside it in the printed list.
private List<MapMarker> stops = [new() { Id = "1", Label = "1", Title = "Contoso", Position = new(47.61, -122.33) }];
private Map? _map;
// The same from a button of the page's own.
private Task PrintAsync() => _map!.PrintAsync();
}Azure Maps, Esri, OpenStreetMap und MapLibre-Karten werden als Bild der Karte gedruckt, sodass die Seite um die Karte herum weggelassen wird und die Karte sich nicht bewegt; derselbe Button speichert dieses Bild auch als PNG-Datei (SaveImageAsync, oder saveImage()). Ein offenes Popup wird auf das Bild mit Titel und Feldern oder den darauf aufgeführten Markern gezeichnet; eines, das den eigenen Inhalt der Seite (PopupTemplate, oder renderPopup) zeigt, wird mit dem Titel des Objekts gezeichnet. Eine Google-Karte kann nicht in ein Bild kopiert werden, daher wird sie so gedruckt, wie sie auf der Seite ist, mit Popup und so, der Rest der Seite bleibt nicht im Ausdruck, und bietet kein Bild zum Speichern an. Ein eigener Anbieter wird als Bild gedruckt, wenn seine Oberfläche implementiert capture.
NativeOptions werden auf die eigene Karte des Anbieters übertragen, sobald sie erstellt wird, über die eigene Karte. Das schaltet zum Beispiel Street View für Google ein oder erlaubt einer MapLibre-Karte, nur mit dem Scrollrad zu zoomen (cooperativeGestures: false); standardmäßig benötigt sie Strg, wie bei Google auf einer Seite, die scrollt, sodass die Seite daran vorbeiscrollt. Das Kartenobjekt des Anbieters ist auch für Ihr eigenes JavaScript verfügbar: GetNativeMapAsync auf Blazor, native in der React-Referenz.
<Map provider={{ name: 'google' }} nativeOptions={{ streetViewControl: true }} /><Map Provider="@(new GoogleMapProvider())"
NativeOptions="@(new Dictionary<string, object?> { ["streetViewControl"] = true })" />Ein Anbieter zeichnet die Basiskarte und Formen, platziert Elemente und meldet Klicks und Umzüge. Alles andere gehört der Karte. Registrieren Sie eine mit ihrem Namen und benennen Sie sie dann in den Anbietereinstellungen der Karte.
import { registerMapProvider, type MapSurface } from '@powerportalspro/react-maps';
registerMapProvider({
name: 'arcgis-sdk',
async create(context): Promise<MapSurface> {
// Draw into context.container with your library; report clicks and moves through
// context.events; return the surface: camera, projection, overlays and shapes.
},
});
Auf Blazor verwenden CustomMapProvider Sie den Namen, den Sie im JavaScript Ihrer Seite registriert haben.
MapLibre, das alle Anbieter außer Google zeichnet, lädt ein Worker-Skript aus einer eigenen Datei. Installiere maplibre-gl neben @powerportalspro/react-mapsund sag ihm, wo dein Bundler den Worker einmal platziert hat, bevor eine Karte gezeichnet wird. Blazor benötigt keine Einrichtung.
// main.tsx, with Vite
import { setMapLibreWorkerUrl } from '@powerportalspro/react-maps';
import workerUrl from 'maplibre-gl/dist/maplibre-gl-worker.mjs?worker&url';
setMapLibreWorkerUrl(workerUrl);
Name | Typ | Default | Beschreibung |
|---|---|---|---|
Address | string? | ||
AddressSearchCountries | IReadOnlyList<string>? | ||
AllowFiltering | bool | False | |
AllowNearSearch | bool | False | |
AllowSavedViews | bool | False | |
Center | MapPosition? | ||
Cluster | bool | True | |
ColorColumn | string? | ||
DefaultTables | IEnumerable<string>? | ||
DefaultViewId | Guid? | ||
FetchXml | string? | ||
Filters | IReadOnlyList<QueryFilter>? | ||
FitItemIds | IReadOnlyList<string>? | ||
Height | string | 400px | |
Items | IReadOnlyList<MapItem>? | ||
LatitudeColumn | string | address1_latitude | |
LongitudeColumn | string | address1_longitude | |
MapStyle | MapStyle | Road | |
MaxRows | int | 1000 | |
MultiTable | bool | False | |
NativeOptions | IReadOnlyDictionary<string, Object>? | ||
NearDistance | double? | ||
NearDistances | IReadOnlyList<double>? | ||
NearDistanceUnit | DistanceUnit | Miles | |
PopupTemplate | RenderFragment<MapItem>? | ||
PrintEntries | IReadOnlyList<MapPrintEntry>? | ||
PrintEntriesProvider | Func<IReadOnlyList<MapPrintEntry>>? | ||
PrintTitle | string? | ||
Provider | MapProvider? | ||
RecordColor | string? | ||
RecordColorSelector | Func<TableRecord, string>? | ||
RecordUrl | string? | ||
RecordUrlSelector | Func<TableRecord, string>? | ||
Regarding | TableRecordReference? | ||
SavedViewsKey | string? | ||
ShowAddressSearch | bool | False | |
ShowLegend | bool | True | |
ShowPopups | bool | True | |
ShowPrintButton | bool | False | |
ShowRecordLinks | bool | True | |
SignInUrl | string | Account/Login | |
Tables | IEnumerable<string>? | ||
Title | string? | ||
TitleColumn | string? | ||
UsePortalTheme | bool | True | |
ViewId | Guid? | ||
ViewIds | IEnumerable<Guid>? | ||
Width | string | 100% | |
Zoom | double? |
AddressAddressSearchCountriesAllowFilteringAllowNearSearchAllowSavedViewsCenterClusterColorColumnDefaultTablesDefaultViewIdFetchXmlFiltersFitItemIdsHeightItemsLatitudeColumnLongitudeColumnMapStyleMaxRowsMultiTableNativeOptionsNearDistanceNearDistancesNearDistanceUnitPopupTemplatePrintEntriesPrintEntriesProviderPrintTitleProviderRecordColorRecordColorSelectorRecordUrlRecordUrlSelectorRegardingSavedViewsKeyShowAddressSearchShowLegendShowPopupsShowPrintButtonShowRecordLinksSignInUrlTablesTitleTitleColumnUsePortalThemeViewIdViewIdsWidthZoomName | Typ | Beschreibung |
|---|---|---|
OnAddressSelected | EventCallback<MapPlace> | |
OnError | EventCallback<string> | |
OnItemClick | EventCallback<MapItemClickEventArgs> | |
OnMapClick | EventCallback<MapClickEventArgs> | |
OnPrintChanged | EventCallback<MapPrintState> | |
OnViewChanged | EventCallback<MapView> |
OnAddressSelectedOnErrorOnItemClickOnMapClickOnPrintChangedOnViewChangedName | Parameter | Typ | Beschreibung |
|---|---|---|---|
ClearAddressAsync | Task | ||
ClosePopupAsync | Task | ||
FitToItemsAsync | IEnumerable<string> ids | Task | |
GetMapSettingsAsync | string provider | Task<MapSettingsResponse> | |
GetNativeMapAsync | Task<IJSObjectReference> | ||
GetViewAsync | Task<MapView> | ||
GoToAddressAsync | string text | Task<MapPlace> | |
NotifyAddressSelectedAsync | MapPlace place | Task | |
NotifyAddressStatusAsync | string status | Task | |
NotifyClusterClickAsync | string[] ids MapPosition position | Task | |
NotifyErrorAsync | string kind string message | Task | |
NotifyItemClickAsync | string id MapPosition position | Task | |
NotifyMapClickAsync | MapPosition position | Task | |
NotifyViewChangedAsync | MapView view | Task | |
OpenPopupAsync | string id | Task | |
PrintAsync | Task | ||
SaveImageAsync | string fileName | Task<bool> | |
SetCameraAsync | MapCamera camera bool animate | Task |
ClearAddressAsyncClosePopupAsyncFitToItemsAsyncGetMapSettingsAsyncGetNativeMapAsyncGetViewAsyncGoToAddressAsyncNotifyAddressSelectedAsyncNotifyAddressStatusAsyncNotifyClusterClickAsyncNotifyErrorAsyncNotifyItemClickAsyncNotifyMapClickAsyncNotifyViewChangedAsyncOpenPopupAsyncPrintAsyncSaveImageAsyncSetCameraAsync