在Android上位置更改时持续更新标记

我正在尝试使用谷歌地图实现一个简单的导航应用程序。最初，我开发了一个代码，用于在地图上标记两个地理点，并显示它们之间的路线。 现在，我尝试根据用户位置将第一个标记移动到第二个标记（目的地）

为此，我使用了

LocationListener

，并在

onLocationChanged

中实现了代码。 问题是

onLocationChanged

没有被触发，并且标记器没有根据用户位置移动。 这是我的密码

MapActivity.java

public class MapActivity extends FragmentActivity implements OnMapClickListener, LocationListener{

private GoogleMap gMap;
private ArrayList<LatLng> markersArray; //Marker points ArrayList
private ArrayList<Marker> markers;
private MarkerOptions options; //Marker options
String distance="";
String duration="";
private TextView travelDetails;
private ProgressDialog pDialog;
private double lattitude=0.0;
private double longitude=0.0;
Marker mMarker;
String bestAvailableProvider;
private LocationManager mLocationManager;


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_map);

    //Loading Google Maps
    try{
        loadMapView();
        markersArray=new ArrayList<LatLng>();
        markers=new ArrayList<Marker>();
        gMap.setOnMapClickListener(this);
        gMap.setMyLocationEnabled(true);
        gMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
        travelDetails=(TextView) findViewById(R.id.lbl_traveldetails);
        pDialog=new ProgressDialog(MapActivity.this);
    }catch(Exception e){
        e.printStackTrace();
    }

}

/*
 * This method loads map
 * 
 */

private void loadMapView(){

    if (gMap==null) {
        gMap=((SupportMapFragment)getSupportFragmentManager()
                .findFragmentById(R.id.map_fragment)).getMap();
    }


    mLocationManager = (LocationManager) getApplicationContext().getSystemService(Context.LOCATION_SERVICE);

    // Specify Location Provider criteria
    Criteria criteria = new Criteria();
    criteria.setAccuracy(Criteria.ACCURACY_FINE);
    criteria.setAltitudeRequired(false);
    criteria.setBearingRequired(false);
    criteria.setCostAllowed(true);
    criteria.setSpeedRequired(false);
    mLocationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,this);


}


/*
 * catches onclick event of map
 * @see com.google.android.gms.maps.GoogleMap.OnMapClickListener#onMapClick(com.google.android.gms.maps.model.LatLng)
 */

@Override
public void onMapClick(LatLng point) {

    //Clearing markers in map


    if (markersArray.size()>1) {
        markersArray.clear();
        gMap.clear();

    }

    //Adding  marker to array
    markersArray.add(point);


    //marking point on Map
    addMarkerOnMap(point);



    //Drawing route when two markers are placed

    if(markersArray.size() >= 2){
        LatLng origin = markersArray.get(0);
        LatLng dest = markersArray.get(1);

        String url = getDirectionsUrl(origin, dest);

        DownloadTask downloadTask = new DownloadTask();

        downloadTask.execute(url);
    }



}

/*
 * This method places markers on map
 */


private void addMarkerOnMap(LatLng point){

    //Marking points on map
    options=new MarkerOptions();
    options.position(point);

    //Setting marker icons

    if (markersArray.size()==1) {

        //Source marker point
        options.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN));


    }else if(markersArray.size()==2){

        //Destination marker point
        options.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_RED));
    }

    //adding marker point to map
    try{
        Marker mMarker=gMap.addMarker(options);

        markers.add(mMarker);
    }catch(Exception e){
        e.printStackTrace();
    }

}


/*
 * Getting direction url between two points
 * 
 */

private String getDirectionsUrl(LatLng origin,LatLng dest){

    // Origin of route
    String str_origin = "origin="+origin.latitude+","+origin.longitude;

    // Destination of route
    String str_dest = "destination="+dest.latitude+","+dest.longitude;

    // Sensor enabled
    String sensor = "sensor=false";

    // Building the parameters to the web service
    String parameters = str_origin+"&"+str_dest+"&"+sensor;

    // Output format
    String output = "json";

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

    return url;
}


/*
 * passing the direction url 
 * 
 */


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


    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        pDialog.show();
        pDialog.setMessage("Loading route...");
        pDialog.setCancelable(false);
    }

    // Downloading data in non-ui thread
    @Override
    protected String doInBackground(String... url) {

        // For storing data from web service
        String data = "";

        try{
            // Fetching the data from web service
            data = downloadUrl(url[0]);
        }catch(Exception e){
            Log.d("Background Task",e.toString());
        }
        return data;
    }

    // Executes in UI thread, after the execution of
    // doInBackground()
    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);

        ParserTask parserTask = new ParserTask();

        // Invokes the thread for parsing the JSON data
        parserTask.execute(result);
    }
}

/*
 * downloading 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();

        // Connecting to url
        urlConnection.connect();

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


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

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

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

            // Starts parsing data
            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();

        // Traversing through all the routes
        for(int i=0;i<result.size();i++){
            points = new ArrayList<LatLng>();
            lineOptions = new PolylineOptions();

            // Fetching i-th route
            List<HashMap<String, String>> path = result.get(i);

            // Fetching all the points in i-th route
            for(int j=0;j<path.size();j++){
                HashMap<String,String> point = path.get(j);


                if(j==0){    // Get distance from the list
                    distance = (String)point.get("distance");
                    continue;
                }else if(j==1){ // Get duration from the list
                    duration = (String)point.get("duration");
                    continue;
                }

                double lat = Double.parseDouble(point.get("lat"));
                double lng = Double.parseDouble(point.get("lng"));
                LatLng position = new LatLng(lat, lng);

                points.add(position);
            }

            // Adding all the points in the route to LineOptions
            lineOptions.addAll(points);
            lineOptions.width(5);
            lineOptions.color(Color.BLUE);
        }

        // Drawing polyline in the Google Map for the i-th route
        try{
            gMap.addPolyline(lineOptions);
            travelDetails.setText("Distance:"+distance+"Duration:"+duration);
            pDialog.dismiss();
        }catch (Exception e) {
            if (pDialog.isShowing()) {
                pDialog.dismiss();
            }
            Toast.makeText(getApplicationContext(), "No Road route found.", Toast.LENGTH_SHORT).show();
            e.printStackTrace();
        }
    }
}





@Override
protected void onResume() {
    super.onResume();

    loadMapView();
}

@Override
protected void onPause() {
    super.onPause();
    mLocationManager.removeUpdates(this);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.map, menu);
    return true;
}

/*
 * (non-Javadoc)
 * @see com.google.android.gms.maps.LocationSource.OnLocationChangedListener#onLocationChanged(android.location.Location)
 */

@Override
public void onLocationChanged(Location location) {
    Log.e("loca", ""+location.getLatitude());

    try {


        if(markersArray.size()>0){

            lattitude=location.getLatitude();
            longitude=location.getLongitude();

            LatLng mLatLng=new LatLng(lattitude, longitude);
            Marker newMarker=markers.get(0);
            newMarker.setPosition(mLatLng);
            gMap.animateCamera(CameraUpdateFactory.newLatLng(mLatLng));
        }

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

}

@Override
public void onProviderDisabled(String provider) {
    // TODO Auto-generated method stub

}

@Override
public void onProviderEnabled(String provider) {
    // TODO Auto-generated method stub
}

@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
    // TODO Auto-generated method stub
}



}

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;
    JSONObject jDistance = null;
    JSONObject jDuration = 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");

                /** Getting distance from the json data */
                jDistance = ((JSONObject) jLegs.get(j)).getJSONObject("distance");
                HashMap<String, String> hmDistance = new HashMap<String, String>();
                hmDistance.put("distance", jDistance.getString("text"));

                /** Getting duration from the json data */
                jDuration = ((JSONObject) jLegs.get(j)).getJSONObject("duration");
                HashMap<String, String> hmDuration = new HashMap<String, String>();
                hmDuration.put("duration", jDuration.getString("text"));

                /** Adding distance object to the path */
                path.add(hmDistance);

                /** Adding duration object to the path */
                path.add(hmDuration);

                /** Getting poly points */
                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);
                    }
                }
                /** Adding poly points */
                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;
}

}

公共类MapActivity扩展了FragmentActivity在MapClickListener、LocationListener上的实现{
私有谷歌地图；
私有ArrayList markersArray；//标记点ArrayList
私有数组列表标记；
私有标记选项；//标记选项
字符串距离=”；
字符串持续时间=”；
私人文本视图travelDetails；
私人对话；
私有双格度=0.0；
私人双经度=0.0；
标记器；
字符串最佳可用提供程序；
私人场所经理；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_map）；
//加载谷歌地图
试一试{
loadMapView（）；
markersArray=newarraylist（）；
markers=newarraylist（）；
gMap.setOnMapClickListener（此）；
gMap.setMyLocationEnabled（真）；
gMap.setMapType（GoogleMap.MAP_-TYPE_卫星）；
travelDetails=（TextView）findViewById（R.id.lbl\u travelDetails）；
pDialog=newprogressdialog（MapActivity.this）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
/*
*此方法加载地图
* 
*/
私有void loadMapView（）{
如果（gMap==null）{
gMap=（（SupportMapFragment）getSupportFragmentManager（）
.findFragmentById（R.id.map_片段））.getMap（）；
}
mLocationManager=（LocationManager）getApplicationContext（）.getSystemService（Context.LOCATION\u服务）；
//指定位置提供程序条件
标准=新标准（）；
标准.设定准确度（标准.准确度/精细度）；
标准。setAltitudeRequired（false）；
标准。需要设置（假）；
条件.setCostAllowed（true）；
标准。设置所需速度（假）；
mlLocationManager.RequestLocationUpdate（LocationManager.GPS_提供程序，0，0，此）；
}
/*
*捕获地图的onclick事件
*@see com.google.android.gms.maps.GoogleMap.onmaclicklistener#onmaclick（com.google.android.gms.maps.model.LatLng）
*/
@凌驾
公共空区（停车点）{
//清除地图上的标记
if（markersArray.size（）>1）{
markersArray.clear（）；
gMap.clear（）；
}
//向数组添加标记
markersArray.add（点）；
//地图上的标记点
addMarkerOnMap（点）；
//放置两个标记时绘制路线
if（markersArray.size（）>=2）{
LatLng origin=markersArray.get（0）；
LatLng dest=markersArray.get（1）；
字符串url=getDirectionsUrl（源、目标）；
DownloadTask DownloadTask=新的DownloadTask（）；
downloadTask.execute（url）；
}
}
/*
*此方法在地图上放置标记
*/
专用void addMarkerOnMap（LatLng点）{
//在地图上标记点
选项=新标记选项（）；
选项。位置（点）；
//设置标记图标
if（markersArray.size（）==1）{
//源标记点
图标（BitmapDescriptorFactory.defaultMarker（BitmapDescriptorFactory.HUE_GREEN））；
}else if（markersArray.size（）==2）{
//目的地标记点
图标（BitmapDescriptorFactory.defaultMarker（BitmapDescriptorFactory.HUE_RED））；
}
//向地图添加标记点
试一试{
Marker mMarker=gMap.addMarker（选项）；
标记。添加（mMarker）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
/*
*获取两点之间的方向url
* 
*/
私有字符串getDirectionsUrl（LatLng来源，LatLng目的地）{
//路线起点
字符串str_origin=“origin=“+origin.latitude+”，“+origin.longitude；
//路线目的地
字符串str_dest=“destination=”+dest.latitude+”，“+dest.longitude；
//传感器启用
字符串sensor=“sensor=false”；
//为web服务构建参数
字符串参数=str_origin+“&”+str_dest+“&”+传感器；
//输出格式
字符串输出=“json”；
字符串url=”https://maps.googleapis.com/maps/api/directions/“+输出+”？“+参数；
返回url；
}
/*
*传递方向url
* 
*/
私有类DownloadTask扩展了AsyncTask{
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
pDialog.show（）；
pDialog.setMessage（“装载路线…”）；
pDialog.setCancelable（假）；
}
//在非ui线程中下载数据
@凌驾
受保护的字符串doInBackground（字符串…url）{
//用于存储来自web服务的数据
字符串数据=”；
试一试{
//从web服务获取数据
数据=下载url（url[0]）；
}捕获（例外e）{
Log.d（“后台任务”，例如toString（））；
}
返回数据；
}
//在UI线程中执行，在
//doInBackground（）
@凌驾
受保护的void onPostExecute（字符串结果）{
super.onPostExecute（结果）；
ParserTask ParserTask=新的ParserTask（）；
//调用线程以解析JSON数据
执行（结果）；
}
}
/*
*从url下载
* 
*/
私有字符串下载URL（字符串strUrl）引发IOException{
字符串数据=”；
InputStream iStream=null；
HttpURLConnection-urlConnection=null；
试一试{
URL=新URL（strUrl）；
urlConnection=（HttpURLConnection）url.openConnection（）；
//连接到url
urlConnection.connect（）；
//从url读取数据
iStream=urlConnection.getInputS