web-dev-qa-db-fra.com

Existe-t-il un moyen d'afficher les itinéraires routiers dans Google Map API v2?

Je cherchais une réponse à l'aide de Google et ici, et les seuls messages pertinents que j'ai trouvés sont:

Google Maps Android V2 et API de direction

Obtenir des itinéraires à l'aide de Google Maps API v2

mais il n'y a pas de réponse ici. Donc, je l’ai déjà mentionné, mais je le répète .. Je recherche une solution pour l'API Google Map v2 utilisant FragmentActivity et un objet SupportMagFragment et LatLng sans utiliser MapView, MapActivtiy et GeoPoint.

De plus, je n'ai pas d'objet Overlay à utiliser, je ne peux donc pas peindre la direction sur la carte. Existe-t-il une alternative à cela? 

Alors, y a-t-il un moyen de faire ça?

Merci d'avance.

androidgoogle-mapsdriving-directionsgoogle-direction
11
Emil Adz

essayez cette solution ici
vous pouvez conduire ou marcher sur V2

8
Akexorcist

La superposition est vraiment quelque chose à oublier.

Les polylignes peuvent facilement être dessinées

https://developers.google.com/maps/documentation/Android/lines#add_a_polyline

Parcourez vos points après avoir analysé la réponse JSON:

PolylineOptions rectOptions = new PolylineOptions()
        .add(new LatLng(37.35, -122.0))
        .add(new LatLng(37.45, -122.0))  // North of the previous point, but at the same longitude
        .add(new LatLng(37.45, -122.2))  // Same latitude, and 30km to the west
        .add(new LatLng(37.35, -122.2))  // Same longitude, and 16km to the south
        .add(new LatLng(37.35, -122.0)); // Closes the polyline.

// Set the rectangle's color to red
rectOptions.color(Color.RED);

// Get back the mutable Polyline
Polyline polyline = myMap.addPolyline(rectOptions);
4
Waza_Be

Le titre de votre question est beaucoup plus général que vos exigences. Je vais donc répondre de manière à en faire bénéficier les lecteurs de cette question et, espérons-le, à répondre à vos exigences d’une manière peut-être différente.

Si vous ne montrez pas les directions dans le contexte d'une carte qui est déjà un fragment chargé et que quelque chose a été fait pour montrer les directions sur la carte (ce qui est probablement similaire à ce que fait le PO), il est plus facile et standard de le faire. avec un Intent.

Cela lance une activité de chemin de la carte (via une application distincte - l'application lancée dépendant des applications compatibles de l'utilisateur, qui est par défaut Google Maps) qui trace le trajet de l'adresse d'origine (String originAddress) à l'adresse de destination .__ (String destinationAddress) par les routes:

// Build the URI query string.
String uriPath = "https://www.google.com/maps/dir/";
// Format parameters according to documentation at:
// https://developers.google.com/maps/documentation/directions/intro
String uriParams = 
    "?api=1" +
    "&Origin=" + originAddress.replace(" ", "+")
        .replace(",", "") +
    "&destination=" + destinationAddress.replace(" ", "+")
        .replace(",", "") +
    "&travelmode=driving";
Uri queryURI = Uri.parse(uriPath + uriParams);
// Open the map.
Intent intent = new Intent(Intent.ACTION_VIEW, queryURI);
startActivity(activity, intent, null);

(Où activity est simplement la Activity actuellement active - obtenue par tout moyen approprié dans le contexte de programmation actuel).

Le code suivant obtient une adresse String à partir d'un objet LatLng (qui doit ensuite être traité pour la requête URI String comme ci-dessus):

/**
* Retrieves an address `String` from a `LatLng` object.
*/
private void getAddressFromLocation(
    final StringBuilder address, final LatLng latlng) {
    // Create the URI query String.
    String uriPath = 
        "https://maps.googleapis.com/maps/api/geocode/json";
    String uriParams = 
        "?latlng=" + String.format("%f,%f",
            latlng.latitude, latlng.longitude) +
        "&key=" + GOOGLE_MAPS_WEB_API_KEY;
    String uriString = uriPath + uriParams;
    // Issue the query using the Volley library for networking.
    RequestFuture<JSONObject> future = RequestFuture.newFuture();
    JSONObject response = null;
    // Required for JsonObjectRequest, but not important here.
    Map<String, String> jsonParams = new HashMap<String, String>();
    JsonObjectRequest request = 
        new JsonObjectRequest(Request.Method.POST, 
            uriString,
            new JSONObject(jsonParams),
            new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    try {
                        if (response != null) {
                            String resultString =
                                response.getJSONArray("results")
                                        .getJSONObject(0)
                                        .getString("formatted_address");
                            // Assumes `address` was empty.
                            address.append(resultString);
                        } // end of if
                        // No response was received.
                    } catch (JSONException e) {
                        // Most likely, an assumption about the JSON 
                        // structure was invalid.
                        e.printStackTrace();
                    }
                } // end of `onResponse()`
            }, // end of `new Response.Listener<JSONObject>()`
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    Log.e(LOG_TAG, "Error occurred ", error);
                }
            });
    // Add the request to the request queue.
    // `VolleyRequestQueue` is a singleton containing
    // an instance of a Volley `RequestQueue`.
    VolleyRequestQueue.getInstance(activity)
        .addToRequestQueue(request);
}

Cette demande est asynchrone, mais elle peut être rendue synchrone . Vous devrez appeler toString() sur le paramètre actuel passé à address pour obtenir originAddress.

1
John Rattz