Pojęcia zaawansowane

Pozyskiwanie danych

Dane o lokalizacji można uzyskać na wiele sposobów. Poniżej opisujemy 2 metody pozyskiwania danych do użycia z funkcją Roads API dopasowania do dróg.

GPX

GPX to otwarty format oparty na XML, służący do udostępniania tras, ścieżek i punktów kontrolnych zarejestrowanych przez urządzenia GPS. W tym przykładzie użyto parsowania XmlPull, czyli lekkiego parsowania XML dostępnego zarówno na serwerach Java, jak i w środowiskach mobilnych.

/**
 * 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;
}

Oto surowe dane GPX załadowane na mapę.

Nieprzetworzone dane GPX na mapie

Usługi lokalizacyjne Androida

Najlepszy sposób rejestrowania danych GPS na urządzeniu z Androidem zależy od przypadku użycia. Zapoznaj się z treningiem na temat Androida dotyczącym odbierania aktualizacji lokalizacji oraz z przykładami kodu lokalizacji Google Play na GitHubie.

Przetwarzanie długich ścieżek

Funkcja dopasowania do dróg określa lokalizację na podstawie pełnej ścieżki, a nie poszczególnych punktów, dlatego należy zachować ostrożność podczas przetwarzania długich ścieżek (czyli ścieżek przekraczających limit 100 punktów na żądanie).

Aby traktować poszczególne żądania jako jedną długą ścieżkę, musisz uwzględnić pewną część nakładającą się na siebie, tak aby ostatnie punkty z poprzedniego żądania były uwzględnione jako pierwsze punkty kolejnego żądania. Liczba punktów do uwzględnienia zależy od dokładności danych. W przypadku zapytań o niską dokładność należy uwzględnić więcej punktów.

W tym przykładzie do wysyłania żądań po stronie używamy klienta Java dla usług Map Google, a następnie dane, w tym punkty interpolowane, są ponownie łączone na zwracanej liście.

/**
 * 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;
}

Oto dane z powyższego przykładu po wykonaniu zapytań dotyczących dopasowania do dróg. Czerwona linia to dane nieprzetworzone, a niebieska – dane przetworzone.

Przykład danych, które zostały dopasowane do dróg

Skuteczne wykorzystanie limitu

Odpowiedź na żądanie dopasowania do dróg zawiera listę identyfikatorów miejsc, które pasują do podanych przez Ciebie punktów, a w razie potrzeby – także dodatkowych punktów, jeśli ustawisz parametr interpolate=true.

Aby efektywnie korzystać z dozwolonej puli limitów prędkości, w zapytaniu należy uwzględnić tylko unikalne identyfikatory miejsc. W tym przykładzie do zapytania o ograniczenia prędkości na podstawie listy identyfikatorów miejsc używamy klienta Java dla usług Map Google.

/**
 * 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;
}

Oto dane z powyżej z ograniczeniami prędkości oznaczonymi przy każdym niepowtarzalnym identyfikatorze miejsca.

Znaki ograniczenia prędkości na mapie

Współdziałanie z innymi interfejsami API

Jedną z zalet zwracania identyfikatorów miejsc w odpowiedziach interfejsu snapToRoads jest możliwość używania identyfikatorów miejsc w wielu interfejsach API Google Maps Platform. W tym przykładzie do geokodowania miejsca zwróconego przez powyższą prośbę o przejście do drogi używamy klienta Java do usług Map Google.

/**
 * 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;
}

Tutaj znak ograniczenia prędkości został opatrzony adnotacją z adresem z interfejsu Geocoding API.

Geokodowany adres wyświetlany na znaczniku

Przykładowy kod

Uwagi

Kod, który ilustruje ten artykuł, jest dostępny w postaci pojedynczej aplikacji na Androida. W praktyce nie należy rozpowszechniać kluczy interfejsu API po stronie serwera w aplikacji na Androida, ponieważ nie można ich zabezpieczyć przed nieautoryzowanym dostępem osób trzecich. Aby zabezpieczyć klucze, należy wdrożyć kod interfejsu API jako serwerowy serwer proxy i skonfigurować aplikację na Androida tak, aby wysyłała żądania przez serwerowy serwer proxy, co zapewni ich autoryzację.

Pobierz

Pobierz kod ze GitHub.