Хороший способ получить местоположение пользователя в Android

проблема:

получение текущего местоположения пользователя в пределах порога как можно скорее и в то же время сохранить батарею.

почему проблема есть проблема:

во-первых, android имеет двух поставщиков; сеть и GPS. Иногда сеть лучше, а иногда и GPS лучше.

под "Лучше" я имею в виду соотношение скорости и точности.

Я готов пожертвовать несколькими метрами точности, если смогу получить местоположение почти мгновенно и без включаю GPS.

во-вторых, если вы запрашиваете обновления для изменения местоположения ничего не отправляется, если текущее местоположение является стабильным.

У Google есть пример определения "лучшего" местоположения здесь: http://developer.android.com/guide/topics/location/obtaining-user-location.html#BestEstimate

Но я думаю, что это не так хорошо, как должно/могло бы быть.

Я немного смущен, почему у google нет нормализованного API для определения местоположения, разработчик не должен заботиться о том, где находится место, вы должны просто указать, что вы хотите, и телефон должен выбрать для вас.

С чем мне нужна помощь:

мне нужно найти хороший способ определить "лучшее" место, возможно, хотя некоторые эвристические или, может быть, через какую-то стороннюю библиотеку.

это не значит определить лучшего поставщика!

Я, вероятно, буду использовать всех поставщиков и выбирать лучшее из них их.

фон приложения:

приложение будет собирать местоположение пользователя с фиксированным интервалом (скажем, каждые 10 минут или около того) и отправлять его на сервер.

Приложение должно сохранить как можно больше батареи, и место должно иметь X (50-100?) метры точности.

цель состоит в том, чтобы позже иметь возможность построить путь пользователя в течение дня на карте, поэтому мне нужна достаточная точность для этого.

разное:

что вы думаете разумные значения по желаемой и принятой точности?

Я использую 100м и 30м, как принято, как хотелось бы, это много, чтобы спросить?

Я хотел бы иметь возможность построить путь пользователя на карте позже.

100м для пожеланного и 500м для принятого лучшего?

кроме того, прямо сейчас у меня есть GPS в течение максимум 60 секунд на обновление местоположения, это слишком коротко, чтобы получить местоположение, если вы находитесь в помещении с точностью, возможно, 200 м?

Это мой текущий код, любая обратная связь ценится (кроме отсутствия проверки ошибок, которая является TODO):

protected void runTask() {

    final LocationManager locationManager = (LocationManager) context

            .getSystemService(Context.LOCATION_SERVICE);

    updateBestLocation(locationManager

            .getLastKnownLocation(LocationManager.GPS_PROVIDER));

    updateBestLocation(locationManager

            .getLastKnownLocation(LocationManager.NETWORK_PROVIDER));

    if (getLocationQuality(bestLocation) != LocationQuality.GOOD) {

        Looper.prepare();

        setLooper(Looper.myLooper());

        // Define a listener that responds to location updates

        LocationListener locationListener = new LocationListener() {



            public void onLocationChanged(Location location) {

                updateBestLocation(location);

                if (getLocationQuality(bestLocation) != LocationQuality.GOOD)

                    return;

                // We're done

                Looper l = getLooper();

                if (l != null) l.quit();

            }



            public void onProviderEnabled(String provider) {}



            public void onProviderDisabled(String provider) {}



            public void onStatusChanged(String provider, int status,

                    Bundle extras) {

                // TODO Auto-generated method stub

                Log.i("LocationCollector", "Fail");

                Looper l = getLooper();

                if (l != null) l.quit();

            }

        };

        // Register the listener with the Location Manager to receive

        // location updates

        locationManager.requestLocationUpdates(

                LocationManager.GPS_PROVIDER, 1000, 1, locationListener,

                Looper.myLooper());

        locationManager.requestLocationUpdates(

                LocationManager.NETWORK_PROVIDER, 1000, 1,

                locationListener, Looper.myLooper());

        Timer t = new Timer();

        t.schedule(new TimerTask() {



            @Override

            public void run() {

                Looper l = getLooper();

                if (l != null) l.quit();

                // Log.i("LocationCollector",

                // "Stopping collector due to timeout");

            }

        }, MAX_POLLING_TIME);

        Looper.loop();

        t.cancel();

        locationManager.removeUpdates(locationListener);

        setLooper(null);

    }

    if (getLocationQuality(bestLocation) != LocationQuality.BAD) 

        sendUpdate(locationToString(bestLocation));

    else Log.w("LocationCollector", "Failed to get a location");

}



private enum LocationQuality {

    BAD, ACCEPTED, GOOD;



    public String toString() {

        if (this == GOOD) return "Good";

        else if (this == ACCEPTED) return "Accepted";

        else return "Bad";

    }

}



private LocationQuality getLocationQuality(Location location) {

    if (location == null) return LocationQuality.BAD;

    if (!location.hasAccuracy()) return LocationQuality.BAD;

    long currentTime = System.currentTimeMillis();

    if (currentTime - location.getTime() < MAX_AGE

            && location.getAccuracy() <= GOOD_ACCURACY)

        return LocationQuality.GOOD;

    if (location.getAccuracy() <= ACCEPTED_ACCURACY)

        return LocationQuality.ACCEPTED;

    return LocationQuality.BAD;

}



private synchronized void updateBestLocation(Location location) {

    bestLocation = getBestLocation(location, bestLocation);

}



// Pretty much an unmodified version of googles example

protected Location getBestLocation(Location location,

        Location currentBestLocation) {

    if (currentBestLocation == null) {

        // A new location is always better than no location

        return location;

    }

    if (location == null) return currentBestLocation;

    // 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 location;

        // If the new location is more than two minutes older, it must be

        // worse

    } else if (isSignificantlyOlder) {

        return currentBestLocation;

    }

    // 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 location;

    } else if (isNewer && !isLessAccurate) {

        return location;

    } else if (isNewer && !isSignificantlyLessAccurate

            && isFromSameProvider) {

        return location;

    }

    return bestLocation;

}



/** Checks whether two providers are the same */

private boolean isSameProvider(String provider1, String provider2) {

    if (provider1 == null) {

        return provider2 == null;

    }

    return provider1.equals(provider2);

}