Android GoogleMap show route to cover all locations?

Question

I marked 10 locations using Google Maps addMarker() and is that possible to show route for reach all locations, the shortest route to cover all locations. If we click on one location it shows a route to reach there but I need connected route not only for one at a time.

Answer 1

You can use Google Maps Directions API with up to 23 waypoints (excluding the origin and destination) (its enough for your 10 marker places) with optimize:true (from Official Docs Optimize your waypoints section):

you may pass optimize:true as the first argument within the waypoints parameter to allow the Directions service to optimize the provided route by rearranging the waypoints in a more efficient order.

Something like that request:

https://maps.googleapis.com/maps/api/directions/json?origin=kilimanoor,in&destination=delhi,in&waypoints=optimize:true|via:12.972614,77.619728|via:17.381196,78.491409|via:21.150758,79.090297&key=YOUR_API_KEY

And than you should parse JSON response and, for example, draw route polyline based on it (you need data from overview_polyline tag for that). You can use code like this:

  private String buildDirectionsUrl(List<LatLng> trackPoints) {

    if (trackPoints.size() < 2) {
        return null;
    }

    final LatLng origin = trackPoints.get(0);
    final LatLng dest = trackPoints.get(trackPoints.size() - 1);

    StringBuilder url = new StringBuilder();
    url.append("https://maps.googleapis.com/maps/api/directions/json?");
    url.append(String.format("origin=%8.5f,%8.5f", origin.latitude, origin.longitude));
    url.append(String.format("&destination=%8.5f,%8.5f", dest.latitude, dest.longitude));

    // add waypoints, if they exists
    if (trackPoints.size() > 2) {
        url.append("&waypoints=optimize:true|");
        LatLng wayPoint;
        for (int ixWaypoint = 1; ixWaypoint < trackPoints.size() - 2; ixWaypoint++) {
            wayPoint = trackPoints.get(ixWaypoint);
            url.append(String.format("%8.5f,%8.5f|", wayPoint.latitude, wayPoint.longitude));
        }
        url.delete(url.length() - 1, url.length());
    }

    url.append(String.format("&key=%s", getResources().getString(R.string.google_maps_key)));

    return url.toString();
}


private class GetDirectionPointsAsyncTask extends AsyncTask<List<LatLng>, Void, List<LatLng>> {

    protected void onPreExecute() {
        super.onPreExecute();
    }

    protected List<LatLng> doInBackground(List<LatLng>... params) {

        List<LatLng> routePoints = new ArrayList<>();

        HttpURLConnection connection = null;
        BufferedReader reader = null;

        try {
            URL url = new URL(buildDirectionsUrl(params[0]));
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.connect();

            int responseCode = connection.getResponseCode();
            InputStream stream = connection.getInputStream();

            reader = new BufferedReader(new InputStreamReader(stream));
            StringBuilder jsonStringBuilder = new StringBuilder();

            StringBuffer buffer = new StringBuffer();
            String line = "";

            while ((line = reader.readLine()) != null) {
                buffer.append(line+"\n");
                jsonStringBuilder.append(line);
                jsonStringBuilder.append("\n");
            }

            JSONObject jsonRoot = new JSONObject(jsonStringBuilder.toString());
            JSONArray jsonRoutes = jsonRoot.getJSONArray("routes");

            if (jsonRoutes.length() < 1) {
                return null;
            }

            JSONObject jsonRoute = jsonRoutes.getJSONObject(0);
            JSONObject overviewPolyline = jsonRoute.getJSONObject("overview_polyline");
            String overviewPolylineEncodedPoints = overviewPolyline.getString("points");
            routePoints = decodePoly(overviewPolylineEncodedPoints);

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (JSONException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return routePoints;
    }

    @Override
    protected void onPostExecute(List<LatLng> result) {
        super.onPostExecute(result);

        PolylineOptions polyLineOptions = new PolylineOptions();
        polyLineOptions.addAll(result);
        polyLineOptions.width(5);
        polyLineOptions.color(Color.RED);
        mGoogleMap.addPolyline(polyLineOptions);

        LatLngBounds.Builder builder = new LatLngBounds.Builder();
        builder.include(result.get(0));
        builder.include(result.get(result.size()-1));
        LatLngBounds bounds = builder.build();
        mGoogleMap.animateCamera(CameraUpdateFactory.newLatLngBounds(bounds, 10));

    }
}

//
// Method to decode polyline points
// Courtesy : http://jeffreysambells.com/2010/05/27/decoding-polylines-from-google-maps-direction-api-with-java
private List<LatLng> decodePoly(String encoded) {

    List<LatLng> poly = new ArrayList<>();
    int index = 0, len = encoded.length();
    int lat = 0, lng = 0;

    while (index < len) {
        int b, shift = 0, result = 0;
        do {
            b = encoded.charAt(index++) - 63;
            result |= (b & 0x1f) << shift;
            shift += 5;
        } while (b >= 0x20);
        int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
        lat += dlat;

        shift = 0;
        result = 0;
        do {
            b = encoded.charAt(index++) - 63;
            result |= (b & 0x1f) << shift;
            shift += 5;
        } while (b >= 0x20);
        int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
        lng += dlng;

        LatLng p = new LatLng((((double) lat / 1E5)),
                (((double) lng / 1E5)));
        poly.add(p);
    }

    return poly;
}

Also see this tutorial.