Pojęcia zaawansowane

Pozyskiwanie danych

Zebrane dane o lokalizacji można uzyskiwać na wiele sposobów. Tutaj opisujemy 2 metody pozyskiwania danych, które można wykorzystać z użyciem funkcji przyciągania do dróg w komponencie Roads API.

GPX

GPX to otwarty format oparty na języku XML, który służy do udostępniania tras, ścieżek i punktów pośrednich zarejestrowanych przez urządzenia GPS. W tym przykładzie korzystamy z parsera XmlPull, czyli lekkiego parsera XML dostępnego zarówno na potrzeby serwera 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 kilka nieprzetworzonych danych GPX wczytanych na mapę.

Usługi lokalizacyjne na Androidzie

Najlepszy sposób rejestrowania danych GPS na urządzeniu z Androidem zależy od konkretnego przypadku użycia. Zapoznaj się z klasą szkoleniową dotyczącą Androida o odbieraniu aktualizacji lokalizacji oraz przykładami lokalizacji w Google Play na GitHubie.

Przetwarzanie długich ścieżek

Funkcja przyciągania do dróg ustala lokalizację na podstawie całej ścieżki, a nie poszczególnych punktów, więc musisz 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ę, należy uwzględnić pewne jej części, tak aby końcowe punkty z poprzedniego żądania były uwzględniane jako pierwsze punkty kolejnego żądania. Liczba punktów zależy od dokładności danych. W przypadku żądań o niskiej dokładności należy uwzględnić więcej punktów.

W tym przykładzie używamy klienta Java do usług Map Google, aby wysyłać żądania z podziałem na strony, a następnie ponownie łączyć dane, m.in. interpolowane punkty, do zwróconej listy.

/**
 * 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ższych danych po uruchomieniu przyciągania do próśb o drogę. Czerwona linia pokazuje nieprzetworzone dane, a niebieska – dane wygenerowane.

Efektywne wykorzystanie limitu

Odpowiedź na żądanie przyciągania do dróg zawiera listę identyfikatorów miejsc mapowanych na podane przez Ciebie punkty. Mogą też zawierać dodatkowe punkty, jeśli ustawisz wartość interpolate=true.

Aby skutecznie wykorzystać dozwolony limit w odpowiedzi na prośbę o ograniczenia prędkości, wysyłaj prośby tylko o unikalne identyfikatory miejsc. W tym przykładzie używamy klienta Java do usług Map Google, aby wysyłać zapytania o ograniczenia prędkości z listy identyfikatorów miejsc.

/**
 * 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 niepowtarzalnym identyfikatorze miejsca.

Współdziałanie z innymi interfejsami API

Jedną z zalet zwracania identyfikatorów miejsc w odpowiedziach na pytanie z drogi jest możliwość używania identyfikatora miejsca w wielu interfejsach API Google Maps Platform. W tym przykładzie używamy klienta Java dla usług Map Google, aby geokodować miejsce zwrócone z powyższego żądania.

/**
 * 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 znacznik ograniczenia prędkości ma adres z interfejsu Geocoding API.

Przykładowy kod

co należy wziąć pod uwagę

Kod obsługujący ten artykuł jest dostępny w postaci pojedynczej aplikacji na Androida w celach ilustracyjnych. W praktyce nie należy rozpowszechniać kluczy interfejsu API po stronie serwera w aplikacji na Androida, ponieważ klucz nie może być zabezpieczony przed nieautoryzowanym dostępem z zewnątrz. Zamiast tego, aby zabezpieczyć swoje klucze, musisz wdrożyć kod przeznaczony dla interfejsu API jako serwer proxy po stronie serwera. Aplikacja na Androida będzie wysyłać żądania przez ten serwer, co zapewni ich autoryzację.

Pobieranie

Pobierz kod z GitHub.