Erweiterte Konzepte

Daten erfassen

Es gibt viele Möglichkeiten, um an erfasste Standortdaten zu kommen. Hier werden zwei Techniken zum Erfassen von Daten für die Funktion An Straßen ausrichten des Roads API beschrieben.

GPX

GPX ist ein offenes XML-basiertes Format zum Teilen von Routen, Tracks und Wegpunkten, die von GPS-Geräten erfasst wurden. In diesem Beispiel wird der XmlPull-Parser verwendet, ein einfacher XML-Parser, der sowohl für Java-Server- als auch für mobile Umgebungen verfügbar ist.

/**
 * Parses the waypoint (wpt tags) data into native objects from a GPX stream.
 */
private List<LatLng> loadGpxData(XmlPullParser parser, InputStream gpxIn)
        throws XmlPullParserException, IOException {
    // We use a List<> as we need subList for paging later
    List<LatLng> latLngs = new ArrayList<>();
    parser.setInput(gpxIn, null);
    parser.nextTag();

    while (parser.next() != XmlPullParser.END_DOCUMENT) {
        if (parser.getEventType() != XmlPullParser.START_TAG) {
            continue;
        }

        if (parser.getName().equals("wpt")) {
            // Save the discovered latitude/longitude attributes in each <wpt>.
            latLngs.add(new LatLng(
                    Double.valueOf(parser.getAttributeValue(null, "lat")),
                    Double.valueOf(parser.getAttributeValue(null, "lon"))));
        }
        // Otherwise, skip irrelevant data
    }

    return latLngs;
}

Hier sehen Sie einige Roh-GPX-Daten, die auf eine Karte geladen wurden.

Roh-GPX-Daten auf einer Karte

Android-Standortdienste

Die beste Methode zum Erfassen von GPS-Daten von einem Android-Gerät hängt von Ihrem Anwendungsfall ab. Sehen Sie sich den Android-Trainingskurs zum Empfangen von Standortaktualisierungen sowie die Google Play-Standortbeispiele auf GitHub an.

Lange Pfade verarbeiten

Da die Funktion An Straßen ausrichten den Standort anhand des vollständigen Pfads und nicht anhand einzelner Punkte ableitet, müssen Sie bei der Verarbeitung langer Pfade (d. h. Pfade mit mehr als 100 Punkten pro Anfrage) vorsichtig sein.

Damit die einzelnen Anfragen als ein langer Pfad behandelt werden, sollten Sie für eine gewisse Überschneidung sorgen. Die letzten Punkte der vorherigen Anfrage sollten also als erste Punkte der nachfolgenden Anfrage enthalten sein. Die Anzahl der einzubeziehenden Punkte hängt von der Genauigkeit Ihrer Daten ab. Bei Anfragen mit geringer Genauigkeit sollten Sie mehr Punkte einbeziehen.

In diesem Beispiel wird der Java-Client für Google Maps-Dienste verwendet, um paginierte Anfragen zu senden. Anschließend werden die Daten, einschließlich interpolierter Punkte, in die zurückgegebene Liste eingefügt.

/**
 * Snaps the points to their most likely position on roads using the Roads API.
 */
private List<SnappedPoint> snapToRoads(GeoApiContext context) throws Exception {
    List<SnappedPoint> snappedPoints = new ArrayList<>();

    int offset = 0;
    while (offset < mCapturedLocations.size()) {
        // Calculate which points to include in this request. We can't exceed the API's
        // maximum and we want to ensure some overlap so the API can infer a good location for
        // the first few points in each request.
        if (offset > 0) {
            offset -= PAGINATION_OVERLAP;   // Rewind to include some previous points.
        }
        int lowerBound = offset;
        int upperBound = Math.min(offset + PAGE_SIZE_LIMIT, mCapturedLocations.size());

        // Get the data we need for this page.
        LatLng[] page = mCapturedLocations
                .subList(lowerBound, upperBound)
                .toArray(new LatLng[upperBound - lowerBound]);

        // Perform the request. Because we have interpolate=true, we will get extra data points
        // between our originally requested path. To ensure we can concatenate these points, we
        // only start adding once we've hit the first new point (that is, skip the overlap).
        SnappedPoint[] points = RoadsApi.snapToRoads(context, true, page).await();
        boolean passedOverlap = false;
        for (SnappedPoint point : points) {
            if (offset == 0 || point.originalIndex >= PAGINATION_OVERLAP - 1) {
                passedOverlap = true;
            }
            if (passedOverlap) {
                snappedPoints.add(point);
            }
        }

        offset = upperBound;
    }

    return snappedPoints;
}

Hier sind die Daten von oben nach Ausführung der Anfragen zum Anpassen an Straßen. Die rote Linie stellt die Rohdaten und die blaue Linie die angepassten Daten dar.

Beispiel für Daten, die an Straßen ausgerichtet wurden

Effiziente Nutzung des Kontingents

Die Antwort auf eine snap to roads-Anfrage enthält eine Liste von Orts-IDs, die den von Ihnen angegebenen Punkten zugeordnet sind. Wenn Sie interpolate=true festlegen, können zusätzliche Punkte enthalten sein.

Damit Sie Ihr zulässiges Kontingent für eine Anfrage zu Tempolimits effizient nutzen, sollten Sie in Ihrer Anfrage nur eindeutige Orts-IDs abfragen. In diesem Beispiel wird der Java-Client für Google Maps-Dienste verwendet, um Tempolimits für eine Liste von Orts-IDs abzufragen.

/**
 * Retrieves speed limits for the previously-snapped points. This method is efficient in terms
 * of quota usage as it will only query for unique places.
 *
 * Note: Speed limit data is only available for requests using an API key enabled for a
 * Google Maps APIs Premium Plan license.
 */
private Map<String, SpeedLimit> getSpeedLimits(GeoApiContext context, List<SnappedPoint> points)
        throws Exception {
    Map<String, SpeedLimit> placeSpeeds = new HashMap<>();

    // Pro tip: Save on quota by filtering to unique place IDs.
    for (SnappedPoint point : points) {
        placeSpeeds.put(point.placeId, null);
    }

    String[] uniquePlaceIds =
            placeSpeeds.keySet().toArray(new String[placeSpeeds.keySet().size()]);

    // Loop through the places, one page (API request) at a time.
    for (int i = 0; i < uniquePlaceIds.length; i += PAGE_SIZE_LIMIT) {
        String[] page = Arrays.copyOfRange(uniquePlaceIds, i,
                Math.min(i + PAGE_SIZE_LIMIT, uniquePlaceIds.length));

        // Execute!
        SpeedLimit[] placeLimits = RoadsApi.speedLimits(context, page).await();
        for (SpeedLimit sl : placeLimits) {
            placeSpeeds.put(sl.placeId, sl);
        }
    }

    return placeSpeeds;
}

Hier sind die Daten von oben mit Geschwindigkeitsbegrenzungen, die an jeder eindeutigen Orts-ID markiert sind.

Tempolimitschilder auf einer Karte

Zusammenwirken mit anderen APIs

Einer der Vorteile der Orts-IDs in den snap to roads-Antworten ist, dass Sie die Orts-ID für viele Google Maps Platform APIs verwenden können. In diesem Beispiel wird der Java-Client für Google Maps-Dienste verwendet, um einen Ort zu geocodieren, der von der oben genannten Anfrage zum Anpassen an die Straße zurückgegeben wurde.

/**
 * Geocodes a snapped point using the place ID.
 */
private GeocodingResult geocodeSnappedPoint(GeoApiContext context, SnappedPoint point) throws Exception {
    GeocodingResult[] results = GeocodingApi.newRequest(context)
            .place(point.placeId)
            .await();

    if (results.length > 0) {
        return results[0];
    }
    return null;
}

Hier wurde die Markierung für das Tempolimit mit der Adresse aus der Geocoding API versehen.

Geocodierte Adresse auf einer Markierung

Beispielcode

Hinweise

Der Code, der dieses Dokument unterstützt, ist zu Veranschaulichungszwecken als einzelne Android-App verfügbar. In der Praxis sollten Sie Ihre serverseitigen API-Schlüssel nicht in einer Android-App verteilen, da Ihr Schlüssel nicht vor unbefugtem Zugriff durch Dritte geschützt werden kann. Stattdessen sollten Sie den API-orientierten Code als serverseitigen Proxy bereitstellen und Ihre Android-App Anfragen über den Proxy senden lassen, um sicherzustellen, dass Anfragen autorisiert sind.

Herunterladen

Laden Sie den Code von GitHub herunter.