Wie erstellt man eine Geolocation App?

In der heutigen Welt werden standortbezogene Anwendungen immer beliebter. Fast jede zweite beliebte App enthält in gewissem Maße Geolocation-Funktionen. Einige tun dies, um die Benutzererfahrung zu verbessern und ein personalisiertes Erlebnis zu bieten, während andere auf standortbasierten Funktionen aufbauen.

In diesem Artikel erfahren Sie alles, was Sie über Geolocation-Apps wissen müssen. Wir sprechen über ihre wichtigsten Funktionen, die Arten von Geolocation-Apps und erklären den Prozess der Erstellung einer Geo-App aus der Sicht des Unternehmens. Außerdem führen wir Sie durch den Prozess der Entwicklung einer Geolocation-App mit Back4app und React Native.

Was ist eine Geolocation-App?

Eine Geolocation- oder standortbasierte App ist eine mobile oder Web-Anwendung, die den Standort des Geräts des Nutzers verfolgt. Apps tun dies, um das Nutzererlebnis zu personalisieren und zu verbessern, um ortsabhängige Dienste anzubieten, für Marketingzwecke, zu Informationszwecken und so weiter.

Geolocation-Apps verwenden verschiedene Technologien, um den Standort des Nutzers zu ermitteln, darunter die folgenden:

• Globales Ortungssystem (GPS)
• Unterstütztes globales Ortungssystem (A-GPS)
• Geolokalisierungstechnologien für Innenräume
• Mobilfunkmasten oder WiFi

Jede der genannten Technologien hat ihre Vor- und Nachteile. Einige sind schneller, während andere präziser und zuverlässiger sind. Aber machen Sie sich nicht zu viele Gedanken über sie. Der Standort wird in der Regel durch das Gerät selbst ermittelt.

Hauptmerkmale standortbezogener Anwendungen

Die Funktionen von Geolocation-Apps sind sehr unterschiedlich, aber die meisten von ihnen enthalten diese Geolocation-Funktionen:

• Kartenansicht: Die Kartenansicht ist eine zentrale Funktion von Geolocation-Apps. Sie bietet Nutzern eine visuelle Darstellung ihres aktuellen Standorts und von Points of Interest. Sie ermöglicht es den Nutzern, Gebiete zu erkunden, Wegbeschreibungen zu finden und raumbezogene Abfragen durchzuführen.
• Standortverfolgung: Geolocation-Apps bieten oft eine Standortverfolgung in Echtzeit, so dass die Nutzer ihren Standort mit anderen teilen oder ihre Bewegungen verfolgen können.
• Personalisierung: Geolocation-Apps können Personalisierungsfunktionen bieten, wie das Speichern von Lieblingsorten, das Festlegen von Präferenzen für Routenarten (z. B. Gehen, Fahren), visuelle Einstellungen usw.
• Benachrichtigungen: Einige Geolocation-Apps verwenden Geofencing, um Benachrichtigungen zu senden, wenn Nutzer ein Gebiet betreten oder verlassen. Außerdem können sie eine Benachrichtigung senden, wenn sich der Nutzer in der Nähe eines Ereignisses befindet, usw.
• Integration mit anderen Diensten: Viele Geolocation-Apps sind mit Diensten oder Plattformen von Drittanbietern integriert, um die Funktionalität zu verbessern. So integriert Google beispielsweise Booking.com, um Hoteloptionen anzubieten, und Transitplattformen, um Informationen über öffentliche Verkehrsmittel abzurufen.

Arten von ortsbezogenen Anwendungen

Es gibt viele Arten von standortbezogenen Anwendungen, aber sehen wir uns einige der wichtigsten an.

Navigations-Apps

Navigations-Apps sind das offensichtlichste Beispiel für Geolocation-Apps. Sie konzentrieren sich in der Regel auf eine Kartenansicht und bieten Funktionen wie Standortverfolgung, Suche nach Geschäften in der Nähe, Durchführung von Geoabfragen und Bereitstellung von Wegbeschreibungen.

Beispiele: Google Maps, Waze, Sygic GPS.

Anwendungen auf Abruf

On-Demand-Apps sind ein weiteres beliebtes Beispiel für Geolocation-Apps. Mit diesen Apps können Sie eine Mitfahrgelegenheit finden, Essen bestellen, Lebensmittel einkaufen und vieles mehr. On-Demand-Dienste nutzen den Standort des Nutzers, um Fahrten, Geschäfte und Restaurants in der Nähe anzuzeigen. Darüber hinaus bieten sie eine Echtzeit-Verfolgung von Bestellungen.

Beispiele: Uber, Uber Eats, Lyft.

Soziale Netzwerke und Dating-Apps

Social-Media-Apps sind in der Regel weniger transparent in Bezug auf ihre Geolocation-Nutzung. Die meisten Social-Media-Apps verwenden den Standort des Nutzers, um ein personalisiertes Erlebnis zu bieten, Menschen zu verbinden, Bilder und Fotos zu markieren und regional beliebte Inhalte anzuzeigen.

Beispiele: Facebook, Instagram, Tinder.

Tourismus-Apps

Tourismus-Apps verwenden den Standort des Nutzers, um Hotels, Veranstaltungen, Erlebnisse und vieles mehr in der Nähe zu empfehlen.

Beispiele: Airbnb, Booking, Eventbrite.

Fitness-Apps

Die meisten Fitness-Apps, insbesondere Lauf-Apps, haben eine integrierte Standortbestimmung. Die Standortverfolgung ermöglicht es ihnen, die Routen der Benutzer zu verfolgen, die Streckendistanz, die durchschnittliche Laufgeschwindigkeit, den Höhenunterschied und mehr zu berechnen.

Beispiele: Strava, GoogleFit, RunKeeper.

Prozess der Erstellung einer Geolocation-App

Die Erstellung einer standortbasierten mobilen Anwendung kann eine entmutigende Aufgabe sein. Aber keine Sorge! Mit den folgenden Schritten sind Sie auf dem besten Weg, eine hervorragende Geolocation-App zu erstellen.

Schritt 1: Definieren Sie den Zweck der Geolocation-App

Der erste Schritt bei der Erstellung einer Geolocation-App besteht darin, ihren Zweck und ihre wichtigsten Funktionen zu definieren. Fragen Sie sich, welches Problem Ihre App lösen soll und wer die Zielgruppe ist.

Sobald Sie das wissen, ist es an der Zeit, den Markt zu erforschen. Finden Sie Ihre Konkurrenten und überlegen Sie, was Ihre App besser macht als alle anderen.

Schritt 2: Auswahl der Technologien

Der entscheidende Teil der Entwicklung einer guten Geolocation-App ist die Auswahl des richtigen technischen Stacks. Ihre App wird wahrscheinlich in das Backend und das Frontend aufgeteilt sein.

Überlegen Sie bei der Auswahl der Backend-Tools, welche Art von Daten Sie speichern wollen, wo die Daten gespeichert werden und so weiter. Umgekehrt sollten Sie sich bei der Auswahl der Frontend-Technologien für diejenigen entscheiden, mit denen Sie eine responsive App mit elegantem Design erstellen können.

Außerdem benötigen Sie eine Geolocation-API. Bei der Auswahl einer Geolokalisierungs-API sollten Sie verschiedene Optionen wie Google Maps, OpenStreetMap und MapBox in Betracht ziehen. Achten Sie darauf, dass Sie die Geolokalisierungs-API wählen, die für Ihre Art von Anwendung am besten geeignet ist.

Schritt 3: Gestaltung der App

Dieser Schritt ist aus Sicht des Nutzers der wichtigste. Achten Sie bei der Gestaltung Ihrer App darauf, dass sie ansprechend und benutzerfreundlich ist und über eine angemessene Anzahl von Funktionen verfügt. Befolgen Sie gute UI/UX-Praktiken und überlegen Sie, wie der Endnutzer Ihre standortbasierte Anwendung nutzen wird.

Schritt 4: Erstellen eines MVP

Vor der Entwicklung einer vollwertigen Anwendung ist es sinnvoll, ein Minimum Viable Product (MVP) zu erstellen. Das MVP sollte so viele Funktionen enthalten, dass es von den ersten Nutzern verwendet werden kann, die dann ihr Feedback geben werden. Anhand des Feedbacks können Sie Ihre Idee validieren und Ihr Produkt verbessern.

Schritt 5: Vollversion und Freigabe

Der letzte Schritt, den Sie unternehmen müssen, ist die Erstellung einer Vollversion der Anwendung. Überprüfen Sie den Rückstand Ihres Projekts und implementieren Sie alle anderen wichtigen Funktionen. Beheben Sie alle Fehler und veröffentlichen Sie Ihre geobasierte App.

Nach der Veröffentlichung müssen Sie Ihre Anwendung natürlich weiter pflegen. Die Geolocation-API kann sich mit der Zeit ändern. Sie müssen Unterstützung für neuere Betriebssysteme hinzufügen, Fehler beheben, neue Funktionen hinzufügen und so weiter.

Wie entwickelt man eine Geolocation-App?

In diesem Artikel sehen wir uns an, wie man eine Geolocation-App mit Back4app und React Native mit Expo erstellt.

Voraussetzungen

• Erfahrung mit JavaScript, insbesondere ES6.
• Grundlegendes Verständnis von React Native (und Expo).
• JavaScript IDE auf Ihrem lokalen Rechner installiert.
• Android-Emulator oder ein physisches Android-Gerät.

Was ist Back4app?

Back4app ist ein hervorragendes Werkzeug für die schnelle Erstellung moderner Anwendungen, ohne dass fortgeschrittene Programmierkenntnisse erforderlich sind. Die Plattform verfügt über viele nützliche Funktionen, wie z. B. Benutzerverwaltung, Authentifizierung, Echtzeit-Datenbanken, Cloud-Code-Funktionen, soziale Integrationen, APIs und mehr.

Mit Back4app können Sie sich auf die wichtigen Teile Ihrer App konzentrieren, wie die Hauptfunktionalität und das Design, ohne sich um das Backend oder die komplizierte Infrastruktur zu kümmern.

Das Beste ist, dass Back4app einen kostenlosen Plan zum Testen und Ausprobieren anbietet. Wenn Ihre App wächst, können Sie dann nahtlos auf Premium-Pläne mit transparenten und vorhersehbaren Preisen upgraden.

Überblick über das Projekt

Um die Leistungsfähigkeit von Back4app zu demonstrieren, werden wir eine einfache Geolocation-App erstellen. Die App wird es den Nutzern ermöglichen, die Karte zu betrachten, in der Datenbank gespeicherte Orte anzuzeigen und Geodatenabfragen durchzuführen. Zu den Geoabfragen gehören das Sortieren von Orten nach Entfernung, das Auffinden von Orten in der Nähe und vieles mehr. Das Backend unserer App wird von Back4app verwaltet, und wir werden React Native und Google Maps im Frontend verwenden.

Back4app App erstellen

Für die folgenden Schritte müssen Sie ein Back4app-Konto haben. Wenn Sie noch keins haben, melden Sie sich einfach kostenlos an!

Wenn Sie sich anmelden, werden Sie zu Ihrer App-Liste weitergeleitet. Um eine neue App zu erstellen, klicken Sie auf “Neue App erstellen”.

Mit Back4app können wir entweder zwei Arten von Anwendungen bereitstellen:

1. Backend as a Service (BaaS ) – eine vollwertige Backend-Lösung, oder
2. Containers as a Service (CaaS) – eine Plattform für die Bereitstellung von Container-Software.

Da wir eine Geolocation-App bauen, entscheiden wir uns für “Backend as a Service”.

Geben Sie Ihrer Anwendung einen schönen Namen, wählen Sie “NoSQL” als Datenbank und klicken Sie auf “Erstellen”.

Back4app benötigt ein wenig Zeit, um alles Notwendige für Ihre Anwendung vorzubereiten. Sobald Ihre Anwendung fertig ist, werden Sie zur Datenbankansicht Ihrer Anwendung weitergeleitet.

Datenbank-Klassen erstellen

Nun müssen wir uns um die Datenbank kümmern.

Wie in der Projekteinführung erwähnt, wollen wir Orte in der Datenbank speichern und auf der Karte anzeigen. Dazu müssen wir eine neue Datenbankklasse erstellen, die diese Orte enthält.

Erstellen Sie eine neue Klasse, indem Sie auf die Schaltfläche “Create a class” klicken. Nennen Sie sie Place, aktivieren Sie “Public Read and Write” und klicken Sie auf “Create class & add columns”.

Fügen Sie dann die folgenden drei Spalten hinzu:

+-------------+-------------+--------------------+----------+
| Data type   | Name        | Default value      | Required |
+-------------+-------------+--------------------+----------+
| String      | name        | <leave blank>      | yes      |
+-------------+-------------+--------------------+----------+
| String      | description | <leave blank>      | no       |
+-------------+-------------+--------------------+----------+
| GeoPoint    | location    | <leave blank>      | yes      |
+-------------+-------------+--------------------+----------+

Nachdem Sie die Klasse erstellt haben, fügen Sie der Datenbank ein paar Beispielorte hinzu. Beispiel:

Alternativ können Sie diesen Datenbankexport der US-Bundesstaaten auch importieren. Verwenden Sie dazu die Schaltfläche mit den drei Punkten oben rechts auf dem Bildschirm, wählen Sie “Importieren > Klassendaten” und wählen Sie dann die Datei aus.

Großartig, wir haben erfolgreich eine Datenbankklasse erstellt und sie mit Daten gefüllt. Der Backend-Teil unseres Projekts ist nun abgeschlossen. Das war einfach!

Code Frontend

In diesem Abschnitt werden wir uns um den Frontend-Teil unserer Geolocation-App kümmern.

Init-Projekt

Für die folgenden Schritte ist es erforderlich, dass Sie Node installiert haben. Wenn Sie es nicht haben, laden Sie es herunter.

Beginnen Sie mit der Erstellung eines Expo-Projekts:

$ npx create-expo-app@latest back4app-geolocation-app --template blank@sdk-49

Wir haben die Vorlage blank@sdk-49 verwendet, weil wir die neueste Version des Expo SDK verwenden wollen.

Expo braucht etwa eine Minute, um alles für Ihr Projekt vorzubereiten. Sobald Ihr Projekt fertig ist, wechseln Sie in Ihr aktuelles Verzeichnis. Starten Sie dann den Expo-Entwicklungsserver:

$ cd back4app-geolocation-app
$ expo start

Drücken Sie A auf Ihrer Tastatur, um die App im Emulator oder auf dem angeschlossenen Android-Gerät zu öffnen.

React Native Karten

Um die Karte anzuzeigen, verwenden wir react-native-maps. React Native Maps ist ein großartiges Paket, das Kartenkomponenten für iOS und Android bietet. Es unterstützt Google Maps und MapKit.

Installieren Sie es zunächst über npm:

$ npx expo install react-native-maps

Als nächstes ersetzen Sie den Inhalt Ihrer App.js, um die wie folgt:

// App.js

import React from "react";
import {StyleSheet, View} from "react-native";
import MapView from "react-native-maps";

const initialRegion = {
  latitude: 30.0000,
  longitude: -100.0000,
  latitudeDelta: 64,
  longitudeDelta: 64,
};

export default function App() {
  return (
    <View style={styles.container}>
      <MapView
        initialRegion={initialRegion}
        style={styles.map}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
  },
  map: {
    zIndex: 10,
    width: "100%",
    height: "100%",
  },
});

Wenn Sie die App jetzt öffnen, sollten Sie die Karte sehen können.

Benutzerstandort abrufen

Um die Standorte der Benutzer abzurufen, verwenden wir das Paket expo-location.

Installieren Sie es zunächst über npm:

$ npx expo install expo-location

Bevor wir auf den Standort des Benutzers zugreifen, müssen wir seine Erlaubnis einholen. Dazu können wir die integrierte Expo-Funktion requestForegroundPermissionsAsync() in der useEffect() wie folgt verwenden:

// App.js

import React, {useEffect, useState} from "react";
import {StyleSheet, View} from "react-native";
import MapView, {Marker} from "react-native-maps";
import * as Location from "expo-location";

// ...

export default function App() {

  const [location, setLocation] = useState(null);

  useEffect(() => {
    (async () => {
      let {status} = await Location.requestForegroundPermissionsAsync();
      if (status !== "granted") {
        console.error("Permission to access location was denied.");
        return;
      }
      let location = await Location.getCurrentPositionAsync({});
      setLocation(location);
    })();
  }, []);

  return (
    <View style={styles.container}>
      <MapView
        initialRegion={initialRegion}
        style={styles.map}
      >
        {location && (
          <Marker
            title="You are here"
            description={`
              ${location.coords.latitude.toFixed(4)},
              ${location.coords.longitude.toFixed(4)}
            `}
            coordinate={{
              latitude: location.coords.latitude,
              longitude: location.coords.longitude,
            }}
            pinColor="blue"
          />
        )}
      </MapView>
    </View>
  );
}

// ...

1. Wenn die App startet, fragen wir den Benutzer um Erlaubnis, auf seinen groben Standort zuzugreifen. Wenn der Zugriff gewährt wird, speichern wir den Standort mit useState() im Standortstatus.
2. Wir haben die Rückgabeanweisung aktualisiert, um den Standort des Benutzers anzuzeigen (wenn der Standort nicht null ist).

Starten Sie die App erneut, und Sie sollten eine blaue Markierung sehen können, die Ihren aktuellen Standort anzeigt.

Parsen installieren

Wie Sie vielleicht wissen, basiert Back4app auf der Parse-Plattform. Wenn wir mit der Back4app-Datenbank oder Back4app im Allgemeinen interagieren wollen, müssen wir das Parse SDK installieren.

Installieren Sie zunächst das Parse SDK:

$ npx expo install [email protected] @react-native-async-storage/async-storage

Ich habe Parse Version 3.5.1 verwendet, da die neuere Version nicht gut mit Expo SDK 49 zusammenarbeitet.

Als nächstes erstellen Sie eine Parse-Instanz in App.js direkt unter den Importen:

// App.js

// ...

import Parse from "parse/react-native.js";
import AsyncStorage from "@react-native-async-storage/async-storage";

Parse.setAsyncStorage(AsyncStorage);
Parse.initialize(
  process.env.EXPO_PUBLIC_PARSE_APPLICATION_ID,
  process.env.EXPO_PUBLIC_PARSE_JAVASCRIPT_KEY,
);
Parse.serverURL = "https://parseapi.back4app.com/";

// ...

Wir werden Umgebungsvariablen verwenden, anstatt die Parse-Anwendungs-ID und den JavaScript-Schlüssel fest zu kodieren. Seit SDK 49 lädt Expo automatisch Umgebungsvariablen aus der Datei .env.local.

Erstellen Sie die Datei .env.local im Stammverzeichnis des Projekts mit folgendem Inhalt:

EXPO_PUBLIC_PARSE_APPLICATION_ID=<parse_app_id>
EXPO_PUBLIC_PARSE_JAVASCRIPT_KEY=<parse_javascript_key>

Stellen Sie sicher, dass Sie die und durch Ihre tatsächliche ID und Ihren Schlüssel ersetzen. Um Ihre Anmeldedaten zu erhalten, navigieren Sie zu Ihrer Back4app-App und wählen Sie in der Seitenleiste “App-Einstellungen > Sicherheit & Schlüssel”.

Orte aus der Datenbank abrufen

Um Orte aus der Datenbank abzurufen, verwenden wir die Parse-Instanz, die wir im vorherigen Schritt erstellt haben.

Zunächst müssen wir eine neue Parse.Query für die Klasse Place erstellen und dann find() ausführen, um die Abfrage zu starten. Danach wandeln wir die Ergebnisse in unser Marker-Format um.

Ändern Sie Ihre App.js wie folgt:

// App.js

// ...

export default function App() {

  // ...

  const [places, setPlaces] = useState([]);

  useEffect(() => {
    // ...

    // fetch `Place` objects from the database
    const placesQuery = new Parse.Query("Place");
    placesQuery.find().then((places) => {
      places = places.map((place) => {
        return {
          title: place.get("name"),
          description: place.get("description"),
          coordinate: {
            latitude: place.get("location").latitude,
            longitude: place.get("location").longitude,
          },
        };
      });
      setPlaces(places);
    });
  }, []);

  return (
    <View style={styles.container}>
      <MapView
        initialRegion={initialRegion}
        style={styles.map}
      >
        // ...
        {places.map((place, index) => (
          <Marker
            key={index}
            title={place.title}
            description={place.description}
            coordinate={place.coordinate}
          />
        ))}
      </MapView>
    </View>
  );
}

// ...

1. Wir haben useState() verwendet, um einen weiteren Status zu erstellen, der Markierungen für Orte enthält.
2. Wir haben den useEffect()-Hook aktualisiert, um die Orte beim Start der Anwendung aus der Datenbank zu holen.
3. Wir haben die Rendering-Funktion geändert, um Platzmarkierungen auf der Karte anzuzeigen.

Öffnen Sie Ihre App noch einmal, und Sie sollten alle Orte sehen können.

Geoabfragen

In diesem letzten Abschnitt sehen wir uns an, wie man mit Back4app Geodatenabfragen durchführt.

Parse wird mit einer Klasse namens GeoPoint ausgeliefert. Die Klasse GeoPoint stellt einen Breitengrad/Längengrad-Punkt dar und ermöglicht die Berechnung von Entfernungen zwischen zwei GeoPointsund die Durchführung von Abfragen, die auf Nähe basieren.

Wir werden diese Klasse nutzen, um die folgenden zwei Funktionen zu implementieren:

1. Sortieren Sie Orte vom Standort des Benutzers aus nach Entfernung.
2. Suche nach Orten im Umkreis von X Kilometern um den Standort des Benutzers.

Fügen Sie Folgendes zu Ihrer App.js hinzu:

// App.js

// ...

const maxDistance = 3000;

export default function App() {

  // ...

  const sortPlacesByProximity = async () => {
    let parseQuery = new Parse.Query("Place");
    let locationGeoPoint = new Parse.GeoPoint(
        location.coords.latitude,
        location.coords.longitude
    );
    parseQuery.near("location", locationGeoPoint);

    let results = await parseQuery.find();
    for (let result of results) {
      console.log(result.get("name"));
    }
  };

  const findPlacesWithinDistance = async () => {
    let parseQuery = new Parse.Query("Place");
    let locationGeoPoint = new Parse.GeoPoint(
        location.coords.latitude,
        location.coords.longitude
    );
    parseQuery.withinKilometers("location", locationGeoPoint, maxDistance);

    let results = await parseQuery.find();
    for (let result of results) {
      console.log(result.get("name"));
    }
  }

  const moveUserToRandomLocation = () => {
    setLocation({
      coords: {
        latitude: Math.random() * (-78.848974 - -103.520833) + 31.3845,
        longitude: Math.random() * (-78.848974 - -123.885444) + -123.885444,
      }
    });
  };

  return (
    <View style={styles.container}>
      <View style={styles.buttonContainer}>
        <Button
          title="Sort places by proximity"
          color="#239658"
          onPress={sortPlacesByProximity}
        />
        <Button
          title={`Find places within ${maxDistance} km`}
          color="#239658"
          onPress={findPlacesWithinDistance}
        />
        <Button
          title="Move user to random location"
          color="#061124"
          onPress={moveUserToRandomLocation}
        />
      </View>
      // ...
    </View>
  );
}

const styles = StyleSheet.create({
  // ...
  buttonContainer: {
    zIndex: 25,
    width: "100%",
    position: "absolute",
    bottom: 0,
    marginVertical: 4,
    display: "flex",
    gap: 4,
  },
});

1. sortPlacesByProximity() und findPlacesWithinDistance() wandeln zunächst den Standort des Benutzers in einen GeoPoint um, erstellen eine Parse.Query und führen dann eine bestimmte Geo-Funktion aus.
2. moveUserToRandomLocation() wird verwendet, um den Benutzer an einen zufälligen Ort innerhalb der USA zu bringen. Diese Methode wird in erster Linie zum Testen der beiden zuvor genannten Methoden verwendet.
3. Außerdem haben wir drei Schaltflächen zum Auslösen der entsprechenden Funktionen hinzugefügt.

Vergessen Sie nicht den Import am Anfang der Datei:

import {Button, StyleSheet, View} from "react-native";

Starten Sie den Server erneut, und Sie sollten folgendes sehen:

Testen Sie die Geoabfragen, indem Sie auf die Schaltfläche “Orte nach Nähe sortieren” klicken:

LOG  Arizona
LOG  Idaho
LOG  Oklahoma
LOG  Florida
LOG  New York

Machen Sie das Gleiche für die Fernabfragefunktion:

LOG  Arizona
LOG  Idaho
LOG  Oklahoma

Zum Schluss bringen Sie den Benutzer an einen zufälligen Ort und testen die Geoabfragen erneut.

Schlussfolgerung

In diesem Artikel haben wir erfolgreich eine Geolocation-App entwickelt. Mit der App können Benutzer die Karte anzeigen, ihren Standort sehen, Orte aus der Datenbank abrufen und Geoabfragen durchführen. Inzwischen sollten Sie ein gutes Verständnis dafür haben, wie Geolocation-Apps funktionieren und wie sie aufgebaut sind.

Hier sind einige Ideen, die Sie umsetzen können, um Ihr Verständnis zu testen:

• Verfolgung des Benutzerstandorts in Echtzeit (die Benutzermarkierung sollte sich bewegen, wenn sich das Gerät bewegt)
• Nutzerstandortverlauf (Nutzer sollten ihren Standortverlauf einsehen können)
• Navigation (Anzeige des Pfades vom Standort des Benutzers zu einem benutzerdefinierten Standort)

Der Quellcode ist auf dem GitHub-Repository back4app-geolocation-app verfügbar.