ACCESS_COARSE_LOCATION autorisation donne une tour de téléphonie cellulaire de précision sur Android

J'ai fais quelques tests avec le requestLocationUpdates() fonction de la FusedLocationApi. Je suis l'aide de la PRIORITY_BALANCED_POWER_ACCURACY. Un bloc de ville de précision est très bien pour moi.

Lorsque je demande la ACCESS_FINE_LOCATION permission, je reçois environ 100 m de précision ce qui est génial avec GPS off. Comme je n'ai pas besoin d'un GPS de précision, mais d'un bloc de ville de précision, je voudrais demander que la ACCESS_COARSE_LOCATION autorisation. Cependant, quand je demande la ACCESS_COARSE_LOCATION permission, je reçois à 2 km de précision. Il semble que l'appareil ne pas utiliser plus de la Wifi permission et seulement une tour de téléphonie cellulaire de précision.

Comment puis-je avoir une meilleure précision avec la ACCESS_COARSE_LOCATION permission?

Remarque: le GPS est désactivé sur mon appareil de test.

Google s'appuie emplacement de modèle par la collecte de points d'accès à l'information des utilisateurs qui se connectent via le wifi et les tours de téléphonie cellulaire. Plus les données qu'ils recueillent la meilleure est la précision donc, techniquement, vous auriez besoin de plus d'utilisateurs d'Android dans votre région. D'autre part, il semble bizarre que le GPS pourrait avoir une précision de l'ordre de 100 m ou 2 km pour les accès grossier. Êtes-vous sûr de ne pas mésestimer ?
GPS de précision est sur le compteur. Je fais tous mes tests avec le GPS éteint. L'appareil utilise le wifi quand je suis en utilisant le ACCESS_FINE_LOCATION autorisation (j'ai assez d'utilisateurs d'android dans ma région). Je devrais obtenir exactement le même résultat lors de l'utilisation de ACCESS_COARSE_LOCATION au lieu d'un 2000m de précision.

InformationsquelleAutor poiuytrez | 2015-05-12

49

C'est un problème intéressant, et j'étais sous l'impression que l'utilisation de ACCESS_COARSE_LOCATION serait d'utiliser le WiFi, puisque c'est ce que dit la documentation.

La documentation pour ACCESS_COARSE_LOCATION états:

Permet à une application d'accéder à l'emplacement approximatif dérivée à partir du réseau
localisation de sources telles que les tours de téléphonie cellulaire et d'une connexion Wi-Fi gratuite.

Donc, je l'ai mis à l'épreuve, et les résultats sont surprenants.

Voici le code que j'ai utilisé pour le test:
```
public class MainActivity extends Activity implements
GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, LocationListener {
LocationRequest mLocationRequest;
GoogleApiClient mGoogleApiClient;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
buildGoogleApiClient();
mGoogleApiClient.connect();
}
@Override
protected void onPause(){
super.onPause();
if (mGoogleApiClient != null) {
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
}
}
protected synchronized void buildGoogleApiClient() {
Toast.makeText(this,"buildGoogleApiClient",Toast.LENGTH_SHORT).show();
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}
@Override
public void onConnected(Bundle bundle) {
Toast.makeText(this,"onConnected",Toast.LENGTH_SHORT).show();
mLocationRequest = new LocationRequest();
mLocationRequest.setInterval(10);
mLocationRequest.setFastestInterval(10);
mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
//mLocationRequest.setPriority(LocationRequest.PRIORITY_LOW_POWER);
//mLocationRequest.setSmallestDisplacement(0.1F);
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
}
@Override
public void onConnectionSuspended(int i) {
Toast.makeText(this,"onConnectionSuspended",Toast.LENGTH_SHORT).show();
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
Toast.makeText(this,"onConnectionFailed",Toast.LENGTH_SHORT).show();
}
@Override
public void onLocationChanged(Location location) {
Log.d("locationtesting", "accuracy: " + location.getAccuracy() + " lat: " + location.getLatitude() + " lon: " + location.getLongitude());
Toast.makeText(this,"Location Changed",Toast.LENGTH_SHORT).show();
}
}
```
AndroidManifest.xml:
```
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
```
construire.gradle:
```
compile 'com.google.android.gms:play-services:7.3.0'
```
Le premier test que j'ai fait était avec PRIORITY_BALANCED_POWER_ACCURACY, et pas de WiFi. Notez que j'ai aussi désactivé Always Allow Scanning, car elle précise:

Laissez-Service de Localisation de Google et d'autres applications d'analyse pour le Wi-Fi
les réseaux, même lorsque la connexion Wi-Fi est désactivé

Donc, ce serait certainement biaiser les résultats si elle a été activée.

Noter que j'ai également eu Lieu en Mode en Mode d'Économie de Batterie pour tous les essais, de sorte que le GPS, la radio a été éteint tout le temps.

Voici les résultats de PRIORITY_BALANCED_POWER_ACCURACY, ACCESS_COARSE_LOCATION, et pas de WiFi:
```
accuracy: 2000.0 lat: 37.78378378378378 lon: -122.40320943772021
```
Donc, il dit à 2000 mètres de l'exactitude, et voici comment loin les coordonnées sont, la flèche verte indique où je suis, en fait:

Ensuite, j'ai activé le WiFi, et a couru de nouveau le test, et de façon surprenante, les résultats ont été exactement la même chose!
```
accuracy: 2000.0 lat: 37.78378378378378 lon: -122.40320943772021
```
Ensuite, je suis passé à LocationRequest.PRIORITY_LOW_POWER dans le LocationRequest tout en gardant android.permission.ACCESS_COARSE_LOCATION dans le AndroidManifest.xml.

Pas De WiFi:
```
accuracy: 2000.0 lat: 37.78378378378378 lon: -122.40320943772021
```
Avec Le WiFi:
```
accuracy: 2000.0 lat: 37.78378378378378 lon: -122.40320943772021
```
Les résultats ont été exactement la même!
À l'aide de PRIORITY_LOW_POWER eu les mêmes résultats que l'utilisation de PRIORITY_BALANCED_POWER_ACCURACY, en ce que le WiFi de l'état ne semble pas avoir d'effet sur la précision des coordonnées.

Puis, juste pour couvrir toutes les bases, j'ai changé de LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY, et la commutation de la AndroidManifest.xml pour ACCESS_FINE_LOCATION :
```
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
```
Premier test, pas de WiFi:
```
accuracy: 826.0 lat: 37.7825458 lon: -122.3948752
```
Si, il est dit exactitude de 826 mètres, et voici comment fermer il était sur la carte:

Ensuite, j'ai allumé le WiFi, et voici le résultat:
```
accuracy: 18.847 lat: 37.779679 lon: -122.3930918
```
C'est littéralement tache, comme vous pouvez le voir sur la carte:

Il semble que cela importe moins que ce que vous utilisez dans votre LocationRequest dans le code Java, et bien plus que l'autorisation que vous utilisez dans le AndroidManifest.xml puisque les résultats présentés ici montrent clairement que lors de l'utilisation de ACCESS_FINE_LOCATION, avoir la connexion WiFi, de la radio ou de désactiver fait une énorme différence dans la précision, et il est aussi plus précis en général.

Il semble certainement comme si la documentation est un peu manquer de pointe, et que tout en utilisant android.permission.ACCESS_COARSE_LOCATION, avoir la connexion WiFi, de la radio ou de désactiver ne pas faire une différence lorsque votre application est le seul à effectuer des demandes de localisation.

Autre chose que la documentation indique que l'utilisation de PRIORITY_BALANCED_POWER_ACCURACY permettra à votre application "piggy-back" sur les demandes de localisation effectués par d'autres applications.
À partir de la documentation:

Ils ne seront attribués à blâmer pour l'intervalle défini par
setInterval(long), mais peut encore recevoir des endroits déclenchée par d'autres
applications à un taux de jusqu'à setFastestInterval(long).

Donc, si l'utilisateur ouvre Google Maps, selon la documentation de votre application peut obtenir une localisation plus précise à ce point. C'est l'un des principaux jusqu'à-côtés de l'utilisation de la nouvelle Fusionné Fournisseur d'Emplacement plutôt que l'ancienne Api, car il diminue la quantité de drainage de la batterie de votre application sans beaucoup de travail sur votre partie.

Edit: j'ai effectué un test de cette fonctionnalité, pour voir ce qui pourrait se produire lors de l'utilisation ACCESS_COARSE_LOCATION.

Premier Test: ACCESS_COARSE_LOCATION, PRIORITY_BALANCED_POWER_ACCURACY, et WiFi:
```
accuracy: 2000.0 lat: 37.78378378378378 lon: -122.38041129850662
```
Qui m'a mis dans l'eau, assez loin de ma position actuelle.
Ensuite, j'ai quitté l'appli de test, a lancé Google Maps, qui trouve-moi exactement où je suis, puis re-lancement de l'appli de test.
L'application de test n'a pas été en mesure de se greffer sur l'emplacement de Google Maps, et le résultat est exactement le même qu'avant!
```
accuracy: 2000.0 lat: 37.78378378378378 lon: -122.38041129850662
```
J'ai re-testé il y a quelques temps, juste pour être sûr, mais il ressemble vraiment à l'aide de ACCESS_COARSE_LOCATION désactive également la capacité des applications de "piggy-back" sur les à des endroits obtenus par d'autres applications.

Il ressemble à l'aide de ACCESS_COARSE_LOCATION dans le AndroidManifest.xml vraiment paralyse l'application en termes d'obtenir des données de localisation précises.

En conclusion, la seule chose que vous pouvez vraiment faire est de se concentrer sur la meilleure combinaison de paramètres qui travaillent pour vous et votre application, et nous espérons que les résultats de ce test peut vous aider à prendre cette décision.
- Grandes épreuves. Cependant, je pense que vous vous trompez sur votre dernier paragraphe avant la conclusion). Si l'utilisateur ouvre les Cartes de Google et de nos apps demande ACCESS_COARSE_LOCATION, nous (malheureusement) toujours obtenir de 2000m. Il semble que le système à "cacher" un endroit plus précis que les 2000m.
- Bon point, j'ai fait une hypothèse. Je pensais que les coordonnées plus précises, quelle que soit l'exactitude signalés. Je vais le tester aujourd'hui, et de mettre à jour avec les résultats!
- Vous avez eu raison, les résultats des tests montrent que cette fonctionnalité ne fonctionne pas avec ACCESS_COARSE_LOCATION. J'ai mis à jour la réponse avec les résultats des tests à partir d'aujourd'hui.
- Merci pour tous vos tests. Nous pouvons voir clairement que COARSE_LOCATION_PERMISSION ne fonctionne pas comme il le devrait.
- Grandes épreuves. Donc dans l'ordre pour obtenir une précision de localisation de l'utilisateur il faut opter ACCESS_FINE_LOCATION autorisation. droit?
InformationsquelleAutor Daniel Nugent
3

Lorsque vous demandez de l'ACCESS_COARSE_LOCATION autorisation, fusionnées à l'emplacement du client vous donnera un pâté de maisons de la précision, c'est le comportement prévu et il est écrit dans la documentation. Jetez un oeil ici sous "Spécifier App Permissions"

Ce que je peux suggérer, c'est que vous l'utilisation de l'android fournisseur d'emplacement (pas fondu emplacement) et essayer de l'accès du fournisseur de RÉSEAU. Il devrait vous donner WIFI précision.
- À partir de la documentation: "Bloquer le niveau de précision est estimé à environ 100 mètres de précision. Avec un pinceau de précision comme souvent, cela consomme moins d'énergie.". Il devrait être un 100m de la précision, pas de 2000m de précision.
InformationsquelleAutor Ohad Zadok

Vous devez vous connecter pour publier un commentaire.