Android 安卓谷歌地图查找之间的距离

我成功地创建了谷歌地图。我可以检查我的位置，我还编写了代码，可以在谷歌地图中添加点（触摸监听器），并在起始位置和点之间画一条线。现在我想检查一下距离。我不知道我怎么能做到这一点 我在谷歌上搜索了一个例子，但是这个代码不能正常工作？我总是有一个距离 这是我的代码，如果有人知道解决方案，请帮助我 谢谢

公共类GPS扩展活动工具
OnMyLocationChangeListener，OnMapClickListener{
最终int RQS_GooglePlayServices=1；
私人谷歌地图；
圈我的圈；
TextView tvLocInfo，GPSLocation；
LatLng LatLng；
布尔标记单击；
ArrayList markerPoints；
双震级、震级、经纬度、经度；
公共按钮gpssize；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
requestWindowFeature（窗口。功能\u无\u标题）；
setContentView（R.layout.gps）；
markerPoints=newarraylist（）；
gpssize=（按钮）findViewById（R.id.gpssize）；
tvLocInfo=（TextView）findViewById（R.id.GpsTxt）；
GPSLocation=（TextView）findViewById（R.id.GPSLocation）；
FragmentManager myFragmentManager=getFragmentManager（）；
MapFragment myMapFragment=（MapFragment）myFragmentManager
.findFragmentById（R.id.GpsMap）；
myMap=myMapFragment.getMap（）；
myMap.getUiSettings（）.setZoomControlsEnabled（true）；
myMap.getUiSettings（）.setCompassEnabled（true）；
myMap.getUiSettings（）.setMyLocationButtonEnabled（true）；
myMap.setMyLocationEnabled（true）；
setOnMyLocationChangeListener（this）；
setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图v）{
双倍距离；
位置A=新位置（“”）；
地点a.设置纬度（纬度）；
地点a.经度（震级）；
位置B=新位置（“”）；
位置b.设置纬度（端纬度）；
位置b.设置经度（经度终点）；
距离=位置A。距离（位置B）/1000；
Toast.makeText（getApplicationContext（），“”+距离，
Toast.LENGTH_LONG）.show（）；
}
});
myMap.setOnMapClickListener（这个）；
myMap.setTrafficEnabled（true）；
markerClicked=false；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
int resultCode=GooglePlayServicesUtil
.isGooglePlayServicesAvailable（getApplicationContext（））；
if（resultCode==ConnectionResult.SUCCESS）{
Toast.makeText（getApplicationContext（），
“iGoogle PlayServicesAvailable SUCCESS”，祝酒词。长度（长）
.show（）；
}否则{
GooglePlayServicesUtil.getErrorDialog（结果代码，此，
RQS_谷歌游戏服务）；
}
}
@凌驾
公共void onMyLocationChange（位置）{
startatitude=location.getLatitude（）；
startongitence=location.getLongitude（）；
latLng=新latLng（惊跳度、惊跳度）；
myMap.moveCamera（CameraUpdateFactory.newLatLng（latLng））；
GPSLocation.setText（startatitude+“”+startongitude）；
//myMap.setMapType（GoogleMap.MAP\u TYPE\u NORMAL）；
LatLng LOCLATLING=新LatLng（location.getLatitude（），
location.getLongitude（））；
双精度=位置。getAccurance（）；
如果（myCircle==null）{
CircleOptions CircleOptions=新CircleOptions（）.center（Localng）
.半径（精度）
.fillColor（颜色。红色）。strokeColor（颜色。黑色）。strokeWidth（5）；
myCircle=myMap.addCircle（circleOptions）；
}否则{
myCircle.setCenter（locLatLng）；
myCircle.setRadius（精度）；
}
myMap.animateCamera（CameraUpdateFactory.zoomTo（15））；
}
私有字符串getDirectionsUrl（LatLng来源，LatLng目的地）{
String str_origin=“origin=“+startatitude+”，“+startongite；
字符串str_dest=“destination=“+dest.latitude+”，“+dest.longitude；
字符串sensor=“sensor=false”；
字符串参数=str_origin+“&”+str_dest+“&”+传感器；
字符串输出=“json”；
字符串url=”https://maps.googleapis.com/maps/api/directions/"
+输出+“？”+参数；
返回url；
}
/**从url下载json数据的方法*/
私有字符串下载URL（字符串strUrl）引发IOException{
字符串数据=”；
InputStream iStream=null；
HttpURLConnection-urlConnection=null；
试一试{
URL=新URL（strUrl）；
urlConnection=（HttpURLConnection）url.openConnection（）；
urlConnection.connect（）；
iStream=urlConnection.getInputStream（）；
BufferedReader br=新的BufferedReader（新的InputStreamReader(
峡流）；
StringBuffer sb=新的StringBuffer（）；
字符串行=”；
而（（line=br.readLine（））！=null）{
某人附加（行）；
}
data=sb.toString（）；
br.close（）；
}捕获（例外e）{
Log.d（“下载url时出现异常”，例如toString（））；
}最后{
iStream.close（）；
urlConnection.disconnect（）；
}
返回数据；
}
私有类DownloadTask扩展了AsyncTask{
@凌驾
受保护的字符串doInBackground（字符串…url）{
字符串数据=”；
试一试{
数据=下载url（url[0]）；
}捕获（例外e）{
Log.d（“后台任务”，例如toString（））；
}
返回数据；
}
@凌驾
受保护的void onPostExecute（字符串结果）{
super.onPostExecute（结果）；
ParserTask ParserTask=新的ParserTask（）；
执行（结果）；
}
}
私有类ParserTask扩展
异步任务{
@凌驾
受保护列表背景(
字符串…jsonData）{
JSONObject jObject；
列表路由=空；
试一试{
jObject=新的JSONObject（jsonData[0]）；
方向JSONParser
public class GPS extends Activity implements
    OnMyLocationChangeListener, OnMapClickListener {
final int RQS_GooglePlayServices = 1;
private GoogleMap myMap;
Circle myCircle;
TextView tvLocInfo, GPSLocation;
LatLng latLng;
boolean markerClicked;
ArrayList<LatLng> markerPoints;
double Startlatitude, Startlongitude, Endlatitude, Endlongitude;

public Button gpssize;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.gps);
    markerPoints = new ArrayList<LatLng>();

    gpssize = (Button) findViewById(R.id.gpssize);

    tvLocInfo = (TextView) findViewById(R.id.GpsTxt);
    GPSLocation = (TextView) findViewById(R.id.GPSLocation);
    FragmentManager myFragmentManager = getFragmentManager();
    MapFragment myMapFragment = (MapFragment) myFragmentManager
            .findFragmentById(R.id.GpsMap);
    myMap = myMapFragment.getMap();
    myMap.getUiSettings().setZoomControlsEnabled(true);
    myMap.getUiSettings().setCompassEnabled(true);
    myMap.getUiSettings().setMyLocationButtonEnabled(true);

    myMap.setMyLocationEnabled(true);
    myMap.setOnMyLocationChangeListener(this);

    gpssize.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {
            double distance;

            Location locationA = new Location("");

            locationA.setLatitude(Startlatitude);

            locationA.setLongitude(Startlongitude);

            Location locationB = new Location("");

            locationB.setLatitude(Endlatitude);

            locationB.setLongitude(Endlongitude);

            distance = locationA.distanceTo(locationB) / 1000;

            Toast.makeText(getApplicationContext(), "" + distance,
                    Toast.LENGTH_LONG).show();

        }
    });

    myMap.setOnMapClickListener(this);

    myMap.setTrafficEnabled(true);

    markerClicked = false;

}

@Override
protected void onResume() {

    super.onResume();

    int resultCode = GooglePlayServicesUtil
            .isGooglePlayServicesAvailable(getApplicationContext());

    if (resultCode == ConnectionResult.SUCCESS) {
        Toast.makeText(getApplicationContext(),
                "isGooglePlayServicesAvailable SUCCESS", Toast.LENGTH_LONG)
                .show();
    } else {
        GooglePlayServicesUtil.getErrorDialog(resultCode, this,
                RQS_GooglePlayServices);
    }

}

@Override
public void onMyLocationChange(Location location) {

    Startlatitude = location.getLatitude();

    Startlongitude = location.getLongitude();

    latLng = new LatLng(Startlatitude, Startlongitude);

    myMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));

    GPSLocation.setText(Startlatitude + " " + Startlongitude);
    // myMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);

    LatLng locLatLng = new LatLng(location.getLatitude(),
            location.getLongitude());
    double accuracy = location.getAccuracy();

    if (myCircle == null) {
        CircleOptions circleOptions = new CircleOptions().center(locLatLng)

        .radius(accuracy)

        .fillColor(Color.RED).strokeColor(Color.BLACK).strokeWidth(5);

        myCircle = myMap.addCircle(circleOptions);
    } else {
        myCircle.setCenter(locLatLng);
        myCircle.setRadius(accuracy);
    }
    myMap.animateCamera(CameraUpdateFactory.zoomTo(15));

}

private String getDirectionsUrl(LatLng origin, LatLng dest) {

    String str_origin = "origin=" + Startlatitude + "," + Startlongitude;

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

/** A method to download json data from url */
private String downloadUrl(String strUrl) throws IOException {
    String data = "";
    InputStream iStream = null;
    HttpURLConnection urlConnection = null;
    try {
        URL url = new URL(strUrl);

        urlConnection = (HttpURLConnection) url.openConnection();

        urlConnection.connect();

        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 while downloading url", e.toString());
    } finally {
        iStream.close();
        urlConnection.disconnect();
    }
    return data;
}

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("Background Task", e.toString());
        }
        return data;
    }

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

        ParserTask parserTask = new ParserTask();

        parserTask.execute(result);

    }
}

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"));
                tvLocInfo.setText(lat + " " + lng);

                LatLng position = new LatLng(lat, lng);
                points.add(position);
            }

            lineOptions.addAll(points);
            lineOptions.width(7);
            lineOptions.geodesic(true);

            lineOptions.color(getResources().getColor(R.color.mapColor));

        }

        myMap.addPolyline(lineOptions);
    }
}

@Override
public void onMapClick(LatLng point) {
    if (markerPoints.size() > 0) {
        markerPoints.clear();
        myMap.clear();
    }

    markerPoints.add(point);

    MarkerOptions options = new MarkerOptions();

    options.position(point);

    if (markerPoints.size() == 1) {
        options.icon(BitmapDescriptorFactory
                .defaultMarker(BitmapDescriptorFactory.HUE_GREEN));
    }

    myMap.addMarker(options);

    if (markerPoints.size() >= 1) {

        LatLng dest = markerPoints.get(0);
        LatLng origin = new LatLng(Endlatitude, Endlongitude);

        String url = getDirectionsUrl(origin, dest);

        DownloadTask downloadTask = new DownloadTask();

        downloadTask.execute(url);
    }

}

float[] distances = new float[1];
Location.distanceBetween(locationA.latitude, locationA.longitude,
                locationB.latitude, locationB.longitude,
                distances);

System.out.println("Distance: " + distances[0]);