Teil 2: An Ort und Stelle

Geolocation – Ortung mit WLAN, Mobilfunknetz und GPS
Keine Kommentare

Mittels Ortungsfunktionen lassen sich allgemeine Daten personalisieren und Informationen auf die Wünsche der Nutzer zuschneiden. Wir sehen uns Anwendungsbeispiele und technische Umsetzungsmöglichkeiten für mobile Geräte an.

In der vorigen Ausgabe haben wir uns mit den vielfältigen Sensoren in modernen Smartphones beschäftigt. Dabei haben wir auch einen Blick auf die Ortungsmöglichkeiten geworfen und uns die fachlichen Hintergründe, wie das GPS-System, angesehen. Der Einsatz von Ortungsfunktionen erlaubt es, mit Hilfe des Smartphones oder Tablets die genaue Position eines Nutzers festzustellen. Die Angabe erfolgt auf Basis der geografischen Koordinaten Breite und Länge. Auf diese Weise lässt sich jeder Ort auf der Erde lokalisieren. Von einer GPS-Ortung spricht man, wenn die Standortsuche mit Hilfe des GPS-Sensors auf Satellitenbasis vorgenommen wird.

Artikelserie

Diese Vorgehensweise weist eine hohe Genauigkeit auf, ist jedoch zeitintensiv und benötigt relativ viel Energie. Ressourcenschonender ist die Nutzung der Mobilfunkfunktion bzw. eines WLANs. Deren Genauigkeit reicht für viele Zwecke aus. Welchen Grad von Genauigkeit man benötigt, lässt sich über die Systemsoftware vorgeben. Diese entscheidet dann über den Einsatz der passenden Ortungsmethode.

Use Cases

Bevor wir uns mit den programmiertechnischen Grundlagen der Ortung beschäftigen, schauen wir uns mögliche Anwendungsszenarien (Use Cases) an. Diese können als Inspiration dienen, um die eigene App mit Hilfe von Geolocation-Funktionen zu verbessern bzw. zu personalisieren. Beginnen wir mit der einmaligen und statischen Positionsermittlung. Die App ermittelt die Geodaten und kann damit den aktuellen Standort des Nutzers feststellen. Dieser könnte im einfachsten Fall in einer Karte dargestellt oder intern in der App verarbeitet werden. Ein Anwendungsbeispiel aus der Praxis: Die App einer Bank kann aus dem Standort des Nutzers die Entfernungen zur nächsten Filiale oder zum Geldautomaten berechnen. Als Service kann der Nutzer mittels Routenplanung an die Zielposition geleitet werden. Auch andere Anwendungen sind denkbar: Von der einfachen Wetter-App, die den aktuellen Standort ermittelt, bis zur Einblendung der Öffnungszeiten benachbarter Shops lassen sich unterschiedlichste Informationen vorstellen, die mit Geodaten angereichert werden können.

Von einer dynamischen Positionsermittlung sprechen wir dann, wenn die Ortung über einen bestimmten Zeitablauf wiederholt ausgeführt wird. Dadurch entsteht ein Bewegungsprofil. Dazu muss festgelegt werden, in welchem Zeitintervall die jeweils aktuelle Position abgefragt wird. Ebenso kann man bestimmen, bei welchem Ausmaß der Positionsänderung, also bei welcher Entfernung zwischen zwei Orten, das betreffende Ereignis ausgelöst wird. Aus den Ortungspunkten mit den zugehörigen Zeitangaben kann die Bewegungsgeschwindigkeit errechnet werden. So lässt sich zum Beispiel prognostizieren, um welche Uhrzeit ein bestimmtes Ziel erreicht werden wird.

Üblicherweise sollen die Daten nicht nur lokal verarbeitet werden, sondern durch andere Services nutzbar sein. Dazu müssen die Geodaten mit einer Zeitangabe (Zeitstempel) an ein Backend übertragen werden. Achtung: Dafür brauchen Sie die explizite Zustimmung des Nutzers, und Sie müssen angeben, wo Sie die Daten speichern, für welchen Zeitraum und für welchen Zweck (Datenschutz). Andere Nutzer bzw. Apps können dann – entsprechende Berechtigung und Freigabe vorausgesetzt – diese Daten weiter nutzen bzw. verarbeiten. Einfache Anwendungen aus diesem Bereich sind etwa Tracking-Apps, die die Position anderer Personen bzw. von Gegenständen verfolgen.

Geodaten lassen sich auch mit den Daten anderer Sensoren des Smartphones verknüpfen. Eine typische Anwendung ist die Kombination aus Kamera und Ortsangabe. Bildaufnahmen werden unmittelbar, zum Beispiel in den Metadaten der Bilddatei, um die Angabe des Aufnahmeortes ergänzt. Auch eine Analyse der Geodaten in Verbindung mit Zeitangaben kann man mit Hilfe von Algorithmen der künstlichen Intelligenz vornehmen. Beispielsweise kann man in langen Zeitreihen nach Mustern in Bewegungsprofilen suchen. Einem Nutzer, der sich etwa immer montags um 8.30 Uhr in der Nähe des Hauptbahnhofs aufhält und später regelmäßig 30 km weiter verortet werden kann, könnte man beim Aufrufen einer Ticket-App ein passendes Bahnticket vorschlagen und mit einem Fingertipp zum Kauf anbieten. Mit derartigen Nutzungen wird versucht, die Wünsche der Anwender zu prognostizieren und daraus mögliche Aktionen für die App abzuleiten. Kommen wir jetzt zu den verwandten Services am Beispiel von Google Maps.

Google Maps

Mit Geodaten kann man eine ganze Menge mehr anfangen, als nur die aktuelle Position zu bestimmen. Ein Einstieg für die Nutzung kann die Google Maps Platform sein, die Sie der Dokumentation finden können. Dazu gehören:

  • Directions API: ermittelt Wegbeschreibungen für Nutzer öffentlicher Verkehrsmittel, Radfahrer, Autofahrer oder Fußgänger zwischen mehreren Orten.
  • Distance Matrix API: berechnet Fahrtzeiten und Entfernungen zwischen mehreren Zielen.
  • Roads API: dient der genauen Ermittlung der Route eines Fahrzeugs.
  • Places SDK bzw. API für Android, iOS und JavaScript, um Details zu Orten abzufragen.
  • Geocoding API: dient der Umwandlung von Adressen in geografische Koordinaten und umgekehrt.
  • Geolocation API: ermöglicht es, den Standort eines Geräts basierend auf den Mobilfunkdaten und den WLAN-Knoten abzufragen. Es wird kein GPS verwendet.
  • Time Zone API: Abrufen der Zeitzone für Breiten- und Längengradkoordinaten.

Sehen wir uns das am Beispiel des Geocodings etwas genauer an. Dabei werden Adressen in geografische Koordinaten konvertiert. Diese Koordinaten können Sie dann zum Beispiel für weitergehende Berechnungen nutzen oder die dazugehörigen Orte in einer Karte darstellen. Bei der umgekehrten Geokodierung werden geografische Koordinaten in eine für Menschen lesbare Adresse umgewandelt. Nun wollen wir die Nutzung der Ortungsfunktionen anhand einiger Praxisbeispiele zeigen.

JavaScript – Ortung mittels Webapplikation

Zum Feststellen der Geoposition brauchen wir kein Smartphone mit GPS-Sensor, das funktioniert auch auf stationären Geräten über das Netzwerk (LAN/WLAN). Dabei nutzen wir JavaScript. Ein API kapselt die Komplexität. Zur Ermittlung der Geoposition braucht es nur wenige Zeilen Quellcode, wie Listing 1 zeigt. Im HTML-Dokument haben wir einen Button hinzugefügt, der als Auslöser für das Abfragen der Geoposition dient. Das onclick-Event verweist auf die JavaScript-Funktion getGeoPosition(). Innerhalb dieser Funktion wird mit navigator.geolocation.getCurrentPosition(showMyPosition); die aktuelle Position abgerufen, sofern sie verfügbar ist. Das wird zuvor geprüft. Auf eine Fehlerbehandlung wurde verzichtet. Das Ergebnis, d. h. die Positionsangaben, wird mittels Callback-Methode an eine weitere Funktion – wir haben sie als showMyPosition() bezeichnet – weitergegeben. In showMyPosition() werden dann die Positionsangaben mittels DOM-Manipulation auf der HTML-Seite angezeigt.

HTML-Dokument
<!doctype html>
<html>
<head>
 ...
</head>
<body>
 ...
  <h1>Die Geolocation API</h1>
  <p>
    <button type="button" onclick="getGeoPosition()">
      Position ermitteln
    </button>
    <p>Sie befinden sich:</p>
    <p id="position"></p>
  </p>
  <!--Einbindung JavaScript-->
  <script type="text/javascript" src="scripts.js"></script>
</body>
</html>
 
Java-Script-Code
function getGeoPosition() {
  if (navigator.geolocation) {
    navigator.geolocation.getCurrentPosition(showMyPosition);
  }
}
 
function showMyPosition(myPos) {
  let myP = document.getElementById("position");
  myP.innerHTML = "Breite: " + myPos.coords.latitude + "<br>Länge :" + myPos.coords.longitude;
}

Da die Positionsermittlung stets mit datenschutzrechtlichen Fragen einhergeht, fordert der Client (Browser) vor der Nutzung die Zustimmung des Anwenders ein. Wird diese Abfrage bestätigt, werden die Koordinaten unmittelbar angezeigt (Abb. 1).

Abb. 1: Ermittlung der Position über JavaScript ohne GPS

function showError(error) {
  let myP = document.getElementById("position");
  if (error.PERMISSION_DENIED) {
    myP.innerHTML =
      "Der Zugriff auf Ihre Position wurde verweigert!?"
  }
  else if (error.POSITION_UNAVAILABLE) {
    myP.innerHTML =
      "Es sind keine Geopositionsdaten vorhanden."
  }
  else if (error.TIMEOUT) {
    myP.innerHTML =
      "Timeout bei der Ortsanfrage wurde ausgelöst."
  }
  else {
    myP.innerHTML = "Ein unbekannter Fehler ist aufgetreten";
  }
}

Für viele Anwendungsfälle dürfte diese Art der Positionsbestimmung genügen. Mit Hilfe der Funktion getGeoPosition() erhalten wir neben dem Zugriff auf die Längen- und Breitenkoordinaten (longitude, latitude) weitere Informationen. Das sind:

  • coords.accuracy: Präzision der Breite und Länge in Meter
  • coords.altitude: Höhe in Meter
  • coords.altitudeAccuracy: Präzision der Höhe in Meter
  • coords.heading: Richtung
  • coords.speed: Geschwindigkeit
  • timestamp: Zeitstempel der Anfrage

Hier können nur dann sinnvolle Werte zurückgegeben werden, wenn der Webbrowser oder das Gerät diese Informationen auch bereitstellt. Andernfalls wird der Wert null zurückgegeben. Die Positionsbestimmung kann aus den unterschiedlichsten Gründen nicht funktionieren. Um mögliche Fehler abzufangen, müssen Sie der Abfrage getGeoPosition() einen weiteren Parameter in Form einer zweiten Callback-Funktion übergeben. Der Aufruf sieht dann zum Beispiel wie folgt aus:

navigator.geolocation.getCurrentPosition(showMyPosition, showError);

Die Methode showMyPosition() verarbeitet im positiven Fall also die Positionsdaten. Die Methode showError() wertet die möglichen Fehler aus (Listing 2). Die Fehlermeldungen deuten auf die folgenden Probleme hin:

  • PERMISSION_DENIED: Zugriff verweigert. Vermutlich hat der Benutzer die Erlaubnis zur Positionsbestimmung verweigert oder eine Einstellung auf dem Gerät blockiert diese Funktion.
  • POSITION_UNAVAILABLE: Die Position konnte nicht ermittelt werden.
  • TIMEOUT: Die Abfrage der Position dauerte zu lange und konnte nicht innerhalb einer bestimmten Zeit abgeschlossen werden.

Die Methode getCurrentPosition() kann noch einen dritten optionalen Parameter mit einem Objekt vom Typ PositionOptions übernehmen. Hier können wir folgende Vorgaben an das Location API machen:

  • enableHighAccuracy: Mit true geben Sie an, dass die Position noch genauer zu ermitteln sein soll. Das trifft insbesondere auf Mobilgeräte (iPhone, Android) zu. Ist die entsprechende Hardware nicht vorhanden, produziert der Aufruf der Methode einen Fehler.
  • maximumAge: Hier legt man fest, wie lange eine im Cache gespeicherte Ortsangabe verwendet werden darf, wenn Sie das nächste Mal getCurrentPosition() aufrufen. Mit der Vorgabe maximumAge = 0 wird definiert, dass keine Daten aus dem Zwischenspeicher verwendet werden können. Es wird dann stets die aktuelle Position neu ermittelt.
  • Timeout: Hiermit geben Sie in Millisekunden an, ab welchen Zeitpunkt ein Fehler (Timeout) ausgelöst werden soll, wenn bis dahin keine Daten abgeholt werden konnten.

Der Aufruf gestaltet sich dann wie folgt. Man definiert eine Datenstruktur, welche aus den folgenden Parametern besteht:

var geo_options = {
  enableHighAccuracy: true,
  maximumAge : 30000,
  timeout : 10000
  };

Diese Datenstruktur wird als dritter Parameter an die Methode getCurrentPosition() übergeben.

function getGeoPosition() {
  if (navigator.geolocation) {
    navigator.geolocation.getCurrentPosition(showMyPosition, showError, geo_options);
  }
}

Die ersten beiden Parameter sind wieder die Callback-Funktionen für die Verarbeitung der Positionsdaten bzw. für ein mögliches Fehlschlagen beim Aufruf des API. Die Funktion getCurrentPosition() ermittelt die aktuelle Position zum Zeitpunkt des Aufrufs. Eine Überwachung der Positionsänderung können Sie auch mit Hilfe des Geolocation API implementieren. Tauschen Sie dazu die Funktion getCurrentPosition() gegen watchPosition() aus. Die Parameter bleiben identisch. Der Code sieht dann zum Beispiel wie folgt aus: id = navigator.geolocation.watchPosition(showMyPosition, showError, geo_options). Im Gegensatz zur Methode getCurrentPosition() ruft die Methode watchPosition() jedes Mal die Callback-Funktion auf, wenn sich der Standort des Benutzers geändert hat. Zusätzlich liefert diese Methode eine ID, die Sie an die Methode clearWatch() als Parameter übergeben können, um die fortlaufende Positionsüberwachung wieder auszuschalten. Das geschieht über navigator.geolocation.clearWatch(id);.

Die Callback-Funktion wird natürlich nur aufgerufen, wenn sich die Position stetig ändert. Das können Sie am besten mit einem Mobilgerät und GPS-Sensor simulieren. Mobilfunk- und WLAN-Daten können minimale Änderungen des Standorts nur bedingt registrieren.

Geolocation unter Android

Wie kommen wir unter Android an die Positionsdaten? Dazu gibt es zwei Möglichkeiten. Sie können zum einen das Location API von Android verwenden und dort mit der Klasse LocationManager arbeiten. Alternativ können Sie den Google Play Service nutzen. Beide APIs sind grundsätzlich dazu geeignet, die Position des mobilen Geräts festzustellen. Die Google Location API Services sind moderner und bieten einige Vorteile. Der Google Play Service arbeitet zuverlässiger und benötigt weniger Energie, d. h., die Batterie wird geschont. Es gibt aber auch einige Nachteile. Auf dem Device muss der Google Play Service installiert sein. Einige Geräte unterstützen ihn nicht, dort kann das API dann nicht eingesetzt werden. Auch in einigen Regionen, zum Beispiel China, funktioniert Google Play Service nicht.

Sehen wir uns die Verwendung an einem Beispiel an. Wir verwenden den LocationManager. Legen Sie dazu ein neues Projekt in Android Studio an und starten Sie mit einer leeren Activity. Erstellen Sie eine minimale Oberfläche, in diesem Fall TextView-Elemente zur Anzeige der Positionsdaten (Listing 3). Aktuelle Android-Versionen (ab Version 6: Marshmallow, kurz: M) verlangen, dass man dezidiert die Berechtigungen überprüft, um eine bestimmte Funktion auszuführen. Android unterscheidet zwischen normalen und sogenannten gefährlichen Berechtigungen. Normale Berechtigungen sind notwendig, wenn die App auf Daten außerhalb der Sandbox zugreifen möchte. Dieser Zugriff hat keinen erheblichen Einfluss auf die Privatsphäre des Nutzers bzw. auf andere Apps. Dazu gehört zum Beispiel der Zugriff auf das Internet. Normale Berechtigungen gewährt das System, sobald sie von der App gefordert werden.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:orientation="vertical" >
  <LinearLayout
    android:id="@+id/linearLayout1"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginTop="40dip"
    android:orientation="horizontal" >
    <TextView
      android:id="@+id/TextView01"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_marginLeft="10dip"
      android:layout_marginRight="5dip"
      android:text="Latitude: "
      android:textSize="20dip" >
    </TextView>
 
    <TextView
       android:id="@+id/TextView02"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="unknown"
       android:textSize="20dip" >
    </TextView>
  </LinearLayout>
  <LinearLayout
    android:id="@+id/linearLayout2"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" >
    <TextView
      android:id="@+id/TextView03"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_marginLeft="10dip"
      android:layout_marginRight="5dip"
      android:text="Longitute: "
      android:textSize="20dip" >
    </TextView>
    <TextView
      android:id="@+id/TextView04"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="unknown"
      android:textSize="20dip" >
    </TextView>
  </LinearLayout>
</LinearLayout>

Gefährliche Berechtigungen dagegen verwenden Daten des Nutzers oder greifen tiefer in das System ein. Diese Berechtigungen müssen vom Anwender ausdrücklich gewährt werden. Ist das nicht der Fall, verweigert das System die Nutzung der entsprechenden Funktion. Beispiele für diese Art von Berechtigungen sind Zugriffe auf Kontakte oder Kalender, die Nutzung von Kamera bzw. Mikrofon oder des Ortungsdienstes (GPS). Bis zur Version Android 5 wurden die Berechtigungen während der Installation abgefragt. Hier konnte ihnen einmalig zugestimmt werden, und die Zustimmung galt dann für die Dauer der Nutzung der App als erteilt. Ab Android Version 6 wird den Nutzern eine größere Kontrolle über die Berechtigungen eingeräumt. Die Nutzer können die erteilten Berechtigungen später wieder entziehen. Um eine entsprechende Funktion zu nutzen, muss man in der laufenden App vor dem Zugriff auf die Funktion die Berechtigung jedes Mal prüfen (Runtime Permissions). Dazu müssen zunächst die Berechtigungen in der Manifestdatei grundsätzlich deklariert (angefordert) werden. In unserem Fall sieht das wie folgt aus:

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

Wenn Sie ACCESS_COARSE_LOCATION angeben, kann das API die WLAN- oder mobile Funkverbindung nutzen, um den Standort des Geräts zu bestimmen. Das API gibt den Speicherort mit einer mittleren Genauigkeit zurück. Wenn Sie ACCESS_FINE_LOCATION angeben, kann das API von den verfügbaren Standortanbietern einschließlich GPS einen möglichst genauen Standort ermitteln. Wenn Sie Android 10 (API-Stufe 29) oder höher als Zielsystem haben und auf den Gerätespeicherort zugreifen möchten, während sich die App im Hintergrund befindet, müssen Sie zusätzlich den Eintrag ACCESS_BACKGROUND_LOCATION deklarieren. Ergänzen Sie diese Zeilen im Manifest. Lesen Sie ggf. in der Dokumentation von Android nach, wie Sie die Berechtigungen zur Laufzeit korrekt prüfen. Das ist abhängig von der Zielversion und erfordert einigen Aufwand.

Kommen wir jetzt zur Abfrage der Geoposition. Das wiederum ist simpel. Der gesamte Code befindet sich in der Datei MainActivity.java. Definieren wir zwei lokale Variablen für den LocationManager und den Provider:

private LocationManager locationManager;
private String provider;

Es folgt die Initialisierung des LocationManager:

locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
Criteria criteria = new Criteria();
provider = locationManager.getBestProvider(criteria, false);

Mit Hilfe der Methode getLastKnownLocation(provider) erhalten wir den Zugriff auf die aktuellen Koordinaten. Diese zeigen wir dann auf der Oberfläche an (Listing 4, Abb. 2).

Location location = locationManager.getLastKnownLocation(provider);
if (location != null) {
  System.out.println("Provider " + provider + " has been selected.");
  onLocationChanged(location);
  } 
  else {
    latituteField.setText("Location not available");
    longitudeField.setText("Location not available");
  }
Abb. 2: Anzeige der Koordinaten in einer Android-App (Emulator)

Abb. 2: Anzeige der Koordinaten in einer Android-App (Emulator)

Damit rufen Sie die Koordinaten einmalig zum aktuellen Zeitpunkt ab. Um ein kontinuierliches Update der Koordinaten zu erhalten, wird das Ereignis onLocationChanged(…) regelmäßig bei einer Änderung des Standorts ausgelöst. Diese Funktionsweise lässt sich an einem physischen Gerät besser nachvollziehen.

Xamarin

Die plattformübergreifende Programmierung gewinnt immer mehr an Bedeutung. Für die Entwicklung von mobilen Apps heißt das, dass man Android und iOS aus einer einzigen Quellcodebasis erreichen kann. Dabei geht man üblicherweise so vor, dass man die Programmierschnittstellen der Plattformen (APIs) kapselt. Man muss also im Ergebnis nur gegen ein generisches Interface programmieren. Dennoch können die hardwarespezifischen Besonderheiten nicht ignoriert werden; die spezifischen Konfigurationen der jeweiligen Plattform müssen meist manuell erfolgen. Am Beispiel für Xamarin wollen wir uns auch ansehen, wie man die aktuelle Position des Nutzers ermittelt.

<?xml version="1.0" encoding="utf-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:d="http://xamarin.com/schemas/2014/forms/design" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d" x:Class="MyAppXamarin.MainPage">
  <StackLayout VerticalOptions="Center" HorizontalOptions="Center">
    <!-- Place new controls here -->
    <Label Text="Position:"  />
    <Label x:Name="LabelLatitude" Text="Latitude" />
    <Label x:Name="LabelLongtitude" Text="Longtitude"  />
  </StackLayout>
</ContentPage>

Starten wir mit einem neuen Projekt in Visual Studio für Mac. Wir entwickeln unter macOS, um Android und iOS gleichzeitig zu bedienen. Das User Interface wird mittels der Beschreibungssprache XAML erstellt und enthält lediglich Labels als Platzhalter für die Anzeige der Position (Listing 5). Um die Geolocation-Funktion zu nutzen, sind auch bei Xamarin die individuellen Berechtigungen auf den Plattformen Android und iOS einzuholen. In Xamarin haben Sie jetzt drei Projekte: ein App-Projekt (übergreifend), ein Projekt für Android und ein Projekt für iOS. Geolocation ist Bestandteil der Bibliothek Xamarin.Essentials. Darüber werden APIs bereitgestellt, um plattformübergreifende Basisfunktionen, zum Beispiel den Zugriff auf Sensoren, in den Griff zu bekommen und eine einheitliche Programmierschnittstelle anzubieten. Um die Plattformen zu konfigurieren, geht man wie folgt vor. Für Android werden in der Datei AssemblyInfo.cs (Ordner Properties) die folgenden Einträge ergänzt:

[assembly: UsesPermission(Android.Manifest.Permission.AccessCoarseLocation)]
[assembly: UsesPermission(Android.Manifest.Permission.AccessFineLocation)]
[assembly: UsesFeature("android.hardware.location", Required = false)]
[assembly: UsesFeature("android.hardware.location.gps", Required = false)]
[assembly: UsesFeature("android.hardware.location.network", Required = false)]

Damit ist die Berechtigungsprüfung für Android erledigt; ein großer Vorteil gegenüber der direkten Programmierung in Java und mit Android Studio. Für iOS benötigt man einen Eintrag in der Datei Info.plist. Ergänzen Sie die folgenden Zeilen:

<key>NSLocationWhenInUseUsageDescription</key>
<string>Grund für den Zugriff</string>

Dann kann es auch schon losgehen. Sorgen Sie für einen Zugriff auf die Bibliothek Xamarin.Essentials mittels using Xamarin.Essentials; Gearbeitet wird mit der Klasse Geolocation. Durch Aufrufen der GetLastKnownLocationAsync()-Methode können Sie den letzten bekannten Standort des Geräts abrufen. Diese Vorgehensweise ist häufig schneller als eine vollständige Abfrage, kann aber auch ungenauer sein und zur Rückgabe des Wertes null führen, wenn kein zwischengespeicherter Standort vorhanden ist. Eine vollständige Abfrage der Geoposition geschieht mittels:

var request = new GeolocationRequest(GeolocationAccuracy.Medium);
var location = await Geolocation.GetLocationAsync(request);

Der gesamte Quellcode zum Ermitteln der Geoposition ist wenig kompliziert, wie Listing 6 zeigt. Die ermittelten Angaben zur Position werden direkt auf der Benutzeroberfläche ausgegeben (Abb. 3).

Abb. 3: Anzeige der Koordinaten in einer iOS-App (Emulator) mittels Xamarin

Abb. 3: Anzeige der Koordinaten in einer iOS-App (Emulator) mittels Xamarin

private async void GetLocationAsync()
  {
    try
    {
      var request = new GeolocationRequest(GeolocationAccuracy.Medium);
      var location = await Geolocation.GetLocationAsync(request);
 
      if (location != null)
      {
        LabelLatitude.Text = location.Longitude.ToString();
        LabelLongtitude.Text = location.Latitude.ToString();
      }
    }
    catch
    { }
  }

Über den Parameter GeolocationAccuracy können wir die gewünschte Genauigkeit der Standortermittlung vorgeben, die von der Plattform abhängt. Die passende Methode (GPS, WLAN, Funk) wird automatisch vom System ausgewählt. Dabei bedeuten:

  • niedrigste Genauigkeit: Android: 500 Meter, iOS: 3 000 Meter
  • niedrige Genauigkeit: Android: 500 Meter, iOS: 1 000 Meter
  • mittlere Genauigkeit (Standard): Android: 100-500 Meter, iOS: 100 Meter
  • hohe Genauigkeit: Android: 0-100 Meter, iOS: 10 Meter
  • sehr hohe Genauigkeit: Android: 0-100 Meter, iOS: ~0 Meter

Die vollständige Dokumentation der Klasse Geolocation finden Sie in der Dokumentation.

Fazit und Ausblick

Location Services bieten vielfältige Möglichkeiten, um die aktuelle Position des Nutzers auszuwerten und sie zur Anreicherung von Daten bzw. zur Verbesserung von Services einzusetzen. Dieses Feature wird intensiv auf mobilen Devices genutzt. Der Abschnitt mit JavaScript hat aber gezeigt, dass man die Geolocation-Funktion auch in Webapplikationen – gleichgültig, ob auf dem Desktop oder Mobile – einsetzen kann. Bis zu einem bestimmten Genauigkeitsgrad ist dazu kein GPS-Sensor notwendig. Für Android- und iOS-Apps nutzt man in der Regel die SDKs, um die Positionsdaten schnell zu erfragen. Um die Daten weiterzuverarbeiten, können weitere Cloud-Services, zum Beispiel die Google Maps Platform, eingesetzt werden.

In der nächsten Ausgabe geht unsere Sensorenserie in die letzte Runde. Darin demonstrieren wir den Einsatz weiterer Sensoren in Anwendung und Programmierung.

Weitere Informationen zu diesen und anderen IT-Themen finden Sie unter http://larinet.com.

 

 

Unsere Redaktion empfiehlt:

Relevante Beiträge

Abonnieren
Benachrichtige mich bei
guest
0 Comments
Inline Feedbacks
View all comments
X
- Gib Deinen Standort ein -
- or -