Concepts avancés

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Récupération des données...

Il existe plusieurs manières d'obtenir des données de géolocalisation collectées. Nous décrivons ici deux techniques d'acquisition de données à utiliser avec la fonctionnalité Snap to Roads de Roads API.

GPX

GPX est un format XML ouvert permettant de partager des itinéraires, des parcours et des points de cheminement enregistrés par des appareils GPS. Cet exemple utilise l'analyseur XmlPull, qui est un analyseur XML léger disponible pour les serveurs Java et les environnements mobiles.

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

Voici quelques données GPX brutes chargées sur une carte.

Données GPX brutes sur une carte

Services de localisation Android

La meilleure méthode pour capturer les données GPS à partir d'un appareil Android varie en fonction de votre cas d'utilisation. Consultez la formation Android sur la réception des mises à jour de position, ainsi que les exemples d'emplacements Google Play sur GitHub.

Traiter des chemins longs

Étant donné que la fonctionnalité d'ancrage vers les routes déduit le lieu en fonction du chemin complet, plutôt que de points individuels, vous devez faire attention lorsque vous traitez des chemins longs (c'est-à-dire les chemins qui dépassent la limite de 100 points par requête).

Afin de traiter les requêtes individuelles comme un chemin long, vous devez inclure un certain chevauchement, de sorte que les points finaux de la requête précédente soient inclus en tant que premiers points de la requête suivante. Le nombre de points à inclure dépend de la précision de vos données. Vous devez inclure plus de points pour les requêtes de faible précision.

Cet exemple utilise le client Java pour les services Google Maps pour envoyer des requêtes paginées, puis réintègre les données, y compris les points interpolés, dans la liste renvoyée.

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

Voici les données ci-dessus après l'exécution des requêtes Snap to Roads. La ligne rouge correspond aux données brutes, tandis que la ligne bleue correspond aux données ancrées.

Exemple de données alignées sur des routes

Utilisation efficace des quotas

La réponse à une requête Snap to Roads inclut une liste d'ID de lieu correspondant aux points que vous avez fournis, éventuellement avec des points supplémentaires si vous définissez interpolate=true.

Afin d'utiliser efficacement votre quota autorisé pour une requête de limites de vitesse, vous ne devez interroger que les ID de lieux uniques dans votre requête. Cet exemple utilise le client Java pour les services Google Maps pour interroger les limites de vitesse à partir d'une liste d'ID de lieu.

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

Voici les données ci-dessus, avec les limitations de vitesse indiquées pour chaque identifiant de lieu unique.

Panneaux de limitation de vitesse sur une carte

Interaction avec d'autres API

L'un des avantages du renvoi des ID de lieu dans les réponses Snap to Roads est que vous pouvez les utiliser dans de nombreuses API Google Maps Platform. Cet exemple utilise le client Java pour les services Google Maps afin de géocoder un lieu renvoyé par la requête Snapchat ci-dessus.

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

Ici, le repère de vitesse a été annoté avec l'adresse de l'API Geocoding.

Adresse géocodée indiquée sur un repère

Exemple de code

Points à prendre en compte

Le code compatible avec cet article est disponible dans une seule application Android à titre d'illustration. En pratique, vous ne devez pas distribuer vos clés API côté serveur dans une application Android, car votre clé ne peut pas être protégée contre les accès non autorisés provenant d'un tiers. Pour sécuriser vos clés, vous devez déployer le code côté API en tant que proxy côté serveur et laisser votre application Android envoyer des requêtes via le proxy, en vous assurant que les requêtes sont autorisées.

Télécharger

Téléchargez le code depuis GitHub.