android - How to get more accuracy by GPS_PROVIDER

Question

I've a challenges task for getting very high accuracy. So I am using GPS_PROVIDER. But my code is getting incorrect accuracy. some time it shows me 10 to 50 meter from my current location. and some time it shows me 5 to 15 meter distance from my current location. I've tested it two devices as XOLO and Sony. I've completed involved with that problems and not able to fix it. This is my code:-

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

    if(mMap!= null)
        mMaprivate LatLng geo;
map.clear();

    locationManager = (LocationManager)this.getSystemService(Context.LOCATION_SERVICE);             
    mFragment = (SupportMapFragment) this.getSupportFragmentManager().findFragmentById(R.id.map);
    mMap = mFragment.getMap(); 
    }
   setListener();
 }

private void setListener() {    
    System.out.println("setListener()  locationListener = "+locationListener);
    if(locationListener != null){
        clearListener();
    }

    Toast toast = Toast.makeText(this, this.getResources().getString(R.string.maps_loading), Toast.LENGTH_LONG);
    toast.show();   
    private LatLng geo;

    locationListener = new CustomLocationListener();

    Criteria criteria = new Criteria();
    criteria.setAccuracy(Criteria.ACCURACY_FINE);
    //criteria.setAccuracy(Criteria.ACCURACY_HIGH);
    criteria.setPowerRequirement(Criteria.NO_REQUIREMENT);
    String bestProvider = locationManager.getBestProvider(criteria, true); 
    Toast.makeText(this, "bestProvider= "+bestProvider, Toast.LENGTH_SHORT).show();
//  locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
   locationManager.requestLocationUpdates(bestProvider, 0, 0, locationListener);

    handler=new Handler();
    timeoutTask = new TimeoutTask(locationListener);
    handler.postDelayed(timeoutTask, 50*1000);
}

private void clearListener(){
    if(locationListener != null){
        locationManager.removeUpdates(locationListener);
        locationListener = null;
    }
}

private void gotLocation(Location location){
    loc = location;
    System.out.println("getLocation = "+location.getLatitude());
 //   Toast.makeText(getBaseContext(), "new Lat = "+location.getLatitude(), Toast.LENGTH_LONG).show();
}

public class CustomLocationListener implements LocationListener {
    private boolean isCompleted = false;

    public CustomLocationListener() {}

    @Override
    public void onLocationChanged(Location location) {
        isCompleted=true;

        System.out.println("onLocationChanged 1");

          // Called when a new location is found by the GPS location provider.
          if(isBetterLocation(location, loc)){
            //  Toast.makeText(getBaseContext(), "yes", Toast.LENGTH_LONG).show();
              System.out.println("onLocationChanged 2");
              gotLocation(location);
          }
          System.out.println("onLocationChanged 3");
          clearListener();
          setUserPoint();
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) { }

    @Override
    public void onProviderEnabled(String provider) { }

    @Override
    public void onProviderDisabled(String provider) { }

    public boolean isCompleted() {
        return isCompleted;
    }private LatLng geo;

}   
private LatLng geo;

 public class TimeoutTask implements Runnable {

    private CustomLocationListener listener;

    public TimeoutTask(CustomLocationListener listener) {
        this.listener=listener;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (listener == null || listener.isCompleted()) {
            Log.e("provider", "completed");
       }
        else {
            Toast.makeText(ScorecardMapViewActivity.this, "We were unable to find your position, please try again", Toast.LENGTH_LONG).show();
            Log.e("provider", "timeout");
            clearListener();
            setUserPoint();
            if(goToScorecardStep3WithLocation) finish(); 
        }
    }
}



protected boolean isBetterLocation(Location location, Location currentBestLocation) {
    if (currentBestLocation == null) {
        // A new location is always better than no location
        return true;
    }

    // Check whether the new location fix is newer or older
    long timeDelta = location.getTime() - currentBestLocation.getTime();
    boolean isSignificantlyNewer = timeDelta > TWO_MINUTES;
    boolean isSignificantlyOlder = timeDelta < -TWO_MINUTES;
    boolean isNewer = timeDelta > 0;

    // If it's been more than two minutes since the current location, use the new location
    // because the user has likely moved
    if (isSignificantlyNewer) {
        return true;
    // If the new location is more than two minutes older, it must be worse
    } else if (isSignificantlyOlder) {
        return false;
    }

    // Check whether the new location fix is more or less accurate
    int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
    boolean isLessAccurate = accuracyDelta > 0;
    boolean isMoreAccurate = accuracyDelta < 0;
    boolean isSignificantlyLessAccurate = accuracyDelta > 200;

    // Check if the old and new location are from the same provider
    boolean isFromSameProvider = isSameProvider(location.getProvider(),
            currentBestLocation.getProvider());

    // Determine location quality using a combination of timeliness and accuracy
    if (isMoreAccurate) {
        return true;
    } else if (isNewer && !isLessAccurate) {
        return true;
    } else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
        return true;
    }
    return false;
}

private LatLng geo;

private void setUserPoint() {
    if(!goToScorecardStep3WithLocation) {
    if(loc != null) {

         if(handler != null) { System.out.println("removed timeout task from handler");
            handler.removeCallbacks(timeoutTask); }

        geo = HelperUtil.getLatLng(loc);
        mMap.animateCamera(CameraUpdateFactory.newLatLngZoom(geo, 18));
        mMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);

        System.out.println("loc.getLatitude() = "+loc.getLatitude());
        System.out.println("loc.getLongitude() = "+loc.getLongitude());

        // your current position show.
         mMap.addMarker(new MarkerOptions().title("Player").position(geo)
        .icon(BitmapDescriptorFactory.fromResource(R.drawable.map_point)));
}
}
}

Please any one expert help me. your help will be very helpful. Thank you!

updated:-

I noted if I am at same place. Sometime I am getting Long decimal points and sometime small decimal points. is there make any effect to calculate distance due to decimal points also? I am calculating distance in Yard.

current location = Lat 28.65361000000004 Long = 77.4122733333333

previous Current Location points ( this is same place but lat/long is different)

Lat = 28.653685000000003 Long = 77.4123083333334

I got 8 yard distance. I think some problem may be due to long or small digits points. is there way so that we can get only long decimal points?

Answer 1

Consumer GPS receivers have an acuracy of 2.5-6m in 95% of cases, you cannot improve that for moving devices.

If you stand still (by user interaction that tells start of standstill, and end-of-standstill), you can calculate the average position.
Especially when standing still GPS chips have a bit less acuracy because the doppler shift can only be used while moving.

To caluclate the accuracy of your device you should take some measures, caluclate the average position, and calculate for each measure the distance to that average position. This then should give a value between 3-6m.

You wrote, that you expect 0m distance between two location while standing still.
But this does not work with GPS. Due fluctating conditions in the troposphere, the signal delay slightly vary, causing jumping position while standing still.

You only get 0m if you have enabled a stand still filter, which iOS uses by default. There should also a possibility in Android to enable such a filter (E.g by setting distance threshold to a value higher than 0).