Pojęcia zaawansowane

Pozyskiwanie danych

Zebrane dane o lokalizacji można uzyskać na wiele sposobów. W tym przykładzie opisujemy 2 technik pozyskiwania danych do wykorzystania z funkcją przyciągnięcia do dróg Roads API.

GPX

GPX to otwarty format XML do udostępniania tras, tras i punktów pośrednich. przechwytywane przez urządzenia GPS. W tym przykładzie używany jest parser XmlPull, lekki parser XML, który jest dostępny zarówno dla serwerów Java, jak i środowisk 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 nieprzetworzone dane GPX wczytane na mapę.

Usługi lokalizacyjne w Androidzie

Najlepszy sposób rejestrowania danych GPS z urządzenia z Androidem zależy od dla każdego przypadku użycia. Skorzystaj z zajęć szkoleniowych na temat Androida w sekcji Odbieranie lokalizacji Aktualizacje oraz przykłady lokalizacji w Google Play w GitHub.

Długie ścieżki przetwarzania

Funkcja Przyciągnięcie do dróg określa lokalizację na podstawie pełnej ścieżki, zamiast pojedynczych punktów musisz więc przemyśleć, ile czasu zajmuje Ci ścieżki (czyli ścieżki przekraczające limit 100 punktów na żądanie).

Aby traktować poszczególne żądania jako jedną długą ścieżkę, musisz w nich uwzględnić częściowo się pokrywają, co powoduje uwzględnienie punktów końcowych z poprzedniego żądania. . Liczba punktów do uwzględnienia zależy od dokładności danych. Musisz podać więcej punktów w przypadku żądań o niskiej dokładności.

W tym przykładzie używamy klienta Java dla usług Map Google do wysyłania żądań stron oraz a następnie ponownie łączy dane, łącznie z interpolowanymi punktami, w zwróconej 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 powyższe dane po uruchomieniu funkcji przyciągania do dróg. Czerwony oznacza nieprzetworzone dane, a niebieska – dane przyciągnięte.

Efektywne wykorzystanie limitu

Odpowiedź na żądanie przyciągnięcia do dróg zawiera listę identyfikatorów miejsc. które są mapowane na podane przez Ciebie punkty, potencjalnie z dodatkowymi punktami, jeśli ustaw interpolate=true.

Aby skutecznie wykorzystać dozwolony limit w przypadku prośby o ograniczenie prędkości, w żądaniu umieść tylko unikalne identyfikatory miejsc. W tym przykładzie użyto klienta Java do usług Map Google do wysyłania zapytań o ograniczenia szybkości z listy miejsc Identyfikatory.

/**
 * 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 powyższe dane z ograniczeniami prędkości oznaczonymi przy każdym unikalnym identyfikatorze miejsca.

Współpraca z innymi interfejsami API

Jedną z korzyści związanych z zwracaniem identyfikatorów miejsc w przypadku przyciągania do dróg jest to, że identyfikatorów miejsca można używać w wielu interfejsów API Google Maps Platform. W tym przykładzie używany jest klient Java dla usług Map Google. do geokodowania miejsca zwróconego w odpowiedzi na żądanie drogi.

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

Na znaczniku ograniczenia prędkości znajduje się adnotacja z adresem Geocoding API.

Przykładowy kod

Uwagi

Kod obsługujący ten artykuł jest dostępny jako pojedyncza aplikacja na Androida w celach ilustracyjnych. W praktyce nie należy przeprowadzać dystrybucji po stronie serwera Kluczy interfejsu API w aplikacji na Androida jako klucza nie mogą być zabezpieczone przed nieautoryzowanymi nie może uzyskać dostępu przez inną firmę. Zamiast tego, aby zabezpieczyć swoje klucze, zaimplementuj kod przez interfejs API jako serwer proxy po stronie serwera i umożliwianie aplikacji na Androida wysyłania żądań; przez serwer proxy, co zapewnia autoryzację żądań.

Pobierz

Pobierz kod z GitHub.