android - 无法从 LocationListener 获取当前位置

Question

我有一个 LocationService，它启动 MainActivity 的 onResume() 并停止 onDestroy()。

@Override
protected void onResume() {
    super.onResume();
    //Start the service using alaram manager
    //If its not running currently
    if (isLocationServiceRunning(this)) {
        am = (AlarmManager) getSystemService(ALARM_SERVICE);
        Intent intent = new Intent(this, LocationService.class);
        pi = PendingIntent.getService(this, 0, intent,
                PendingIntent.FLAG_UPDATE_CURRENT);
        am.cancel(pi);
        am.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                SystemClock.elapsedRealtime(), 1 * 60 * 1000, pi);
    }
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (isLocationServiceRunning(this)) {
        stopService(new Intent(this, LocationService.class));
        if (am != null && pi != null) {
            am.cancel(pi);
        }
    }
}

LocationService.java

public class LocationService extends Service implements LocationListener {

    public static double curLat = 0.0;
    public static double curLng = 0.0;
    private LocationManager mgr;
    private String best;
    private Location location;
    private Location currentBestLocation;
    private static final int TWO_MINUTES = 1000 * 60 * 2;

    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        mgr = (LocationManager) getSystemService(LOCATION_SERVICE);
        boolean gps_enabled = mgr
                .isProviderEnabled(LocationManager.GPS_PROVIDER);

        if (gps_enabled) {

            // If GPS is enabled, set criteria as ACCURACY_FINE
            // and get the best provider(which usually will be GPS_PROVIDER)
            Criteria criteria = new Criteria();
            criteria.setAccuracy(Criteria.ACCURACY_FINE);

            best = mgr.getBestProvider(criteria, true);
            // getLastKnownLocation so that user don't need to wait
            location = mgr.getLastKnownLocation(best);
            if (location == null) {
                // request for a single update, and try again.
                // Later will request for updates every 10 mins
                mgr.requestSingleUpdate(criteria, this, null);
                location = mgr
                        .getLastKnownLocation(LocationManager.GPS_PROVIDER);
            }
            if (location != null) {
                // If the GPS gives a location, update curLat and curLng
                dumpLocation(location);
            } else {
                // If the location is still null, go for NETWORK_PROVIDER
                best = LocationManager.NETWORK_PROVIDER;
                location = mgr.getLastKnownLocation(best);
                if (location != null) {
                    // If the NETWORK gives a location, update curLat and curLng
                    dumpLocation(location);
                }
            }
            // Register the Location Manager for updates, with both the
            // providers
            // Since GPS updates are expensive, we ask update every 10 mins and
            // unregister updates if GPS is disabled in onProviderDisabled
            // callback
            mgr.requestLocationUpdates(LocationManager.GPS_PROVIDER,
                    10 * 60 * 1000, 50, this);
            // NETWORK_PROVIDER updates every 20 secs
            mgr.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,
                    20 * 1000, 0, this);

            return START_NOT_STICKY;
        } else {
            // If GPS is disables, go with NETWORK_PROVIDER
            best = LocationManager.NETWORK_PROVIDER;
            location = mgr.getLastKnownLocation(best);
            if (location != null) {
                dumpLocation(location);
            }
            // Register NETWORK_PROVIDER for updates every 20 secs
            mgr.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,
                    20 * 1000, 0, this);
            return START_NOT_STICKY;
        }
    }

    private void dumpLocation(Location l) {
        // Called to update the curLat and curLng.
        currentBestLocation = l;
        SimpleDateFormat s = new SimpleDateFormat("dd/MM/yyyy:hh:mm:ss",
                Locale.ENGLISH);
        String format = s.format(l.getTime());
        try {
            Geocoder coder = new Geocoder(this);
            List<Address> address;
            Address location = null;
            address = coder.getFromLocation(l.getLatitude(), l.getLongitude(),
                    1);
            location = address.get(0);
        } catch (Exception e) {
            Log.e("Exception while getting address", e.getMessage() + "");
        }
        curLat = l.getLatitude();
        curLng = l.getLongitude();
    }

    @Override
    public void onLocationChanged(Location location) {
        // called when location is changed, since we registered Location
        // Providers
        // for updates
        if (isBetterLocation(location, currentBestLocation)) {
            dumpLocation(location);
        } else {
            Log.d("Not a Better Location", "Ignore");
        }
    }

    @Override
    public void onProviderDisabled(String provider) {
        // Check if best(the currently being used provider) is not null
        if (best != null) {
            // if best and disabled provider are same, the remove updates
            if ((provider.equalsIgnoreCase(LocationManager.GPS_PROVIDER) && best
                    .equals(LocationManager.GPS_PROVIDER))
                    || provider
                            .equalsIgnoreCase(LocationManager.NETWORK_PROVIDER)
                    && best.equals(LocationManager.NETWORK_PROVIDER)) {
                if (mgr != null) {
                    mgr.removeUpdates(this);
                }
            }
        }
    }

    @Override
    public void onProviderEnabled(String provider) {
        // This will be taken care in the onStartCommand where if gps_enabled
        // case is used.
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
        // No need to care about, because any thing like OUT_OF_SERVICE occurs,
        // location being fetched will be null and such cases are handled above.
        if ((provider.equals(LocationManager.GPS_PROVIDER))
                && (LocationProvider.OUT_OF_SERVICE == status)) {
            if (mgr != null) {
                mgr.removeUpdates(this);
            }
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // triggered when we call stopService(LocationService);
        // which is done in onDestroy of MainActivity
        // Because LocationService must be stopped
        // when application is closed to avoid data usage
        if (mgr != null) {
            mgr.removeUpdates(this);
        }
    }

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

        // Not significantly newer or older, so check for Accuracy
        if (isMoreAccurate) {
            // If more accurate return true
            return true;
        } else if (isNewer && !isLessAccurate) {
            // Same accuracy but newer, return true
            return true;
        } else if (isNewer && !isSignificantlyLessAccurate
                && isFromSameProvider) {
            // Accuracy is less (not much though) but is new, so if from same
            // provider return true
            return true;
        }
        return false;
    }

    // Checks whether two providers are the same
    private boolean isSameProvider(String provider1, String provider2) {
        if (provider1 == null) {
            return provider2 == null;
        }
        return provider1.equals(provider2);
    }
}

服务确实按预期启动和停止，我可以在日志中看到位置详细信息，这很好。

问题是当我移动到一个完全不同的位置(300 英里)时，当我打开申请。

是不是因为我在设备运动时没有运行服务(因为我的应用程序没有运行)？

因为当我打开 FourSquare 等其他应用程序(获取正确的位置)然后重新打开我的应用程序时，它会显示正确的位置。

我还应该做些什么才能正确刷新位置。

Answer 1

我认为你的问题出在这里

best = mgr.getBestProvider(criteria, true);
// getLastKnownLocation so that user don't need to wait
location = mgr.getLastKnownLocation(best);
if (location == null) {
     // request for a single update, and try again.
     // Later will request for updates every 10 mins
     mgr.requestSingleUpdate(criteria, this, null);
     location = mgr
             .getLastKnownLocation(LocationManager.GPS_PROVIDER);
 }

因为之前有一个位置 location = mgr.getLastKnownLocation(best); 返回那个位置没有启动提供者(参见 the android documentation 。所以位置不是null 和 mgr.requestSingleUpdate(criteria, this, null); 永远不会运行。

要获取最新的位置数据，必须启动提供程序。

所以更正可能是:

best = mgr.getBestProvider(criteria, true);
// getLastKnownLocation so that user don't need to wait
mgr.requestSingleUpdate(best, this, null);
location = mgr.getLastKnownLocation(best);

此外，我不确定它是否有意，但即使 GPS 数据可用且更准确(由于为 GPS 更新和数据过时选择了 10 分钟和 2 分钟时间)，此服务仍将使用网络提供商。

附言您是否有特定原因不想使用作为 Google Play 服务一部分的 FusedLocationProvider？我发现它更简单，并且据说针对选定的最佳供应商进行了优化并节省了电量。