Java Google Maps API和标记之间的自定义多段线路由

我想为android应用程序定制一条路径，我不确定应该使用哪种API以及它是否与Java兼容

据我所知，我需要使用航路点来确定路线（我不需要知道两点之间的距离，只需要确定路线）

其目的是从地图侧面的菜单中选择一个选项，并显示两个标记之间的自定义路线之一。

您可以使用，和

对于谷歌地图API的入门，已经有很多其他的好答案了。有关简单地图活动的完整工作示例。请注意，您还需要设置一个API密钥来处理您的项目

至于使用GoogleMapsDirections Web服务API，您应该首先阅读文档。您可以使用API密钥并在开发人员控制台中启用API，但它目前仍然可以在不使用API密钥的情况下工作

以下是使用Google Maps API在两点之间绘制多段线所需的基本代码，请注意，API返回的点编码为需要解码的base 64编码字符串

首先，确保您的项目包含Google Maps实用程序库，该库将用于解码base64编码的多段线：

dependencies {
    compile 'com.google.maps.android:android-maps-utils:0.5+'
    //.......
}

这是AsyncTask，在调用它时，您应该给它两个LatLng点

您可以使用两个LatLng对象调用AsyncTask，例如在两个标记之间：

new GetDirectionsAsync().execute(markerOne.getPosition(), markerTwo.getPosition());

以下是异步任务代码：

class GetDirectionsAsync extends AsyncTask<LatLng, Void, List<LatLng>> {

    JSONParser jsonParser;
    String DIRECTIONS_URL = "https://maps.googleapis.com/maps/api/directions/json";


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

    @Override
    protected List<LatLng> doInBackground(LatLng... params) {
        LatLng start = params[0];
        LatLng end = params[1];

        HashMap<String, String> points = new HashMap<>();
        points.put("origin", start.latitude + "," + start.longitude);
        points.put("destination", end.latitude + "," + end.longitude);

        jsonParser = new JSONParser();

        JSONObject obj = jsonParser.makeHttpRequest(DIRECTIONS_URL, "GET", points, true);

        if (obj == null) return null;

        try {
            List<LatLng> list = null;

            JSONArray routeArray = obj.getJSONArray("routes");
            JSONObject routes = routeArray.getJSONObject(0);
            JSONObject overviewPolylines = routes.getJSONObject("overview_polyline");
            String encodedString = overviewPolylines.getString("points");
            list = PolyUtil.decode(encodedString);

            return list;

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

        return null;
    }

    @Override
    protected void onPostExecute(List<LatLng> pointsList) {

        if (pointsList == null) return;

        if (line != null){
            line.remove();
        }

        PolylineOptions options = new PolylineOptions().width(5).color(Color.MAGENTA).geodesic(true);
        for (int i = 0; i < pointsList.size(); i++) {
            LatLng point = pointsList.get(i);
            options.add(point);
        }
        line = mMap.addPolyline(options);

    }
}

下面是本例中使用的JSONParser类，请注意，这是一个为android-23更新的修改版本，我：

公共类JSONParser{
字符串charset=“UTF-8”；
httpurl连接连接；
数据输出流；
结果；
URL-urlObj；
JSONObject jObj=null；
字符串生成器sbParams；
字符串参数字符串；
公共JSONObject makeHttpRequest（字符串url、字符串方法、，
HashMap参数，布尔编码）{
sbParams=新的StringBuilder（）；
int i=0；
for（字符串键：params.keySet（））{
试一试{
如果（i！=0）{
sbParams.append（“&”）；
}
如果（编码）{
sbParams.append（键）.append（“”）
.append（URLEncoder.encode（params.get（key），charset））；
}
否则{
sbParams.append（键）.append（“”）
.append（参数get（键））；
}
}捕获（不支持的编码异常e）{
e、 printStackTrace（）；
}
i++；
}
if（方法等于（“POST”））{
//请求方法为POST
试一试{
urlObj=新URL（URL）；
conn=（HttpURLConnection）urlObj.openConnection（）；
连接设置输出（真）；
conn.setRequestMethod（“POST”）；
conn.setRequestProperty（“接受字符集”，字符集）；
连接设置读取超时（10000）；
连接设置连接超时（15000）；
连接（）；
paramsString=sbParams.toString（）；
wr=新的DataOutputStream（conn.getOutputStream（））；
writeBytes（paramsString）；
wr.flush（）；
wr.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
else if（method.equals（“GET”））{
//请求方法是GET
如果（sbParams.length（）！=0）{
url+=“？”+sbParams.toString（）；
}
d（“JSONParser”，“完整获取url:+url”）；
试一试{
urlObj=新URL（URL）；
conn=（HttpURLConnection）urlObj.openConnection（）；
连接设置输出（假）；
conn.setRequestMethod（“GET”）；
conn.setRequestProperty（“接受字符集”，字符集）；
连接设置连接超时（15000）；
连接（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
试一试{
//从服务器接收响应
InputStream in=新的BufferedInputStream（conn.getInputStream（））；
BufferedReader reader=新的BufferedReader（新的InputStreamReader（in））；
弦线；
结果=新的StringBuilder（）；
而（（line=reader.readLine（））！=null）{
结果。追加（行）；
}
Log.d（“JSON解析器”，“结果：+result.toString（））；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
连接断开（）；
//尝试将字符串解析为JSON对象
试一试{
jObj=新的JSONObject（result.toString（））；
}捕获（JSONException e）{
Log.e（“JSON解析器”，“错误解析数据”+e.toString（））；
}
//返回JSON对象
返回jObj；
}
}

在两个标记之间绘制管线的结果：

new GetDirectionsAsync().execute(markerOne.getPosition(), markerTwo.getPosition());

---

如何添加第三个标记并继续路由到第三个标记？@AndrewJeromeBernard您只需添加第三个标记，然后绘制路由：

new GetDirectionAsync（）.execute（markerTwo.getPosition（），markertThree.getPosition（））
public class JSONParser {

    String charset = "UTF-8";
    HttpURLConnection conn;
    DataOutputStream wr;
    StringBuilder result;
    URL urlObj;
    JSONObject jObj = null;
    StringBuilder sbParams;
    String paramsString;

    public JSONObject makeHttpRequest(String url, String method,
                                      HashMap<String, String> params, boolean encode) {

        sbParams = new StringBuilder();
        int i = 0;
        for (String key : params.keySet()) {
            try {
                if (i != 0){
                    sbParams.append("&");
                }
                if (encode) {
                    sbParams.append(key).append("=")
                            .append(URLEncoder.encode(params.get(key), charset));
                }
                else{
                    sbParams.append(key).append("=")
                            .append(params.get(key));
                }

            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            i++;
        }

        if (method.equals("POST")) {
            // request method is POST
            try {
                urlObj = new URL(url);

                conn = (HttpURLConnection) urlObj.openConnection();

                conn.setDoOutput(true);

                conn.setRequestMethod("POST");

                conn.setRequestProperty("Accept-Charset", charset);

                conn.setReadTimeout(10000);
                conn.setConnectTimeout(15000);

                conn.connect();

                paramsString = sbParams.toString();

                wr = new DataOutputStream(conn.getOutputStream());
                wr.writeBytes(paramsString);
                wr.flush();
                wr.close();

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        else if(method.equals("GET")){
            // request method is GET

            if (sbParams.length() != 0) {
                url += "?" + sbParams.toString();
            }

            Log.d("JSONParser", "full GET url: " + url);

            try {
                urlObj = new URL(url);

                conn = (HttpURLConnection) urlObj.openConnection();

                conn.setDoOutput(false);

                conn.setRequestMethod("GET");

                conn.setRequestProperty("Accept-Charset", charset);

                conn.setConnectTimeout(15000);

                conn.connect();

            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        try {
            //Receive the response from the server
            InputStream in = new BufferedInputStream(conn.getInputStream());
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));

            String line;
            result = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }

            Log.d("JSON Parser", "result: " + result.toString());

        } catch (IOException e) {
            e.printStackTrace();
        }

        conn.disconnect();

        // try parse the string to a JSON object
        try {
            jObj = new JSONObject(result.toString());
        } catch (JSONException e) {
            Log.e("JSON Parser", "Error parsing data " + e.toString());
        }

        // return JSON Object
        return jObj;
    }
}