a.erbeesri-de-esridist

Das ArcGIS Runtime Local Server SDK

Blog Post created by a.erbeesri-de-esridist Employee on Aug 15, 2017

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:

 

 

Was ist der ArcGIS Runtime Local Server?

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 Python Skripte in ArcGIS Desktop 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.

 

 

Unterstütze Plattformen 

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.

 

 

Download und Lizensierung

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.

 

 

Datenquellen und Funktionalität 

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

  • Dynamische Daten
  • Rasterdaten
  • Features & Tabellen
  • Abfragen, Editierung
  • Dynamic Layers (Hier grundlegende Infos des Konzeptes)
  • Zugriff auf (ArcSDE) Datenbanken
  • uvm

Geoprocessing Package (.gpk)

Geoprocessing Service

https://developers.arcgis.com/net/latest/wpf/guide/local-server-geoprocessing-tools-support.htm

 

 

Implementierung

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:

 

  1. Download und Installation
  2. Erstellen eines Local Server Deployments für das Projekt (Welche Funktionalität soll genutzt werden!)
    1. Local Server Deployment Builder tool (Java und Qt)
    2. Deployment manifest file im Visual Studio Projekt (.NET)
  3. Im Code:
    1. Starten des Runtime Local Server
    2. Erzeugen und Starten von lokalen Services auf Basis von Packages
    3. Nutzen der lokalen Services in den entsprechenden ArcGIS Runtime Tasks und Layer

 

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

 

Resümee

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 …

Outcomes