Trazar una ruta de un punto a otro en Google maps y Android

Trazar una ruta de un punto a otro en Google maps y Android

Hoy vamos a ver como trazar una ruta de un punto a otro en un mapa de Google Maps pero implementado para aplicaciones moviles con Android, el resultado de esta implementacion es el que se mira en la imagen del post.. Teniendo nuestro mapa de google ya implementado simplemente obtendremos ambos puntos, tanto el destino como el origen y pintaremos la ruta para llegar desde el punto A hasta el punto B.

Como mencionamos anteriormente este post no cubre como crear una aplicacion android o incrustar el mapa, unicamente abordaremos el codigo necesario para obtener el punto A y el punto B hasta donde queremos llegar, la forma de mandar a Google estos puntos para obtener un conjunto de puntos para dibujar una poligono.

Para comenzar:

            LatLng destino = new LatLng(Double.parseDouble(coordenadasx),Double.parseDouble(coordenadasy));

            MarkerOptions marcadorDestino= new MarkerOptions();
            marcadorDestino.position(destino);
            marcadorDestino.title("Este es tu destino");
            marcadorDestino.icon(BitmapDescriptorFactory.fromBitmap(resizeMapIcons("ic_marcador_destino",80,80)));
            mGoogleMap.addMarker(marcadorDestino);

            String url = obtenerDireccionesURL(origen.getPosition(), destino);
            DownloadTask downloadTask = new DownloadTask();
            downloadTask.execute(url);

donde mGoogleMap es nuestro mapa ya implemantado, establecemos nuestro destino y origen (en el codigo para el origen obtenemos la posicion de un marcador llamado origen que refleja la posicion actual del usuario ) y finalmente mandamos llamar el metodo obtenerDireccionesURL que menciono a continuación y mandamos ejecutar una tarea de descarga en segundo plano.

El metodo obtenerDireccionesURL es el  siguiente:

    private String obtenerDireccionesURL(LatLng origin,LatLng dest){

        String str_origin = "origin="+origin.latitude+","+origin.longitude;

        String str_dest = "destination="+dest.latitude+","+dest.longitude;

        String sensor = "sensor=false";

        String parameters = str_origin+"&"+str_dest+"&"+sensor;

        String output = "json";

        String url = "https://maps.googleapis.com/maps/api/directions/"+output+"?"+parameters;

        return url;
    }

En este metodo lo que hacemos es construir la url que mandaremos al web service de google maps para obtener una serie de puntos con la ruta a seguir, o pintar en este caso.


¿Sabías que?

¿Necesitas aprender algo nuevo ? Ve a Udemy, busca el tema del que quieres aprender, selecciona el curso para ti y continua con tu aprendizaje.

Udemy

Recordando que esta ruta que obtenemos con el metodo obtenerDireccionesURL lo mandamos a una tarea de descarga en segundo plano, esta tarea de descarga es como sigue:

private class DownloadTask extends AsyncTask<String, Void, String>{

        @Override
        protected String doInBackground(String... url) {

            String data = "";

            try{
                data = downloadUrl(url[0]);
            }catch(Exception e){
                Log.d("ERROR AL OBTENER INFO DEL WS",e.toString());
            }
            return data;
        }

        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);

            ParserTask parserTask = new ParserTask();

            parserTask.execute(result);
        }
    }

Aqui lo que hacemos es conectar con el web service y obtener el resultado, que cabe recalcar lo solicitamos en formato JSON, despues mandamos llamar una tarea asincrona para interpretar el resultado, mismo que le pasamos como parametro.

El codigo para ParserTask es el siguiente:

private class ParserTask extends AsyncTask<String, Integer, List<List<HashMap<String,String>>> >{

        @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]);
                DirectionsJSONParser parser = new DirectionsJSONParser();

                routes = parser.parse(jObject);
            }catch(Exception e){
                e.printStackTrace();
            }
            return routes;
        }

        @Override
        protected void onPostExecute(List<List<HashMap<String, String>>> result) {
            ArrayList<LatLng> points = null;
            PolylineOptions lineOptions = null;
            MarkerOptions markerOptions = new MarkerOptions();

            for(int i=0;i<result.size();i++){
                points = new ArrayList<LatLng>();
                lineOptions = new PolylineOptions();

                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(4);
                lineOptions.color(Color.rgb(0,0,255));
            }
            if(lineOptions!=null) {
                mGoogleMap.addPolyline(lineOptions);
            }
        }
    }

El codigo de la clase DirectionsJSONParser es el siguiente:
public class DirectionsJSONParser {

    public List<List<HashMap<String,String>>> parse(JSONObject jObject){

        List<List<HashMap<String, String>>> routes = new ArrayList<List<HashMap<String,String>>>() ;
        JSONArray jRoutes = null;
        JSONArray jLegs = null;
        JSONArray jSteps = null;

        try {

            jRoutes = jObject.getJSONArray("routes");

            for(int i=0;i<jRoutes.length();i++){
                jLegs = ( (JSONObject)jRoutes.get(i)).getJSONArray("legs");
                List path = new ArrayList<HashMap<String, String>>();

                for(int j=0;j<jLegs.length();j++){
                    jSteps = ( (JSONObject)jLegs.get(j)).getJSONArray("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);

                        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);
                        }
                    }
                    routes.add(path);
                }
            }

        } catch (JSONException e) {
            e.printStackTrace();
        }catch (Exception e){
        }

        return routes;
    }

    private List<LatLng> decodePoly(String encoded) {

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

 

Por ultimo lo que hacemos aqui es interpretar el resultado del web service de Google Maps al que le mandamos nuestros puntos, crear los puntos que conforman la ruta desde el punto A hasta el punto B, darles un ancho y un color para para al final agregarlo todo al mapa como una poyline.

Actualización:

Me olvide agregar la definicion del metodo fdf, la dejo a continuación:

private String downloadUrl(String strUrl) throws IOException {
        String data = "";
        InputStream iStream = null;
        HttpURLConnection urlConnection = null;
        try{
            URL url = new URL(strUrl);

            // Creamos una conexion http
            urlConnection = (HttpURLConnection) url.openConnection();

            // Conectamos
            urlConnection.connect();

            // Leemos desde URL
            iStream = urlConnection.getInputStream();

            BufferedReader br = new BufferedReader(new InputStreamReader(iStream));

            StringBuffer sb = new StringBuffer();

            String line = "";
            while( ( line = br.readLine()) != null){
                sb.append(line);
            }

            data = sb.toString();

            br.close();

        }catch(Exception e){
            Log.d("Exception", e.toString());
        }finally{
            iStream.close();
            urlConnection.disconnect();
        }
        return data;
    }

Para más informacion del web service de Google maps.

Cualquier duda o comentario puedes dejarme un comentario y con gusto te ayudaré a resolverla.

Saludos!

 

Clic para valorar esta información
[Total: 0 Promedio: 0]