Gute Möglichkeit, den Standort des Benutzers in Android zu ermitteln

Das Problem:

Erhalten Sie den aktuellen Standort des Benutzers so schnell wie möglich innerhalb eines Schwellenwerts und schonen Sie gleichzeitig die Batterie.

Warum das Problem ein Problem ist:

Zunächst einmal hat Android zwei Anbieter; Netzwerk und GPS. Manchmal ist das Netzwerk besser und manchmal ist das GPS besser.

Mit "besser" meine ich das Verhältnis von Geschwindigkeit zu Genauigkeit.
Ich bin bereit, ein paar Meter Genauigkeit zu opfern, wenn ich den Standort fast sofort und ohne Einschalten des GPS ermitteln kann.

Zweitens wird nichts gesendet, wenn Sie Aktualisierungen für Standortänderungen anfordern, wenn der aktuelle Standort stabil ist.

Google hat hier ein Beispiel für die Ermittlung des "besten" Standorts: http://developer.android.com/guide/topics/location/obtaining-user-location.html#BestEstimate
Aber ich denke, es ist nicht annähernd so gut wie es sollte /könnte sein.

Ich bin etwas verwirrt, warum Google keine normalisierte API für den Standort hat. Der Entwickler sollte sich nicht darum kümmern müssen, woher der Standort stammt. Sie sollten nur angeben, was Sie möchten, und das Telefon sollte für Sie auswählen.

Womit ich Hilfe brauche:

Ich muss einen guten Weg finden, um den "besten" Ort zu bestimmen, vielleicht durch eine Heuristik oder durch eine Bibliothek eines Drittanbieters.

Dies bedeutet nicht, den besten Anbieter zu ermitteln!
Ich werde wahrscheinlich alle Anbieter nutzen und die besten auswählen.

Hintergrund der App:

Die App sammelt den Standort des Benutzers in einem festgelegten Intervall (etwa alle 10 Minuten) und sendet ihn an einen Server.
Die App sollte so viel Batterie wie möglich sparen und der Standort sollte eine Genauigkeit von X (50-100?) Meter haben.

Das Ziel ist es, später den Pfad des Benutzers während des Tages auf einer Karte darstellen zu können, daher benötige ich dafür eine ausreichende Genauigkeit.

Sonstiges:

Was sind Ihrer Meinung nach vernünftige Werte für gewünschte und akzeptierte Genauigkeiten?
Ich habe 100 m wie akzeptiert und 30 m wie gewünscht verwendet. Ist das zu viel verlangt?
Ich möchte den Pfad des Benutzers später auf einer Karte darstellen können.
Ist 100m für gewünscht und 500m für akzeptiert besser?

Im Moment habe ich das GPS für maximal 60 Sekunden pro Standortaktualisierung eingeschaltet. Ist dies zu kurz, um einen Standort zu ermitteln, wenn Sie sich in Innenräumen mit einer Genauigkeit von etwa 200 m befinden?

Dies ist mein aktueller Code. Jedes Feedback wird geschätzt (abgesehen von der fehlenden Fehlerprüfung, die TODO ist):

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

Sieht so aus, als würden wir dieselbe Anwendung codieren ;-)
Hier ist meine aktuelle Implementierung. Ich bin noch in der Beta-Testphase meiner GPS-Uploader-App, daher gibt es möglicherweise viele mögliche Verbesserungen. aber es scheint bisher ziemlich gut zu funktionieren.

/**
 * try to get the 'best' location selected from all providers
 */
private Location getBestLocation() {
    Location gpslocation = getLocationByProvider(LocationManager.GPS_PROVIDER);
    Location networkLocation =
            getLocationByProvider(LocationManager.NETWORK_PROVIDER);
    // if we have only one location available, the choice is easy
    if (gpslocation == null) {
        Log.d(TAG, "No GPS Location available.");
        return networkLocation;
    }
    if (networkLocation == null) {
        Log.d(TAG, "No Network Location available");
        return gpslocation;
    }
    // a locationupdate is considered 'old' if its older than the configured
    // update interval. this means, we didn't get a
    // update from this provider since the last check
    long old = System.currentTimeMillis() - getGPSCheckMilliSecsFromPrefs();
    boolean gpsIsOld = (gpslocation.getTime() < old);
    boolean networkIsOld = (networkLocation.getTime() < old);
    // gps is current and available, gps is better than network
    if (!gpsIsOld) {
        Log.d(TAG, "Returning current GPS Location");
        return gpslocation;
    }
    // gps is old, we can't trust it. use network location
    if (!networkIsOld) {
        Log.d(TAG, "GPS is old, Network is current, returning network");
        return networkLocation;
    }
    // both are old return the newer of those two
    if (gpslocation.getTime() > networkLocation.getTime()) {
        Log.d(TAG, "Both are old, returning gps(newer)");
        return gpslocation;
    } else {
        Log.d(TAG, "Both are old, returning network(newer)");
        return networkLocation;
    }
}

/**
 * get the last known location from a specific provider (network/gps)
 */
private Location getLocationByProvider(String provider) {
    Location location = null;
    if (!isProviderSupported(provider)) {
        return null;
    }
    LocationManager locationManager = (LocationManager) getApplicationContext()
            .getSystemService(Context.LOCATION_SERVICE);
    try {
        if (locationManager.isProviderEnabled(provider)) {
            location = locationManager.getLastKnownLocation(provider);
        }
    } catch (IllegalArgumentException e) {
        Log.d(TAG, "Cannot acces Provider " + provider);
    }
    return location;
}

Bearbeiten: Hier ist der Teil, der die regelmäßigen Aktualisierungen von den Standortanbietern anfordert:

public void startRecording() {
    gpsTimer.cancel();
    gpsTimer = new Timer();
    long checkInterval = getGPSCheckMilliSecsFromPrefs();
    long minDistance = getMinDistanceFromPrefs();
    // receive updates
    LocationManager locationManager = (LocationManager) getApplicationContext()
            .getSystemService(Context.LOCATION_SERVICE);
    for (String s : locationManager.getAllProviders()) {
        locationManager.requestLocationUpdates(s, checkInterval,
                minDistance, new LocationListener() {

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

                    @Override
                    public void onProviderEnabled(String provider) {}

                    @Override
                    public void onProviderDisabled(String provider) {}

                    @Override
                    public void onLocationChanged(Location location) {
                        // if this is a gps location, we can use it
                        if (location.getProvider().equals(
                                LocationManager.GPS_PROVIDER)) {
                            doLocationUpdate(location, true);
                        }
                    }
                });
        // //Toast.makeText(this, "GPS Service STARTED",
        // Toast.LENGTH_LONG).show();
        gps_recorder_running = true;
    }
    // start the gps receiver thread
    gpsTimer.scheduleAtFixedRate(new TimerTask() {

        @Override
        public void run() {
            Location location = getBestLocation();
            doLocationUpdate(location, false);
        }
    }, 0, checkInterval);
}

public void doLocationUpdate(Location l, boolean force) {
    long minDistance = getMinDistanceFromPrefs();
    Log.d(TAG, "update received:" + l);
    if (l == null) {
        Log.d(TAG, "Empty location");
        if (force)
            Toast.makeText(this, "Current location not available",
                    Toast.LENGTH_SHORT).show();
        return;
    }
    if (lastLocation != null) {
        float distance = l.distanceTo(lastLocation);
        Log.d(TAG, "Distance to last: " + distance);
        if (l.distanceTo(lastLocation) < minDistance && !force) {
            Log.d(TAG, "Position didn't change");
            return;
        }
        if (l.getAccuracy() >= lastLocation.getAccuracy()
                && l.distanceTo(lastLocation) < l.getAccuracy() && !force) {
            Log.d(TAG,
                    "Accuracy got worse and we are still "
                      + "within the accuracy range.. Not updating");
            return;
        }
        if (l.getTime() <= lastprovidertimestamp && !force) {
            Log.d(TAG, "Timestamp not never than last");
            return;
        }
    }
    // upload/store your location here
}

Dinge, die man beachten muss:

• Fordern Sie nicht zu oft GPS-Updates an, da der Akku entladen wird. Ich verwende derzeit 30 Minuten als Standard für meine Anwendung.

• Fügen Sie eine Überprüfung der Mindestentfernung zum letzten bekannten Standort hinzu. Ohne dies "springen" Ihre Punkte herum, wenn kein GPS verfügbar ist und der Standort von den Mobilfunkmasten aus trianguliert wird. oder Sie können überprüfen, ob der neue Standort außerhalb des Genauigkeitswerts des letzten bekannten Standorts liegt.

Um den richtigen Standortanbieter für Ihre App auszuwählen, können Sie Kriterienobjekte verwenden :

Criteria myCriteria = new Criteria();
myCriteria.setAccuracy(Criteria.ACCURACY_HIGH);
myCriteria.setPowerRequirement(Criteria.POWER_LOW);
// let Android select the right location provider for you
String myProvider = locationManager.getBestProvider(myCriteria, true); 

// finally require updates at -at least- the desired rate
long minTimeMillis = 600000; // 600,000 milliseconds make 10 minutes
locationManager.requestLocationUpdates(myProvider,minTimeMillis,0,locationListener); 

Weitere Informationen zur Berücksichtigung der Argumente finden Sie in der Dokumentation zu requestLocationUpdates :

Die Häufigkeit der Benachrichtigung kann mithilfe der Parameter minTime und minDistance gesteuert werden. Wenn minTime größer als 0 ist, kann der LocationManager möglicherweise minTime Millisekunden zwischen Standortaktualisierungen ruhen, um Strom zu sparen. Wenn minDistance größer als 0 ist, wird ein Standort nur gesendet, wenn sich das Gerät mit minDistance-Messgeräten bewegt. Um so häufig wie möglich Benachrichtigungen zu erhalten, setzen Sie beide Parameter auf 0.

Weitere Gedanken

• Sie können die Genauigkeit der Standortobjekte mit Location.getAccuracy () überwachen , das die geschätzte Genauigkeit der Position in Metern zurückgibt.
• Das Criteria.ACCURACY_HIGHKriterium sollte Ihnen Fehler unter 100 m geben, was nicht so gut ist wie GPS, aber Ihren Anforderungen entspricht.
• Sie müssen auch den Status Ihres Standortanbieters überwachen und zu einem anderen Anbieter wechseln, wenn dieser vom Benutzer nicht verfügbar oder deaktiviert wird.
• Der passive Anbieter passt möglicherweise auch gut zu dieser Art von Anwendung: Die Idee ist, Standortaktualisierungen zu verwenden, wenn sie von einer anderen App angefordert und systemweit gesendet werden.

Beantwortung der ersten beiden Punkte :

• GPS gibt Ihnen immer einen genaueren Standort, wenn es aktiviert ist und keine dicken Wände vorhanden sind .

• Wenn sich der Speicherort nicht geändert hat, können Sie getLastKnownLocation (String) aufrufen und den Speicherort sofort abrufen.

Verwenden eines alternativen Ansatzes :

Sie können versuchen, die Zellen-ID oder alle benachbarten Zellen zu verwenden

TelephonyManager mTelephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
GsmCellLocation loc = (GsmCellLocation) mTelephonyManager.getCellLocation(); 
Log.d ("CID", Integer.toString(loc.getCid()));
Log.d ("LAC", Integer.toString(loc.getLac()));
// or 
List<NeighboringCellInfo> list = mTelephonyManager.getNeighboringCellInfo ();
for (NeighboringCellInfo cell : list) {
    Log.d ("CID", Integer.toString(cell.getCid()));
    Log.d ("LAC", Integer.toString(cell.getLac()));
}

Sie können dann über mehrere offene Datenbanken (z. B. http://www.location-api.com/ oder http://opencellid.org/ ) auf den Zellenstandort verweisen.

Die Strategie wäre, die Liste der Turm-IDs beim Lesen des Standorts zu lesen. Lesen Sie sie dann in der nächsten Abfrage (10 Minuten in Ihrer App) erneut. Wenn mindestens einige Türme gleich sind, ist die Verwendung sicher getLastKnownLocation(String). Wenn nicht, warten Sie onLocationChanged(). Dadurch wird die Notwendigkeit einer Datenbank eines Drittanbieters für den Standort vermieden. Sie können diesen Ansatz auch ausprobieren .

Dies ist meine Lösung, die ziemlich gut funktioniert:

private Location bestLocation = null;
private Looper looper;
private boolean networkEnabled = false, gpsEnabled = false;

private synchronized void setLooper(Looper looper) {
    this.looper = looper;
}

private synchronized void stopLooper() {
    if (looper == null) return;
    looper.quit();
}

@Override
protected void runTask() {
    final LocationManager locationManager = (LocationManager) service
            .getSystemService(Context.LOCATION_SERVICE);
    final SharedPreferences prefs = getPreferences();
    final int maxPollingTime = Integer.parseInt(prefs.getString(
            POLLING_KEY, "0"));
    final int desiredAccuracy = Integer.parseInt(prefs.getString(
            DESIRED_KEY, "0"));
    final int acceptedAccuracy = Integer.parseInt(prefs.getString(
            ACCEPTED_KEY, "0"));
    final int maxAge = Integer.parseInt(prefs.getString(AGE_KEY, "0"));
    final String whichProvider = prefs.getString(PROVIDER_KEY, "any");
    final boolean canUseGps = whichProvider.equals("gps")
            || whichProvider.equals("any");
    final boolean canUseNetwork = whichProvider.equals("network")
            || whichProvider.equals("any");
    if (canUseNetwork)
        networkEnabled = locationManager
                .isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    if (canUseGps)
        gpsEnabled = locationManager
                .isProviderEnabled(LocationManager.GPS_PROVIDER);
    // If any provider is enabled now and we displayed a notification clear it.
    if (gpsEnabled || networkEnabled) removeErrorNotification();
    if (gpsEnabled)
        updateBestLocation(locationManager
                .getLastKnownLocation(LocationManager.GPS_PROVIDER));
    if (networkEnabled)
        updateBestLocation(locationManager
                .getLastKnownLocation(LocationManager.NETWORK_PROVIDER));
    if (desiredAccuracy == 0
            || getLocationQuality(desiredAccuracy, acceptedAccuracy,
                    maxAge, bestLocation) != LocationQuality.GOOD) {
        // Define a listener that responds to location updates
        LocationListener locationListener = new LocationListener() {

            public void onLocationChanged(Location location) {
                updateBestLocation(location);
                if (desiredAccuracy != 0
                        && getLocationQuality(desiredAccuracy,
                                acceptedAccuracy, maxAge, bestLocation)
                                == LocationQuality.GOOD)
                    stopLooper();
            }

            public void onProviderEnabled(String provider) {
                if (isSameProvider(provider,
                        LocationManager.NETWORK_PROVIDER))networkEnabled =true;
                else if (isSameProvider(provider,
                        LocationManager.GPS_PROVIDER)) gpsEnabled = true;
                // The user has enabled a location, remove any error
                // notification
                if (canUseGps && gpsEnabled || canUseNetwork
                        && networkEnabled) removeErrorNotification();
            }

            public void onProviderDisabled(String provider) {
                if (isSameProvider(provider,
                        LocationManager.NETWORK_PROVIDER))networkEnabled=false;
                else if (isSameProvider(provider,
                        LocationManager.GPS_PROVIDER)) gpsEnabled = false;
                if (!gpsEnabled && !networkEnabled) {
                    showErrorNotification();
                    stopLooper();
                }
            }

            public void onStatusChanged(String provider, int status,
                    Bundle extras) {
                Log.i(LOG_TAG, "Provider " + provider + " statusChanged");
                if (isSameProvider(provider,
                        LocationManager.NETWORK_PROVIDER)) networkEnabled = 
                        status == LocationProvider.AVAILABLE
                        || status == LocationProvider.TEMPORARILY_UNAVAILABLE;
                else if (isSameProvider(provider,
                        LocationManager.GPS_PROVIDER))
                    gpsEnabled = status == LocationProvider.AVAILABLE
                      || status == LocationProvider.TEMPORARILY_UNAVAILABLE;
                // None of them are available, stop listening
                if (!networkEnabled && !gpsEnabled) {
                    showErrorNotification();
                    stopLooper();
                }
                // The user has enabled a location, remove any error
                // notification
                else if (canUseGps && gpsEnabled || canUseNetwork
                        && networkEnabled) removeErrorNotification();
            }
        };
        if (networkEnabled || gpsEnabled) {
            Looper.prepare();
            setLooper(Looper.myLooper());
            // Register the listener with the Location Manager to receive
            // location updates
            if (canUseGps)
                locationManager.requestLocationUpdates(
                        LocationManager.GPS_PROVIDER, 1000, 1,
                        locationListener, Looper.myLooper());
            if (canUseNetwork)
                locationManager.requestLocationUpdates(
                        LocationManager.NETWORK_PROVIDER, 1000, 1,
                        locationListener, Looper.myLooper());
            Timer t = new Timer();
            t.schedule(new TimerTask() {

                @Override
                public void run() {
                    stopLooper();
                }
            }, maxPollingTime * 1000);
            Looper.loop();
            t.cancel();
            setLooper(null);
            locationManager.removeUpdates(locationListener);
        } else // No provider is enabled, show a notification
        showErrorNotification();
    }
    if (getLocationQuality(desiredAccuracy, acceptedAccuracy, maxAge,
            bestLocation) != LocationQuality.BAD) {
        sendUpdate(new Event(EVENT_TYPE, locationToString(desiredAccuracy,
                acceptedAccuracy, maxAge, bestLocation)));
    } else Log.w(LOG_TAG, "LocationCollector failed to get a location");
}

private synchronized void showErrorNotification() {
    if (notifId != 0) return;
    ServiceHandler handler = service.getHandler();
    NotificationInfo ni = NotificationInfo.createSingleNotification(
            R.string.locationcollector_notif_ticker,
            R.string.locationcollector_notif_title,
            R.string.locationcollector_notif_text,
            android.R.drawable.stat_notify_error);
    Intent intent = new Intent(
            android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);
    ni.pendingIntent = PendingIntent.getActivity(service, 0, intent,
            PendingIntent.FLAG_UPDATE_CURRENT);
    Message msg = handler.obtainMessage(ServiceHandler.SHOW_NOTIFICATION);
    msg.obj = ni;
    handler.sendMessage(msg);
    notifId = ni.id;
}

private void removeErrorNotification() {
    if (notifId == 0) return;
    ServiceHandler handler = service.getHandler();
    if (handler != null) {
        Message msg = handler.obtainMessage(
                ServiceHandler.CLEAR_NOTIFICATION, notifId, 0);
        handler.sendMessage(msg);
        notifId = 0;
    }
}

@Override
public void interrupt() {
    stopLooper();
    super.interrupt();
}

private String locationToString(int desiredAccuracy, int acceptedAccuracy,
        int maxAge, Location location) {
    StringBuilder sb = new StringBuilder();
    sb.append(String.format(
            "qual=%s time=%d prov=%s acc=%.1f lat=%f long=%f",
            getLocationQuality(desiredAccuracy, acceptedAccuracy, maxAge,
                    location), location.getTime() / 1000, // Millis to
                                                            // seconds
            location.getProvider(), location.getAccuracy(), location
                    .getLatitude(), location.getLongitude()));
    if (location.hasAltitude())
        sb.append(String.format(" alt=%.1f", location.getAltitude()));
    if (location.hasBearing())
        sb.append(String.format(" bearing=%.2f", location.getBearing()));
    return sb.toString();
}

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(int desiredAccuracy,
        int acceptedAccuracy, int maxAge, Location location) {
    if (location == null) return LocationQuality.BAD;
    if (!location.hasAccuracy()) return LocationQuality.BAD;
    long currentTime = System.currentTimeMillis();
    if (currentTime - location.getTime() < maxAge * 1000
            && location.getAccuracy() <= desiredAccuracy)
        return LocationQuality.GOOD;
    if (acceptedAccuracy == -1
            || location.getAccuracy() <= acceptedAccuracy)
        return LocationQuality.ACCEPTED;
    return LocationQuality.BAD;
}

private synchronized void updateBestLocation(Location location) {
    bestLocation = getBestLocation(location, bestLocation);
}

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

Die Standortgenauigkeit hängt hauptsächlich vom verwendeten Standortanbieter ab:

1. GPS - bringt Ihnen eine Genauigkeit von mehreren Metern (vorausgesetzt, Sie haben GPS-Empfang)
2. Wifi - Sie erhalten einige hundert Meter Genauigkeit
3. Cell Network - Erhält sehr ungenaue Ergebnisse (ich habe bis zu 4 km Abweichung gesehen ...)

Wenn Sie nach Genauigkeit suchen, ist GPS Ihre einzige Option.

Ich habe einen sehr informativen Artikel darüber lesen Sie hier .

Für das GPS-Timeout sollten 60 Sekunden ausreichen und in den meisten Fällen sogar zu viel. Ich denke 30 Sekunden sind OK und manchmal sogar weniger als 5 Sekunden ...

Wenn Sie nur einen einzigen Standort benötigen, würde ich vorschlagen, dass Sie bei Ihrer onLocationChangedMethode nach Erhalt eines Updates die Registrierung des Listeners aufheben und eine unnötige Verwendung des GPS vermeiden.

Derzeit verwende ich, da dies vertrauenswürdig ist, um den Standort zu ermitteln und die Entfernung für meine Anwendung zu berechnen. Ich verwende dies für meine Taxi-Anwendung.

Verwenden Sie die Fusions-API, die Google-Entwickler mit der Fusion von GPS-Sensor, Magnetometer und Beschleunigungsmesser entwickelt haben. Verwenden Sie außerdem WLAN oder den Standort der Zelle, um den Standort zu berechnen oder zu schätzen. Es ist auch in der Lage, Standortaktualisierungen auch innerhalb des Gebäudes genau zu geben. Weitere Informationen finden Sie unter https://developers.google.com/android/reference/com/google/android/gms/location/FusedLocationProviderApi

import android.app.Activity;
import android.location.Location;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GooglePlayServicesUtil;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks;
import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


public class MainActivity extends Activity implements LocationListener,
        GoogleApiClient.ConnectionCallbacks,
        GoogleApiClient.OnConnectionFailedListener {

    private static final long ONE_MIN = 500;
    private static final long TWO_MIN = 500;
    private static final long FIVE_MIN = 500;
    private static final long POLLING_FREQ = 1000 * 20;
    private static final long FASTEST_UPDATE_FREQ = 1000 * 5;
    private static final float MIN_ACCURACY = 1.0f;
    private static final float MIN_LAST_READ_ACCURACY = 1;

    private LocationRequest mLocationRequest;
    private Location mBestReading;
TextView tv;
    private GoogleApiClient mGoogleApiClient;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (!servicesAvailable()) {
            finish();
        }

        setContentView(R.layout.activity_main);
tv= (TextView) findViewById(R.id.tv1);
        mLocationRequest = LocationRequest.create();
        mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        mLocationRequest.setInterval(POLLING_FREQ);
        mLocationRequest.setFastestInterval(FASTEST_UPDATE_FREQ);

        mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addApi(LocationServices.API)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();


        if (mGoogleApiClient != null) {
            mGoogleApiClient.connect();
        }
    }

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

        if (mGoogleApiClient != null) {
            mGoogleApiClient.connect();
        }
    }

    @Override
    protected void onPause() {d
        super.onPause();

        if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
            mGoogleApiClient.disconnect();
        }
    }


        tv.setText(location + "");
        // Determine whether new location is better than current best
        // estimate
        if (null == mBestReading || location.getAccuracy() < mBestReading.getAccuracy()) {
            mBestReading = location;


            if (mBestReading.getAccuracy() < MIN_ACCURACY) {
                LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
            }
        }
    }

    @Override
    public void onConnected(Bundle dataBundle) {
        // Get first reading. Get additional location updates if necessary
        if (servicesAvailable()) {

            // Get best last location measurement meeting criteria
            mBestReading = bestLastKnownLocation(MIN_LAST_READ_ACCURACY, FIVE_MIN);

            if (null == mBestReading
                    || mBestReading.getAccuracy() > MIN_LAST_READ_ACCURACY
                    || mBestReading.getTime() < System.currentTimeMillis() - TWO_MIN) {

                LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);

               //Schedule a runnable to unregister location listeners

                    @Override
                    public void run() {
                        LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, MainActivity.this);

                    }

                }, ONE_MIN, TimeUnit.MILLISECONDS);

            }

        }
    }

    @Override
    public void onConnectionSuspended(int i) {

    }


    private Location bestLastKnownLocation(float minAccuracy, long minTime) {
        Location bestResult = null;
        float bestAccuracy = Float.MAX_VALUE;
        long bestTime = Long.MIN_VALUE;

        // Get the best most recent location currently available
        Location mCurrentLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
        //tv.setText(mCurrentLocation+"");
        if (mCurrentLocation != null) {
            float accuracy = mCurrentLocation.getAccuracy();
            long time = mCurrentLocation.getTime();

            if (accuracy < bestAccuracy) {
                bestResult = mCurrentLocation;
                bestAccuracy = accuracy;
                bestTime = time;
            }
        }

        // Return best reading or null
        if (bestAccuracy > minAccuracy || bestTime < minTime) {
            return null;
        }
        else {
            return bestResult;
        }
    }

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {

    }

    private boolean servicesAvailable() {
        int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);

        if (ConnectionResult.SUCCESS == resultCode) {
            return true;
        }
        else {
            GooglePlayServicesUtil.getErrorDialog(resultCode, this, 0).show();
            return false;
        }
    }
}

Ich habe das Internet nach einer aktualisierten Antwort (im letzten Jahr) durchsucht und dabei die neuesten von Google vorgeschlagenen Methoden zum Abrufen von Standorten verwendet (um FusedLocationProviderClient zu verwenden). Ich bin endlich darauf gelandet:

https://github.com/googlesamples/android-play-location/tree/master/LocationUpdates

Ich habe ein neues Projekt erstellt und den größten Teil dieses Codes kopiert. Boom. Es klappt. Und ich denke ohne veraltete Zeilen.

Außerdem scheint der Simulator keinen GPS-Standort zu erhalten, von dem ich weiß. Es ging so weit, dies im Protokoll zu melden: "Alle Standorteinstellungen sind erfüllt."

Und schließlich, falls Sie es wissen wollten (ich tat es), benötigen Sie KEINEN Google Maps-API-Schlüssel von der Google-Entwicklerkonsole, wenn Sie nur den GPS-Standort wünschen.

Ebenfalls nützlich ist ihr Tutorial. Aber ich wollte ein vollständiges einseitiges Tutorial / Codebeispiel, und das. Ihr Tutorial stapelt sich, ist aber verwirrend, wenn Sie neu in diesem Bereich sind, da Sie nicht wissen, welche Teile Sie von früheren Seiten benötigen.

https://developer.android.com/training/location/index.html

Und schließlich erinnern Sie sich an solche Dinge:

Ich musste nicht nur die mainActivity.Java ändern. Ich musste auch Strings.xml, androidmanifest.xml UND das richtige build.gradle ändern. Und auch Ihre activity_Main.xml (aber dieser Teil war einfach für mich).

Ich musste Abhängigkeiten wie diese hinzufügen: Implementierung 'com.google.android.gms: play-services-location: 11.8.0' und die Einstellungen meines Android Studio SDK so aktualisieren, dass sie Google Play Services enthalten. (Dateieinstellungen Aussehen Systemeinstellungen Android SDK SDK Tools überprüfen Google Play Services).

Update: Der Android-Simulator schien einen Standort und Standortänderungsereignisse zu erhalten (als ich den Wert in den Einstellungen der Sim änderte). Aber meine besten und ersten Ergebnisse wurden auf einem tatsächlichen Gerät erzielt. Daher ist es wahrscheinlich am einfachsten, auf tatsächlichen Geräten zu testen.

Kürzlich überarbeitet, um den Speicherort des Codes zu ermitteln, einige gute Ideen zu erlernen und schließlich eine relativ perfekte Bibliothek und Demo zu erhalten.

@ Gryphius 'Antwort ist gut

    //request all valid provider(network/gps)
private boolean requestAllProviderUpdates() {
    checkRuntimeEnvironment();
    checkPermission();

    if (isRequesting) {
        EasyLog.d("Request location update is busy");
        return false;
    }


    long minTime = getCheckTimeInterval();
    float minDistance = getCheckMinDistance();

    if (mMapLocationListeners == null) {
        mMapLocationListeners = new HashMap<>();
    }

    mValidProviders = getValidProviders();
    if (mValidProviders == null || mValidProviders.isEmpty()) {
        throw new IllegalArgumentException("Not available provider.");
    }

    for (String provider : mValidProviders) {
        LocationListener locationListener = new LocationListener() {
            @Override
            public void onLocationChanged(Location location) {
                if (location == null) {
                    EasyLog.e("LocationListener callback location is null.");
                    return;
                }
                printf(location);
                mLastProviderTimestamp = location.getTime();

                if (location.getProvider().equals(LocationManager.GPS_PROVIDER)) {
                    finishResult(location);
                } else {
                    doLocationResult(location);
                }

                removeProvider(location.getProvider());
                if (isEmptyValidProviders()) {
                    requestTimeoutMsgInit();
                    removeUpdates();
                }
            }

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

            @Override
            public void onProviderEnabled(String provider) {
            }

            @Override
            public void onProviderDisabled(String provider) {
            }
        };
        getLocationManager().requestLocationUpdates(provider, minTime, minDistance, locationListener);
        mMapLocationListeners.put(provider, locationListener);
        EasyLog.d("Location request %s provider update.", provider);
    }
    isRequesting = true;
    return true;
}

//remove request update
public void removeUpdates() {
    checkRuntimeEnvironment();

    LocationManager locationManager = getLocationManager();
    if (mMapLocationListeners != null) {
        Set<String> keys = mMapLocationListeners.keySet();
        for (String key : keys) {
            LocationListener locationListener = mMapLocationListeners.get(key);
            if (locationListener != null) {
                locationManager.removeUpdates(locationListener);
                EasyLog.d("Remove location update, provider is " + key);
            }
        }
        mMapLocationListeners.clear();
        isRequesting = false;
    }
}

//Compared with the last successful position, to determine whether you need to filter
private boolean isNeedFilter(Location location) {
    checkLocation(location);

    if (mLastLocation != null) {
        float distance = location.distanceTo(mLastLocation);
        if (distance < getCheckMinDistance()) {
            return true;
        }
        if (location.getAccuracy() >= mLastLocation.getAccuracy()
                && distance < location.getAccuracy()) {
            return true;
        }
        if (location.getTime() <= mLastProviderTimestamp) {
            return true;
        }
    }
    return false;
}

private void doLocationResult(Location location) {
    checkLocation(location);

    if (isNeedFilter(location)) {
        EasyLog.d("location need to filtered out, timestamp is " + location.getTime());
        finishResult(mLastLocation);
    } else {
        finishResult(location);
    }
}

//Return to the finished position
private void finishResult(Location location) {
    checkLocation(location);

    double latitude = location.getLatitude();
    double longitude = location.getLongitude();
    float accuracy = location.getAccuracy();
    long time = location.getTime();
    String provider = location.getProvider();

    if (mLocationResultListeners != null && !mLocationResultListeners.isEmpty()) {
        String format = "Location result:<%f, %f> Accuracy:%f Time:%d Provider:%s";
        EasyLog.i(String.format(format, latitude, longitude, accuracy, time, provider));

        mLastLocation = location;
        synchronized (this) {
            Iterator<LocationResultListener> iterator =  mLocationResultListeners.iterator();
            while (iterator.hasNext()) {
                LocationResultListener listener = iterator.next();
                if (listener != null) {
                    listener.onResult(location);
                }
                iterator.remove();
            }
        }
    }
}

Vollständige Implementierung: https://github.com/bingerz/FastLocation/blob/master/fastlocationlib/src/main/java/cn/bingerz/fastlocation/FastLocation.java

1. Dank der @ Grephius-Lösungsideen teile ich auch den vollständigen Code.

2.Jede Anforderung, den Standort zu vervollständigen, ist am besten, Aktualisierungen zu entfernen, da sonst in der Statusleiste des Telefons immer das Positionierungssymbol angezeigt wird

Nach meiner Erfahrung ist es am besten, mit dem GPS-Fix zu arbeiten, es sei denn, er ist nicht verfügbar. Ich weiß nicht viel über andere Standortanbieter, aber ich weiß, dass es für GPS einige Tricks gibt, mit denen man ein bisschen Ghetto-Präzision messen kann. Die Höhe ist oft ein Zeichen, so dass Sie nach lächerlichen Werten suchen können. Es gibt das Genauigkeitsmaß für Android-Standortkorrekturen. Auch wenn Sie die Anzahl der verwendeten Satelliten sehen können, kann dies auch die Genauigkeit anzeigen.

Ein interessanter Weg, um eine bessere Vorstellung von der Genauigkeit zu bekommen, könnte darin bestehen, sehr schnell nach einer Reihe von Korrekturen zu fragen, z. B. ~ 1 / s für 10 Sekunden, und dann ein oder zwei Minuten zu schlafen. Ein Vortrag, an dem ich teilgenommen habe, hat zu der Annahme geführt, dass einige Android-Geräte dies sowieso tun werden. Sie würden dann die Ausreißer aussortieren (ich habe gehört, dass der Kalman-Filter hier erwähnt wird) und eine Art Zentrierungsstrategie verwenden, um eine einzelne Korrektur zu erhalten.

Offensichtlich hängt die Tiefe, die Sie hier erreichen, davon ab, wie hoch Ihre Anforderungen sind. Wenn Sie besonders strenge Anforderungen haben, um den bestmöglichen Standort zu erhalten, werden Sie feststellen, dass GPS und Netzwerkstandort so ähnlich sind wie Äpfel und Orangen. Auch GPS kann von Gerät zu Gerät sehr unterschiedlich sein.

Skyhook (http://www.skyhookwireless.com/) hat einen Standortanbieter, der viel schneller ist als der von Google bereitgestellte Standardanbieter. Es könnte das sein, wonach Sie suchen. Ich bin nicht mit ihnen verbunden.