Develop Reference

How to draw more than one route, between origin and destination, googlemaps api?

I have a code to draw a route for the user. But, I would like it to be drawn, the alternative routes, too. I changed the URL by passing the parameter alternatives=true and also the source code to bring the other routes. But, it's just being drawn, just one route.
I made these changes, based on the questions and answers, also here on the page.
Code:
Map, receive the polylines and draw to user:
if (rota != null) {
map.addPolyline(ApplicationUtils.getApplicationUtils().getPolylineOptions());
//Adicionando ponto inicial
CircleOptions circle = new CircleOptions().center(ultimaLocation);
circle.fillColor(Color.DKGRAY);
circle.radius(15); // Em metros
map.addCircle(circle);
}
Calculate route:
public void calculateRoute(LatLng origin, LatLng dest, String mode, RotaListener rotaListener) {
this.rotaListener = rotaListener;
try {
// Getting URL to the Google Directions API
String url = getDirectionsUrl(origem, destino, modo);
Log.d(TAG, "URL DIRECTIONS = " + url);
DownloadTask downloadTask = new DownloadTask();
// Start downloading json data from Google Directions API
downloadTask.execute(url);
} catch (Exception e) {
rotaListener.onFailure(e);
}
}
private String getDirectionsUrl(LatLng origin, LatLng dest, String mode) {
// Origin of route
String str_origin = "origin=" + origin.latitude + "," + origin.longitude;
// Destination of route
String str_dest = "destination=" + dest.latitude + "," + dest.longitude;
// Sensor enabled
String sensor = "sensor=false";
String str_mode = "mode=" + mode;
// Building the parameters to the web service
String parameters = str_origin + "&" + str_dest + "&" + sensor + "&" + str_mode +"&alternatives=true" ;
// Output format
String output = "json";
// Building the url to the web service
String url = "https://maps.googleapis.com/maps/api/directions/" + output + "?" + parameters + "&key=" + MY_API_KEY;
;
return url;
}
/**
* A class to download data from Google Directions URL
*/
private class DownloadTask extends AsyncTask<String, Void, String> {
// Downloading data in non-ui thread
#Override
protected String doInBackground(String... url) {
try {
// For storing data from web service
String data = "";
try {
// Fetching the data from web service
data = downloadUrl(url[0]);
} catch (Exception e) {
Log.d("Background Task", e.toString());
}
return data;
} catch (Exception e) {
rotaListener.onFailure(e);
return "";
}
}
// Executes in UI thread, after the execution of
// doInBackground()
#Override
protected void onPostExecute(String result) {
try {
super.onPostExecute(result);
ParserTask parserTask = new ParserTask();
// Invokes the thread for parsing the JSON data
if (rotaListener != null) {
rotaListener.onRotaChanged(result);
parserTask.execute(result);
}
} catch (Exception e) {
rotaListener.onFailure(e);
}
}
}
/**
* A class to parse the Google Directions in JSON format
*/
private class ParserTask extends AsyncTask<String, Integer, PolylineOptions> {
// Parsing the data in non-ui thread
#Override
protected PolylineOptions doInBackground(String... jsonData) {
try {
JSONObject jObject;
List<Rota> routes = null;
try {
jObject = new JSONObject(jsonData[0]);
DirectionsJSONParser parser = new DirectionsJSONParser();
// Starts parsing data
routes = parser.parse(jObject);
} catch (Exception e) {
e.printStackTrace();
}
ArrayList<LatLng> points = null;
PolylineOptions lineOptions = null;
// Traversing through all the routes
for (int i = 0; i < routes.size(); i++) {
points = new ArrayList<LatLng>();
lineOptions = new PolylineOptions();
// Fetching i-th route
List<HashMap<String, String>> path = routes.get(i).Pontos;
rotaListener.onTempoRotaChanged(routes.get(i).TempoEstimadoMin);
// Fetching all the points in i-th route
for (int j = 0; j < path.size(); j++) {
HashMap<String, String> point = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
// Adding all the points in the route to LineOptions
lineOptions.addAll(points);
lineOptions.width(LARGURA_ROTA);
lineOptions.color(COR_ROTA);
lineOptions.geodesic(true);
ApplicationUtils.getApplicationUtils().setPolylineOptions(lineOptions);
}
return lineOptions;
} catch (Exception e) {
rotaListener.onFailure(e);
return null;
}
}
// Executes in UI thread, after the parsing process
#Override
protected void onPostExecute(PolylineOptions result) {
// Drawing polyline in the Google Map for the i-th route
try {
if (rotaListener != null) {
rotaListener.onInstrucoesRotaChanged(result);
rotaListener = null;
}
} catch (Exception e) {
rotaListener.onFailure(e);
}
}
}
public class DirectionsJSONParser {
/**
* Receives a JSONObject and returns a list of lists containing latitude and longitude
*/
public List<Rota> parse(JSONObject jObject) {
List<Rota> routes = new ArrayList<Rota>();
JSONArray jRoutes = null;
JSONArray jLegs = null;
JSONArray jSteps = null;
JSONObject jDuration = null;
Rota rota;
try {
jRoutes = jObject.getJSONArray("routes");
/** Traversing all routes */
for (int i = 0; i < jRoutes.length(); i++) {
jLegs = ((JSONObject) jRoutes.get(i)).getJSONArray("legs");
List path = new ArrayList<HashMap<String, String>>();
/** Traversing all legs */
for (int j = 0; j < jLegs.length(); j++) {
jSteps = ((JSONObject) jLegs.get(j)).getJSONArray("steps");
rota = new Rota();
jDuration = ((JSONObject) jLegs.get(j)).getJSONObject("duration");
if (jDuration != null) {
rota.TempoEstimadoMin = jDuration.getInt("value") / 60;
}
/** Traversing all steps */
for (int k = 0; k < jSteps.length(); k++) {
String polyline = "";
polyline = (String) ((JSONObject) ((JSONObject) jSteps.get(k)).get("polyline")).get("points");
List<LatLng> list = decodePoly(polyline);
/** Traversing all points */
for (int l = 0; l < list.size(); l++) {
HashMap<String, String> hm = new HashMap<String, String>();
hm.put("lat", Double.toString(((LatLng) list.get(l)).latitude));
hm.put("lng", Double.toString(((LatLng) list.get(l)).longitude));
path.add(hm);
}
}
rota.Pontos = path;
routes.add(rota);
}
}
} catch (JSONException e) {
e.printStackTrace();
} catch (Exception e) {
}
return routes;
}
If possible, I would like some help so that I can draw more than one route for the user.
Thank you!

I think you should be doing this inside of the doInBackground task:
for (int i = 0; i < routes.size(); i++) {
...
// Adding all the points in the route to LineOptions
lineOptions.addAll(points);
lineOptions.width(LARGURA_ROTA);
// Change the color with every new iteration of the route
lineOptions.color(COR_ROTA);
lineOptions.geodesic(true);
ApplicationUtils.getApplicationUtils().setPolylineOptions(lineOptions)
map.addPolyline(ApplicationUtils.getApplicationUtils().getPolylineOptions());
lineOptions = null;
}
We're using slightly different libraries, but this is what my code looks like (encoded path is a string representing a group of lat/lons):
pathDynamic = new PolylineOptions().width(15).color(Color.RED);
pathDynamic.addAll(decode(item.getEncodedPath()));
if (mMap != null) {
mMap.addPolyline(pathDynamic);
}

I resolved by changing my parser class.
Adding points in each iteration of FOR to specific variables
private class ParserTask1 extends AsyncTask<String, Integer, List<List<List<HashMap<String, String>>>>> {
// Parsing the data in non-ui thread
#Override
protected List<List<List<HashMap<String, String>>>> doInBackground(String... jsonData) {
JSONObject jObject;
List<List<List<HashMap<String, String>>>> routes = null;
try {
jObject = new JSONObject(jsonData[0]);
DirectionsJSONParser1 parser = new DirectionsJSONParser1();
// Starts parsing data
routes = parser.parse(jObject);
} catch (Exception e) {
e.printStackTrace();
}
return routes;
}
// Executes in UI thread, after the parsing process
#Override
protected void onPostExecute(List<List<List<HashMap<String, String>>>> result) {
ArrayList<LatLng> points = null;
PolylineOptions lineOptions = new PolylineOptions();
PolylineOptions lineOptions1 = null;
List<LatLng> aline1 = new ArrayList<LatLng>();
List<LatLng> aline2 = new ArrayList<LatLng>();
List<LatLng> aline3 = new ArrayList<LatLng>();
Rota rota = new Rota();
List<HashMap<String, String>> rotaNumero = new ArrayList<>();
HashMap<String, String> pointNumber = null;
if (result != null) {
int i = 0;
Log.d(SHETTY, "onPostExecute: result size " + result.size());
while (i < result.size()) {
// for(int i=0;i<result.size();i++){
//result.size()
//int g= i-1;
points = new ArrayList<LatLng>();
// lineOptions = new PolylineOptions();
// if(i==1){
// }else{
List<List<HashMap<String, String>>> path1 = result.get(i);
for (int s = 0; s < path1.size(); s++) {
Log.d("pathsize1", path1.size() + "");
// Fetching i-th route
List<HashMap<String, String>> path = path1.get(s);
Log.d("pathsize", path.size() + "");
// Fetching all the points in i-th route
for (int j = 0; j < path.size(); j++) {
lineOptions1 = new PolylineOptions();
HashMap<String, String> point = path.get(j);
pointNumber = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
// Log.d("latlng", position.toString());
points.add(position);
}
}
if (i == 0) {
rotaNumero.add(pointNumber);
ApplicationUtils.getApplicationUtils().setPoints(rotaNumero);
aline1.addAll(points);
ApplicationUtils.getApplicationUtils().setAline1(aline1);
rotaNumero.clear();
} else if (i == 1) {
rotaNumero.add(pointNumber);
ApplicationUtils.getApplicationUtils().setPoints2(rotaNumero);
aline2.addAll(points);
ApplicationUtils.getApplicationUtils().setAline2(aline2);
rotaNumero.clear();
} else if (i == 2) {
rotaNumero.add(pointNumber);
ApplicationUtils.getApplicationUtils().setPoints2(rotaNumero);
aline3.addAll(points);
ApplicationUtils.getApplicationUtils().setAline3(aline3);
rotaNumero.clear();
}
// Adding all the points in the route to LineOptions
i++;
}
try {
if (rotaListener != null) {
rotaListener.onInstrucoesRotaChanged(lineOptions.addAll(ApplicationUtils.getApplicationUtils().getAline1()));
rotaListener = null;
}
} catch (Exception e) {
rotaListener.onFailure(e);
}
}
}
}
After inserting the points, in my class where I have the map, I draw the routes.
private void drawRoutes() {
line1 = new PolylineOptions().width(10).color(baseActivity.getResources().getColor(R.color.btn_map_inserir_pressed));
line2 = new PolylineOptions().width(10).color(baseActivity.getResources().getColor(R.color.verde_novo));
line3 = new PolylineOptions().width(10).color(baseActivity.getResources().getColor(R.color.azul));
line1.addAll(ApplicationUtils.getApplicationUtils().getAline1());
map.addPolyline(line1);
if (ApplicationUtils.getApplicationUtils().getAline2() != null) {
line2.addAll(ApplicationUtils.getApplicationUtils().getAline2());
map.addPolyline(line2);
}
if (ApplicationUtils.getApplicationUtils().getAline3() != null) {
line3.addAll(ApplicationUtils.getApplicationUtils().getAline3());
map.addPolyline(line3);
}
}

Remove previous route and add new one

I have a application containing a map activity which has plenty of markers from my SQLite database and a polyline connecting those markers.
The problem begins when I want to show a route between any clicked marker and my Location.
Problem is it works fine and shows the route for the first time but if any other marker is clicked, a new route is generated without removing previous route.
I know the problem is the following code.
#Override
protected void onPostExecute(List<List<HashMap<String, String>>> result) {
ArrayList<LatLng> points = new ArrayList<>();
PolylineOptions lineOptions = new PolylineOptions();
for(int i=0;i<result.size();i++){
List<HashMap<String, String>> path = result.get(i);
for(int j=0;j<path.size();j++){
HashMap<String,String> point = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
lineOptions.addAll(points);
lineOptions.width(5);
lineOptions.color(Color.WHITE);
}
// googleMap.clear();
//setMarkersPolyLines();
googleMap.addPolyline(lineOptions);
}
My efforts till now:
Googled it and found a way using polyline.remove(); but the problem is if placed after addPolyline then newly created route is also removed and if placed before that then error comes saying polyline might not be initialised.
Tried with if else as
if(flag==0){
polyline = googleMap.addPolyline(lineOptions);
flag++;
}
else if(flag>0)
polyline.remove();
polyline = googleMap.addPolyline(lineOptions);
}
but nothing happened.
Tried these steps but it causes a glitch/fluctuation kind of thing and also some delay.
googleMap.clear();
setMarkersPolyLines(); //setting all my markers again
googleMap.addPolyline(lineOptions);
Atlast, tried initialising points and lineoptions in the for loop but again might not be initialised error and can't set to null as giving nullPointerException as PolylineOptions can't be set to null.
I tried many posts but nothing really was working. Thanks.

I've modified Josef Adamcik's answer and it should work.
boolean isSecond = false;
private Polyline lastPolyline;
#Override
protected void onPostExecute(List<List<HashMap<String, String>>> result) {
ArrayList<LatLng> points = new ArrayList<>();
PolylineOptions lineOptions = new PolylineOptions();
for(int i=0;i<result.size();i++){
List<HashMap<String, String>> path = result.get(i);
for(int j=0;j<path.size();j++){
HashMap<String,String> point = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
lineOptions.addAll(points);
lineOptions.width(5);
lineOptions.color(Color.WHITE);
}
if(isSecond) {
lastPolyline.remove();
lastPolyline = googleMap.addPolyline(lineOptions);
}
else
{
lastPolyline = googleMap.addPolyline(lineOptions);
isSecond=true;
}
}

You should keep a reference to a polyline created in last rendering. This reference should be a field of your class. You should call remove before add but only when lastPolyline is not null.
private Polyline lastPolyline;
#Override
protected void onPostExecute(List<List<HashMap<String, String>>> result) {
ArrayList<LatLng> points = new ArrayList<>();
PolylineOptions lineOptions = new PolylineOptions();
for(int i=0;i<result.size();i++){
List<HashMap<String, String>> path = result.get(i);
for(int j=0;j<path.size();j++){
HashMap<String,String> point = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
lineOptions.addAll(points);
lineOptions.width(5);
lineOptions.color(Color.WHITE);
}
// googleMap.clear();
//setMarkersPolyLines();
if (lastPolyline != null) {
lastPolyline.remove();
}
lastPolyline = googleMap.addPolyline(lineOptions);
}

How to prevent Polyline from overlapping in google maps android?

Hello guys this may be dumb question but am struggling with this so far haven't found any solution. Now let me ask my doubt am using multiple polyline for plotting multiple routes each and every polyline has different colors but when two point intersects last polyline get overridden how to prevent it. How it must look is only first route should get one color and all the other routes must have same color how to do this let me post the code what i have tried so far:
public class GetDistance extends AsyncTask<Double, Void, String> {
private ProgressDialog pd;
private static final int READ_TIMEOUT = 6000;
private static final int CONNECTION_TIMEOUT = 6000;
private int flag;
public GetDistance(int flag) {
this.flag=flag;
}
#Override
protected void onPreExecute() {
super.onPreExecute();
pd = new ProgressDialog(VisitTravel.this);
pd.setMessage("Please wait");
pd.show();
}
#Override
protected String doInBackground(Double... strings) {
URL url;
try {
url = new URL("http://maps.googleapis.com/maps/api/directions/json?origin=" + strings[0] + "," + strings[1] + "&destination=" + strings[2] + "," + strings[3] + "&sensor=false&units=metric&mode=driving&alternatives=true");
HttpURLConnection conn;
conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(READ_TIMEOUT);
conn.setConnectTimeout(CONNECTION_TIMEOUT);
conn.setRequestMethod("POST");
InputStream in;
in = new BufferedInputStream(conn.getInputStream());
StringBuilder buffer = new StringBuilder();
BufferedReader reader;
reader = new BufferedReader(new InputStreamReader(in));
String inputLine;
while ((inputLine = reader.readLine()) != null)
buffer.append(inputLine).append("\n");
if (buffer.length() == 0) {
// Stream was empty. No point in parsing.
Log.e("empty", "empty");
}
JsonResponse = buffer.toString();
Log.d("response", JsonResponse);
} catch (IOException e1) {
e1.printStackTrace();
}
return JsonResponse;
}
#Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
pd.dismiss();
if(flag==1) {
new ParserTask().execute(result);
}}
}
private class ParserTask extends AsyncTask<String, Integer, List<List<HashMap<String, String>>>> {
private ArrayList<LatLng> points;
#Override
protected List<List<HashMap<String, String>>> doInBackground(String... jsonData) {
JSONObject jObject;
List<List<HashMap<String, String>>> routes = null;
try {
jObject = new JSONObject(jsonData[0]);
DirectionJSONParser parser = new DirectionJSONParser();
// Starts parsing data
routes = parser.parse(jObject);
} catch (Exception e) {
e.printStackTrace();
}
return routes;
}
#Override
protected void onPostExecute(List<List<HashMap<String, String>>> result) {
PolylineOptions polylineOptionss=null;
// MarkerOptions markerOptions = new MarkerOptions();
// Traversing through all the routes
for (int i = 0; i < result.size(); i++) {
points = new ArrayList<>();
// Fetching i-th route
List<HashMap<String, String>> path = result.get(i);
// Fetching all the points in i-th route
for (int j = 0; j < path.size(); j++) {
HashMap<String, String> point = path.get(j);
if (j == 0) {
duration = point.get("duration");
Log.d("duration", duration);
continue;
}
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
polylineOptionss=new PolylineOptions();
// Adding all the points in the route to LineOptions
polylineOptionss.addAll(points);
// polylineOptions.width(7);
// Random rnd = new Random();
// int color = Color.argb(255, rnd.nextInt(256), rnd.nextInt(256), rnd.nextInt(256));
if(i==0) {
polylineOptions0=new PolylineOptions();
polylineOptions0.addAll(points);
// mGoogleMap.setTrafficEnabled(true);
polylineOptions0.width(15);
polylineOptions0.color(Color.parseColor("#9c27b0"));
polylineOptions0.geodesic(true);
Polyline polyline= mGoogleMap.addPolyline(polylineOptions0);
polyline.setTag(duration);
polyline.setClickable(true);
}
//Here only differentiating each and every route.
else if(i==1){
polylineOptions1=new PolylineOptions();
polylineOptions1.addAll(points);
polylineOptions1.geodesic(true);
polylineOptions1.width(15);
// mGoogleMap.setTrafficEnabled(true);
polylineOptions1.color(Color.parseColor("#9e9e9e"));
Polyline polyline= mGoogleMap.addPolyline(polylineOptions1);
polyline.setTag(duration);
polyline.setClickable(true);
///
}
else if(i==2){
polylineOptions2=new PolylineOptions();
polylineOptions2.addAll(points);
polylineOptions2.geodesic(true);
polylineOptions2.width(15);
polylineOptions2.color(Color.parseColor("#9c27b0"));
Polyline polyline= mGoogleMap.addPolyline(polylineOptions2);
polyline.setTag(duration);
polyline.setClickable(true);
// mGoogleMap.setTrafficEnabled(true);
//
}
else {
polylineOptions3=new PolylineOptions();
polylineOptions3.addAll(points);
// mGoogleMap.setTrafficEnabled(true);
polylineOptions3.width(15);
polylineOptions3.geodesic(true);
polylineOptions3.color(Color.parseColor("#9e9e9e"));
Polyline polyline= mGoogleMap.addPolyline(polylineOptions3);
polyline.setTag(duration);
polyline.setClickable(true);
/// polylineOptions3.color(Color.parseColor("#ffffff"));
}
}
setBottomSheet(jsonresponse, edt.getText().toString(),1);
CameraAnimation(polylineOptionss);
// mGoogleMap.addPolyline(polylineOptions);
// Drawing polyline in the Google Map for the i-th route
}
}
How to plot first route with one color from starting to end and then remaining routes with other color. Thanks in advance !!

Use Z-Index variable of Polyline and Use Polylineclick listener to change the z-index of the polylines. Means whenever you click any line, its z-index will be increased and other lines z-index will be decreased so that the line you clicked will always override others. See the attached code for help.
Z-Index
The order in which this tile overlay is drawn with respect to other overlays (including GroundOverlays, TileOverlays, Circles, and Polygons but not Markers). An overlay with a larger z-index is drawn over overlays with smaller z-indices. The order of overlays with the same z-index is arbitrary. The default zIndex is 0.
final List<Polyline> polylines = new ArrayList<>();
for(int i= 0; i<paths.size(); i++ ){
polylines.add(mMap.addPolyline(paths.get(i)));
}
mMap.setOnPolylineClickListener(new GoogleMap.OnPolylineClickListener() {
#Override
public void onPolylineClick(Polyline polyline) {
for(int i= 0; i<polylines.size(); i++ ){
polylines.get(i).setColor(Color.argb(255,187,189,191));
polylines.get(i).setZIndex(0);
}
polyline.setColor(Color.argb(255,102,157,246));
polyline.setZIndex(2);
}
});

One possible solution might be to vary the strokeWidth of the overlapping section of the polyline so that the first one drawn is wider and therefore can still be seen under the subsequent ones. Just an idea, not tested.

update value of holder textview in AsyncTask

I'm using google direction API to get the duration between my location and nearby places and it's working. But, I face problem in setting the duration value where the value is in onPostExecute.I tried to make duration global but it does not work. By the way, my textview is in ViewHolder class.
public class ParserTask extends AsyncTask<String, Integer, List<List<HashMap<String,String>>> >{
String distance = "";
String duration = "";
// Parsing the data in non-ui thread
#Override
public List<List<HashMap<String, String>>> doInBackground(String... jsonData) {
JSONObject jObject;
List<List<HashMap<String, String>>> routes = null;
try{
jObject = new JSONObject(jsonData[0]);
DirectionsJSONParser parser = new DirectionsJSONParser();
// Starts parsing data
routes = parser.parse(jObject);
}catch(Exception e){
e.printStackTrace();
}
return routes;
}
// Executes in UI thread, after the parsing process
#Override
public void onPostExecute(List<List<HashMap<String, String>>> result) {
/*ArrayList<LatLng> points = null;
PolylineOptions lineOptions = null;
MarkerOptions markerOptions = new MarkerOptions();*/
if(result.size()<1){
Toast.makeText(context, "No Points", Toast.LENGTH_SHORT).show();
return;
}
// Traversing through all the routes
for(int i=0;i<result.size();i++){
// Fetching i-th route
List<HashMap<String, String>> path = result.get(i);
// Fetching all the points in i-th route
for(int j=0;j<path.size();j++){
HashMap<String,String> point = path.get(j);
if(j==0){ // Get distance from the list
distance = (String)point.get("distance");
continue;
}else if(j==1){ // Get duration from the list
duration = (String)point.get("duration");
continue;
}
}
}
//holder.val.setText("value"+duration);
Toast.makeText(context,"Duration:"+duration ,Toast.LENGTH_LONG).show();
}

Android ProgressDialog stops spinning before the task is completed

I am using progress dialog in my Asynctask class on onpreExecte() method, and dismissing the dialog in onPostExecute while google makes the routes of the map. My problem is the wheel in dialog is stopping after 2-3 seconds but my background process is still working.
private class ParserTask extends
AsyncTask<String, Integer, List<List<HashMap<String, String>>>> {
#Override
protected void onPreExecute() {
dialog = new ProgressDialog(MapaViagem.this);
// setup your dialog here
dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
dialog.setTitle("Traçando Rotas");
dialog.setMessage("Aguarde...");
dialog.setCancelable(false);
dialog.show();
}
#Override
protected List<List<HashMap<String, String>>> doInBackground(
String... jsonData) {
JSONObject jObject;
List<List<HashMap<String, String>>> routes = null;
try {
jObject = new JSONObject(jsonData[0]);
PathJSONParser parser = new PathJSONParser();
routes = parser.parse(jObject);
} catch (Exception e) {
e.printStackTrace();
}
return routes;
}
#Override
protected void onPostExecute(List<List<HashMap<String, String>>> routes) {
ArrayList<LatLng> points = null;
PolylineOptions polyLineOptions = null;
// traversing through routes
for (int i = 0; i < routes.size(); i++) {
points = new ArrayList<LatLng>();
polyLineOptions = new PolylineOptions();
List<HashMap<String, String>> path = routes.get(i);
for (int j = 0; j < path.size(); j++) {
HashMap<String, String> point = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
polyLineOptions.addAll(points);
polyLineOptions.width(4);
polyLineOptions.color(Color.BLUE);
}
googleMap.addPolyline(polyLineOptions);
if (dialog.isShowing()) {
dialog.dismiss();
}
}
}

You must put all the "procesing" code inside the doInBackground, that means all the code you have inside the onPostExcecute. Only the things that modify the UI should be in the onPostExcecute (like for example show a message to the user, change text of a TextView, etc.), else you will get your UI stucked.
I had the same problem and resolved it this way.
Hope it helps