ArcGIS Runtime ist eine Familie aus nativen SDKs zur Entwicklung von Geo-Apps für alle populären Mobile und Desktop Plattformen. Für Desktops gibt es mit dem Runtime Local Server ein zusätzliches SDK zur Implementierung von erweiterter Geo-Funktionalität. Mit diesen wollen wir uns in dem Blog näher beschäftigen:
Wie der Name schon andeutet ist der Runtime Local Server ein lokal auf dem Gerät laufender Web GIS Server. Dieser wird aber nicht installiert, sondern zur Laufzeit der ArcGIS Runtime Anwendung als Prozess erzeugt und verwaltet. Wird die Anwendung beendet, beendet sich damit auch der Local Server. Pro ausgeführte Anwendung kann nur ein Local Server gestartet werden (Singleton Pattern), es können aber mehrere Anwendungen mit jeweils eigenem Local Server nebeneinander laufen.
Die lokalen GIS Services für den Local Server werden auch zur Laufzeit erzeugt und verwaltet. Diese basieren auf lokalen Datenpaketen, welche zuvor mit ArcGIS Desktop erzeugt werden müssen. Genau wie in ArcGIS Online und ArcGIS Enterprise werden diese GIS Services über die ArcGIS Server REST API, also über URLs angesprochen. In ArcGIS Runtime ist es somit egal aus welcher Quelle ein GIS Service stammt, es können die gleichen Tasks und Layer auch dafür genutzt werden.
Der Schwerpunkt des Runtime Local Server liegt ganz klar auf dem lokalen Geoprocessing. Hunderte Analyse Tools aus der ArcToolbox, mächtige Model Builder Analyse Modelle und auch eigene Py... können zu Geoprocessing Packages gekapselt und diese durch lokale Geoprocessing Services genutzt werden. Das ist der Schlüssel für hochspezialisierten ArcGIS Runtime Anwendungen auch für GIS-Experten.
Es können noch weitere Typen lokaler Services erzeugt werden, dazu später mehr.
Folgende ArcGIS Runtime SDKs unterstützen den Runtime Local Server:
ArcGIS Runtime SDK for | Local Server Unterstützung für: | Anmerkungen |
.NET | · Windows (32/64 Bit) | Es wird nur die WPF API unterstützt. |
Java | · Windows (32/64 Bit) · Linux (64 Bit) | MacOS wird nicht unterstützt. |
Qt | · Windows (32/64 Bit) · Linux (64 Bit) | Es wird nur die Qt/C++ API unterstützt. |
Weitere mögliche Zielplattformen der SDKs in der Tabelle und auch die ArcGIS Runtime SDKs for Android, iOS und macOS werden nicht unterstützt. Dies lässt sich auch nicht mit Cross-Platform Technologie (z.B. Xamarin oder QML API) umgehen.
ArcGIS Entwickler können mit dem Local Server ab der kostenlosen ArcGIS Developer Subscription „Essentials“ entwickeln und testen. Das ArcGIS Runtime Local Server SDK gibt es für Windows und Linux und wird im Downloadbereich des ArcGIS Developers Portals heruntergeladen.
Die Lizenzstufe einer fertigen Anwendung mit Runtime Local Server Technologie hängt von der implementierten Funktionalität ab. Die Mindeststufe ist dabei ArcGIS Runtime License Level Standard. Für manche Funktionen wird zusätzlich noch die Analysis Extension benötigt. Für Geoprocessing Tools werden die benötigten Lizenzstufenstufen hier aufgeschlüsselt.
Map- und Geoprocessing Packages können im Moment nur in ArcMap erzeugt werden. Dabei ist folgendes zu beachten:
Folgendes ist möglich (Auszug):
Quelle | Lokaler Service | Funktionen (Auszug) |
Map package (.mpk) | MapService/ FeatureService |
|
Geoprocessing Package (.gpk) | Geoprocessing Service | https://developers.arcgis.com/net/latest/wpf/guide/local-server-geoprocessing-tools-support.htm |
In der Dokumentation der ArcGIS Runtime SDKs for .NET/WPF, Java und Qt/C++ steht die Implementierung des ArcGIS Runtime Local Server ausführlich beschrieben. Hier die Kurzfassung:
Mit dem ArcGIS Runtime SDK for .Net am Beispiel eines einfachen Buffer Tools (Download) sieht es so aus:
(a) Starten des Runtime Local Server
private LocalServer _localServer;
private LocalGeoprocessingService _localGpService;
private async void StartLocalServer()
{
try
{
// Get the singleton LocalServer object using the static "Instance" property
_localServer = LocalServer.Instance;
_localServer.AppDataPath = @"D:\Temp\LocalServerData";
// Handle the StatusChanged event to react when the server is started
_localServer.StatusChanged += (sender, statusChangedEventArgs) =>
{
// Check if the server started successfully
if (statusChangedEventArgs.Status == LocalServerStatus.Started)
{
// Start specific local services here ...
InitializeGpService();
}
};
// Start the local server instance
await _localServer.StartAsync();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
(b) Erzeugen und Starten eines lokalen Services auf Basis eines Geoprocessing Packages (Download)
private async void InitializeGpService()
{
try
{
// Create a local GP service from a geoprocessing package on disk
_localGpService = new LocalGeoprocessingService(@"data\simple-buffer.gpk");
// Handle the status changed event to check when it's loaded
_localGpService.StatusChanged += (svc, args) =>
{
// If service started successfully, create a gp task
if (args.Status == LocalServerStatus.Started)
{
//do something, if needed
}
};
// Start the local geoprocessing service
await _localGpService.StartAsync();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
(c) Nutzen des lokalen Services mit einem Geoprocessing Tasks
private async void MyMapViewOnGeoViewTapped(object sender, GeoViewInputEventArgs e)
{
var gpUri = new Uri(_localServer.Services[0].Url.AbsoluteUri + "/SimpleBuffer");
// Create parameters, run the task, process results, etc.
// ...
var geoprocessorTask = await GeoprocessingTask.CreateAsync(gpUri);
var parameter =
new GeoprocessingParameters(GeoprocessingExecutionType.AsynchronousSubmit)
{
OutputSpatialReference = MyMapView.SpatialReference
};
var myInputFeatures = new FeatureCollectionTable(new List<Field>(), GeometryType.Point, MyMapView.SpatialReference);
// Create a new feature from the feature collection table. It will not have a coordinate location (x,y) yet
var myInputFeature = myInputFeatures.CreateFeature();
// Assign a physical location to the new point feature based upon where the user clicked in the map view
myInputFeature.Geometry = e.Location;
// Add the new feature with (x,y) location to the feature collection table
await myInputFeatures.AddFeatureAsync(myInputFeature);
parameter.Inputs.Add("InputFeatures", new GeoprocessingFeatures(myInputFeatures));
parameter.Inputs.Add("Distance", new GeoprocessingLinearUnit(1000, GeoprocessingLinearUnits.Kilometer));
GeoprocessingJob job = geoprocessorTask.CreateJob(parameter);
try
{
// Execute analysis and wait for the results
var analysisResult = await job.GetResultAsync();
var outputFeatures = analysisResult.Outputs["BufferOutput"] as GeoprocessingFeatures;
}
catch (TaskCanceledException cancelledException)
{
// This is thrown if the task is cancelled.
MessageBox.Show(cancelledException.Message);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
Ergebnis
Mit der Local Server Technologie können fokussierte ArcGIS Runtime Anwendungen mit Werkzeugen aus ArcGIS Desktop für den GIS-Expertenbereich erstellt werden. Weiterhin gibt es die Möglichkeit, direkt auf Daten einer SDE zuzugreifen, viele verschiedene lokale Datentypen zu nutzen und vieles mehr. Und das mit modernster Technologie (64 Bit, Asynchron usw.) für verschiedene Desktop Plattformen. Wenn das nicht Grund genug für ArcGIS Engine/ArcObjects Entwickler ist …
You must be a registered user to add a comment. If you've already registered, sign in. Otherwise, register and sign in.