java - Google Maps API 和标记之间的自定义折线路线

Question

我想为 Android 应用程序创建自定义路由，我不确定应该使用哪个 API 以及它是否与 Java 兼容。

据我所知，我需要使用航路点来制定路线(我不需要知道两点之间的距离，只需制定路线即可)。

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

Answer 1

您可以使用 Google Maps API v2 for Android 来执行此操作，以及 Google Maps Directions webservice API

对于 Google Maps API 入门，已经有很多其他很好的答案。 See here有关简单 map Activity 的完整工作示例。请注意，您还需要设置一个 API key 才能与您的项目配合使用。

对于使用 Google Maps Directions Webservice API，您应该首先阅读文档。您可以使用 API key 并在开发者控制台中启用 API，但目前在不使用 API key 的情况下它仍然可以工作。

以下是使用 Google Maps API 在两点之间绘制折线所需的基本代码，请注意，从 API 返回的点以需要解码的 Base 64 编码字符串进行编码。

首先，确保您的项目包含 Google Maps Utility 库，该库将用于解码 Base64 编码的折线:

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

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

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

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

这是 AsyncTask 代码:

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);

    }
}

AsyncTask引用了Activity的一些成员变量，即Polyline和GoogleMap，Activity的定义如下:

public class MapsActivity extends AppCompatActivity implements OnMapReadyCallback{

    GoogleMap mMap;
    Polyline line;
    //.....

这是本示例中使用的 JSONParser 类，请注意，这是针对我 wrote a blog post about 的 android-23 更新的修改版本。 :

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;
    }
}

在两个标记之间绘制路线的结果: