android - Google Maps API Version difference

Question

I'm trying to show route between two places, I want to used Google Places API V3 for route steps between two points.

---

Before I was using Old Google Maps API, and following request gives perfect result:

http://maps.google.com/maps?f=d&hl=en&saddr=19.5217608,-99.2615823&daddr=19.531224,-99.248262&ie=UTF8&0&om=0&output=kml

Output :

---

Now I try to replace this with New Google Maps API, and following request gives wrong result, In both case i'm using same source and destination, but result gives different behavior on Google Map:

http://maps.googleapis.com/maps/api/directions/json?origin=19.5217608,-99.2615823&destination=19.531224,-99.248262&sensor=false

My problem is that, New Google Maps API return less number of steps between source and destination therefore the route not showing perfect on Google Map.

Please help to resolve this problem for New Google Maps API v3.

Thanks in advance.

Answer 1

I've taken your request URL and pasted it in my app, which is using the newer version, and it works great. The problem may be how you parse the data, or decode the received JSON string.

String url = "http://maps.googleapis.com/maps/api/directions/json?origin=19.5217608,-99.2615823&destination=19.531224,-99.248262&sensor=false";

HttpPost httppost = new HttpPost(url);
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
InputStream is = null;
is = entity.getContent();
BufferedReader reader = new BufferedReader(new InputStreamReader(is, "iso-8859-1"), 8);
StringBuilder sb = new StringBuilder();
sb.append(reader.readLine() + "
");
String line = "0";
while ((line = reader.readLine()) != null) {
    sb.append(line + "
");
}
is.close();
reader.close();
String result = sb.toString();
JSONObject jsonObject = new JSONObject(result);
JSONArray routeArray = jsonObject.getJSONArray("routes");
JSONObject routes = routeArray.getJSONObject(0);
JSONObject overviewPolylines = routes.getJSONObject("overview_polyline");
String encodedString = overviewPolylines.getString("points");
List<GeoPoint> pointToDraw = decodePoly(encodedString);

//Added line:
mapView.getOverlays().add(new RoutePathOverlay(pointToDraw));

and the decodePoly() method is taken from another question here in SO, which I don't remember the author:

private List<GeoPoint> decodePoly(String encoded) {

    List<GeoPoint> poly = new ArrayList<GeoPoint>();
    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;

        GeoPoint p = new GeoPoint((int) (((double) lat / 1E5) * 1E6), (int) (((double) lng / 1E5) * 1E6));
        poly.add(p);
    }

    return poly;
}

I'm including what I've used in order to add the overlay to the map itself as well, I can't find the tutorial it's taken from.. sorry for not giving credit. (added the call to this in the first method I posted)

public class RoutePathOverlay extends Overlay {

    private int _pathColor;
    private final List<GeoPoint> _points;
    private boolean _drawStartEnd;

    public RoutePathOverlay(List<GeoPoint> points) {
            this(points, Color.RED, true);
    }

    public RoutePathOverlay(List<GeoPoint> points, int pathColor, boolean drawStartEnd) {
            _points = points;
            _pathColor = pathColor;
            _drawStartEnd = drawStartEnd;
    }


    private void drawOval(Canvas canvas, Paint paint, Point point) {
            Paint ovalPaint = new Paint(paint);
            ovalPaint.setStyle(Paint.Style.FILL_AND_STROKE);
            ovalPaint.setStrokeWidth(2);
            int _radius = 6;
            RectF oval = new RectF(point.x - _radius, point.y - _radius, point.x + _radius, point.y + _radius);
            canvas.drawOval(oval, ovalPaint);               
    }

    public boolean draw(Canvas canvas, MapView mapView, boolean shadow, long when) {
            Projection projection = mapView.getProjection();
            if (shadow == false && _points != null) {
                    Point startPoint = null, endPoint = null;
                    Path path = new Path();
                    //We are creating the path
                    for (int i = 0; i < _points.size(); i++) {
                            GeoPoint gPointA = _points.get(i);
                            Point pointA = new Point();
                            projection.toPixels(gPointA, pointA);
                            if (i == 0) { //This is the start point
                                    startPoint = pointA;
                                    path.moveTo(pointA.x, pointA.y);
                            } else {
                                    if (i == _points.size() - 1)//This is the end point
                                            endPoint = pointA;
                                    path.lineTo(pointA.x, pointA.y);
                            }
                    }

                    Paint paint = new Paint();
                    paint.setAntiAlias(true);
                    paint.setColor(_pathColor);
                    paint.setStyle(Paint.Style.STROKE);
                    paint.setStrokeWidth(5);
                    paint.setAlpha(90);
                    if (getDrawStartEnd()) {
                            if (startPoint != null) {
                                    drawOval(canvas, paint, startPoint);
                            }
                            if (endPoint != null) {
                                    drawOval(canvas, paint, endPoint);
                            }
                    }
                    if (!path.isEmpty())
                            canvas.drawPath(path, paint);
            }
            return super.draw(canvas, mapView, shadow, when);
    }

    public boolean getDrawStartEnd() {
            return _drawStartEnd;
    }

    public void setDrawStartEnd(boolean markStartEnd) {
            _drawStartEnd = markStartEnd;
    }
}

Hope this works for you.