Concetti avanzati

Acquisizione dei dati

Esistono molti modi per ottenere i dati sulla posizione raccolti. Qui descriviamo due tecniche per l'acquisizione dei dati da utilizzare con la funzionalità Allinea alle strade di Roads API.

GPX

GPX è un formato aperto basato su XML per la condivisione di percorsi, tracce e waypoint acquisiti dai dispositivi GPS. In questo esempio viene utilizzato l'analizzatore sintattico XmlPull, un parser XML leggero disponibile sia per gli ambienti server Java che per gli ambienti mobili.

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

Ecco alcuni dati GPX non elaborati caricati su una mappa.

Dati GPX non elaborati su una mappa

Servizi di geolocalizzazione Android

Il modo migliore per acquisire i dati GPS da un dispositivo Android varia a seconda del caso d'uso. Consulta il corso di formazione Android sulla ricezione degli aggiornamenti della posizione, nonché gli esempi di Google Play Location su GitHub.

Elaborazione di percorsi lunghi

Poiché la funzionalità di aggancio alle strade deducono la posizione in base al percorso completo, piuttosto che ai singoli punti, devi prestare attenzione quando elabori percorsi lunghi (ovvero percorsi che superano il limite di 100 punti per richiesta).

Per considerare le singole richieste come un unico percorso lungo, devi includere una certa sovrapposizione, in modo che i punti finali della richiesta precedente siano inclusi come primi punti della richiesta successiva. Il numero di punti da includere dipende dall'accuratezza dei dati. Dovresti includere più punti per le richieste con bassa precisione.

Questo esempio utilizza il client Java per i servizi Google Maps per inviare richieste paginate e poi riunisce i dati, inclusi i punti interpolati, nell'elenco restituito.

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

Ecco i dati riportati sopra dopo l'esecuzione delle richieste di adeguamento alle strade. La linea rossa rappresenta i dati non elaborati e la linea blu i dati agganciati.

Esempio di dati allineati alle strade

Utilizzo efficiente della quota

La risposta a una richiesta di adattamento alle strade include un elenco di ID luogo che corrispondono ai punti che hai fornito, potenzialmente con punti aggiuntivi se hai impostato interpolate=true.

Per utilizzare in modo efficiente la quota consentita per una richiesta di limiti di velocità, devi eseguire query solo per ID luogo univoci nella richiesta. Questo esempio utilizza il client Java per i servizi Google Maps per eseguire query sui limiti di velocità da un elenco di ID luogo.

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

Di seguito sono riportati i dati precedenti con i limiti di velocità contrassegnati in ogni ID luogo univoco.

Cartelli stradali con limite di velocità su una mappa

Interazione con altre API

Uno dei vantaggi dell'avere ID luogo restituiti nelle risposte di adattamento alle strade è che puoi utilizzare l'ID luogo in molte delle API di Google Maps Platform. Questo esempio utilizza il client Java per i servizi Google Maps per geocodificare un luogo restituito dalla richiesta di aggancio alla strada riportata sopra.

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

Qui l'indicatore del limite di velocità è stato annotato con l'indirizzo dell'API Geocoding.

Indirizzo geocodificato mostrato su un indicatore

Codice di esempio

Considerazioni

Il codice alla base di questo articolo è disponibile come singola app per Android a scopo illustrativo. In pratica, non dovresti distribuire le chiavi API lato server in un'app per Android perché non possono essere protette dall'accesso non autorizzato di terze parti. Per proteggere le tue chiavi, devi implementare il codice rivolto all'API come proxy lato server e fare in modo che la tua app per Android invii le richieste tramite il proxy, assicurandoti che siano autorizzate.

Scarica

Scarica il codice da GitHub.