Localisation fictive Android sur l'appareil?
Comment puis-je simuler ma position sur un périphérique physique (Nexus One)? Je sais que vous pouvez le faire avec l'émulateur dans le panneau de configuration de l'émulateur, mais cela ne fonctionne pas pour un périphérique physique.
Il semble que la seule façon de faire est d'utiliser un fournisseur de localisation fictif.
Vous devez activer les emplacements fictifs dans le panneau de développement dans vos paramètres et ajouter
<uses-permission Android:name="Android.permission.ACCESS_MOCK_LOCATION" />
à votre manifeste.
Maintenant, vous pouvez aller dans votre code et créer votre propre fournisseur d'emplacement fictif et définir l'emplacement de ce fournisseur.
Si vous utilisez ce téléphone uniquement dans les laboratoires de développement, vous pouvez souder une puce GPS et alimenter le port série directement avec les séquences NMEA d'un autre appareil.
J'aimerais avoir mon câble à portée de main. Je sais que vous pouvez téléphoner à l'émulateur pour changer son emplacement
$ telnet localhost 5554
Android Console: type 'help' for a list of commands
OK
geo fix -82.411629 28.054553
OK
Je ne me souviens plus si vous pouvez établir une connexion telnet avec votre appareil, mais je pense que vous le pouvez. J'espère que ça aide.
Vous aurez besoin de adb (pont de débogage Android) pour cela (CLI).
Vous pouvez utiliser la permission des services de localisation pour simuler une position ...
"Android.permission.ACCESS_MOCK_LOCATION"
et ensuite dans votre code Java,
// Set location by setting the latitude, longitude and may be the altitude...
String[] MockLoc = str.split(",");
Location location = new Location(mocLocationProvider);
Double lat = Double.valueOf(MockLoc[0]);
location.setLatitude(lat);
Double longi = Double.valueOf(MockLoc[1]);
location.setLongitude(longi);
Double alti = Double.valueOf(MockLoc[2]);
location.setAltitude(alti);
J'ai eu du succès avec le code suivant. Bien que cela m'ait procuré un verrou unique pour une raison quelconque (même si j'ai essayé différentes paires de LatLng), cela a fonctionné pour moi. mLocationManager est une LocationManager qui est raccordée à une LocationListener:
private void getMockLocation()
{
mLocationManager.removeTestProvider(LocationManager.GPS_PROVIDER);
mLocationManager.addTestProvider
(
LocationManager.GPS_PROVIDER,
"requiresNetwork" == "",
"requiresSatellite" == "",
"requiresCell" == "",
"hasMonetaryCost" == "",
"supportsAltitude" == "",
"supportsSpeed" == "",
"supportsBearing" == "",
Android.location.Criteria.POWER_LOW,
Android.location.Criteria.ACCURACY_FINE
);
Location newLocation = new Location(LocationManager.GPS_PROVIDER);
newLocation.setLatitude (/* TODO: Set Some Lat */);
newLocation.setLongitude(/* TODO: Set Some Lng */);
newLocation.setAccuracy(500);
mLocationManager.setTestProviderEnabled
(
LocationManager.GPS_PROVIDER,
true
);
mLocationManager.setTestProviderStatus
(
LocationManager.GPS_PROVIDER,
LocationProvider.AVAILABLE,
null,
System.currentTimeMillis()
);
mLocationManager.setTestProviderLocation
(
LocationManager.GPS_PROVIDER,
newLocation
);
}
Ce que Dr1Ku a publié fonctionne. Utilisé le code aujourd'hui mais il fallait ajouter plus de locus ..__ Alors voici quelques améliorations:
Facultatif: Au lieu d'utiliser la chaîne LocationManager.GPS_PROVIDER, vous pouvez définir votre propre constat PROVIDER_NAME et l'utiliser. Lorsque vous vous enregistrez pour des mises à jour de localisation, choisissez un fournisseur via des critères plutôt que de le spécifier directement sous forme de chaîne.
Tout d'abord: au lieu d'appeler removeTestProvider, vérifiez d'abord s'il y a un fournisseur à supprimer (pour éviter IllegalArgumentException):
if (mLocationManager.getProvider(PROVIDER_NAME) != null) {
mLocationManager.removeTestProvider(PROVIDER_NAME);
}
Deuxièmement: pour publier plusieurs emplacements, vous devez définir l'heure de l'emplacement:
newLocation.setTime(System.currentTimeMillis());
...
mLocationManager.setTestProviderLocation(PROVIDER_NAME, newLocation);
Un test Google utilisant MockLocationProviders semble également exister: http://grepcode.com/file/repository.grepcode.com/Java/ext/com.google.Android/android/1.5_r4/Android/location/LocationManagerProximityTest .Java
Un autre bon exemple de travail peut être trouvé à: http://pedroassuncao.com/blog/2009/11/12/Android-location-provider-mock/
Un autre bon article est: http://ballardhack.wordpress.com/2010/09/23/location-gps-and-automated-testing-on-Android/#comment-1358 Vous aurez également Trouvez du code qui fonctionne réellement pour moi sur l'émulateur.
Il existe des applications disponibles sur l'Android Market qui vous permettent de spécifier une "position GPS fictive" pour votre appareil.
J'ai cherché https://market.Android.com et trouvé une application appelée "My Fake Location" qui fonctionne pour moi.
Le fournisseur fictif GPS mentionné par Paul ci-dessus (à http://www.cowlumbus.nl/forum/MockGpsProvider.Zip ) est un autre exemple qui inclut le code source - bien que je n’ai pas pu installer le fichier APK fourni. (il indique Failure [INSTALL_FAILED_OLDER_SDK] et peut simplement nécessiter une recompilation)
Pour pouvoir utiliser des emplacements fictifs GPS, vous devez l'activer dans les paramètres de votre appareil . Accédez à Paramètres -> Applications -> Développement et cochez la case "Autoriser les emplacements fictifs".
Vous pouvez ensuite utiliser une application telle que celles décrites ci-dessus pour définir les coordonnées GPS. Google Maps et d'autres applications utiliseront la fausse position GPS que vous spécifiez.
Cela a fonctionné pour moi (Android Studio):
Désactiver le suivi GPS et WiFi sur le téléphone. Sous Android 5.1.1 et inférieur, sélectionnez "activer les emplacements fictifs" dans les options pour les développeurs.
Faites une copie de votre manifeste dans le répertoire src/debug. Ajoutez ce qui suit (en dehors de la balise "application"):
uses-permission Android: name = "Android.permission.ACCESS_MOCK_LOCATION"
Mettre en place un fragment de carte appelé "carte". Incluez le code suivant dans onCreate ():
lm = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
ll = new MyLocationListener();
if (lm.getProvider("Test") == null) {
lm.addTestProvider("Test", false, false, false, false, false, false, false, 0, 1);
}
lm.setTestProviderEnabled("Test", true);
lm.requestLocationUpdates("Test", 0, 0, ll);
map.setOnMapClickListener(new GoogleMap.OnMapClickListener() {
@Override
public void onMapClick(LatLng l) {
Location loc = new Location("Test");
loc.setLatitude(l.latitude);
loc.setLongitude(l.longitude);
loc.setAltitude(0);
loc.setAccuracy(10f);
loc.setElapsedRealtimeNanos(System.nanoTime());
loc.setTime(System.currentTimeMillis());
lm.setTestProviderLocation("Test", loc);
}
};
Notez que vous devrez peut-être augmenter temporairement "minSdkVersion" dans votre fichier de gradateur de module à 17 pour pouvoir utiliser la méthode "setElapsedRealtimeNanos".
Incluez le code suivant dans la classe d'activité principale:
private class MyLocationListener implements LocationListener {
@Override
public void onLocationChanged(Location location) {
// do whatever you want, scroll the map, etc.
}
}
Exécutez votre application avec AS. Sur Android 6.0 et supérieur, vous obtiendrez une exception de sécurité. Maintenant, allez dans Options du développeur dans les paramètres et sélectionnez "Choisir une application de localisation factice". Sélectionnez votre application dans la liste.
Maintenant, lorsque vous appuyez sur la carte, onLocationChanged () se déclenchera avec les coordonnées de votre robinet.
Je viens de comprendre cela alors maintenant je n'ai pas à arpenter le quartier avec les téléphones à la main.
J'ai créé un gestionnaire simple simulant une position en mouvement à partir d'une position initiale.
Lancez-le dans votre rappel de connexion:
private final GoogleApiClient.ConnectionCallbacks mConnectionCallbacks = new GoogleApiClient.ConnectionCallbacks() {
@Override
public void onConnected(Bundle bundle) {
if (BuildConfig.USE_MOCK_LOCATION) {
LocationServices.FusedLocationApi.setMockMode(mGoogleApiClient, true);
new MockLocationMovingHandler(mGoogleApiClient).start(48.873399, 2.342911);
}
}
@Override
public void onConnectionSuspended(int i) {
}
};
La classe Handler:
private static class MockLocationMovingHandler extends Handler {
private final static int SET_MOCK_LOCATION = 0x000001;
private final static double STEP_LATITUDE = -0.00005;
private final static double STEP_LONGITUDE = 0.00002;
private final static long FREQUENCY_MS = 1000;
private GoogleApiClient mGoogleApiClient;
private double mLatitude;
private double mLongitude;
public MockLocationMovingHandler(final GoogleApiClient googleApiClient) {
super(Looper.getMainLooper());
mGoogleApiClient = googleApiClient;
}
public void start(final double initLatitude, final double initLongitude) {
if (hasMessages(SET_MOCK_LOCATION)) {
removeMessages(SET_MOCK_LOCATION);
}
mLatitude = initLatitude;
mLongitude = initLongitude;
sendEmptyMessage(SET_MOCK_LOCATION);
}
public void stop() {
if (hasMessages(SET_MOCK_LOCATION)) {
removeMessages(SET_MOCK_LOCATION);
}
}
@Override
public void handleMessage(Message message) {
switch (message.what) {
case SET_MOCK_LOCATION:
Location location = new Location("network");
location.setLatitude(mLatitude);
location.setLongitude(mLongitude);
location.setTime(System.currentTimeMillis());
location.setAccuracy(3.0f);
location.setElapsedRealtimeNanos(System.nanoTime());
LocationServices.FusedLocationApi.setMockLocation(mGoogleApiClient, location);
mLatitude += STEP_LATITUDE;
mLongitude += STEP_LONGITUDE;
sendEmptyMessageDelayed(SET_MOCK_LOCATION, FREQUENCY_MS);
break;
}
}
}
J'espère que ça peut aider ..
La solution mentionnée par icyerasor et fournie par Pedro sur http://pedroassuncao.com/blog/2009/11/12/Android-location-provider-mock/ a très bien fonctionné pour moi. Cependant, il n’offre pas d’assistance pour démarrer, arrêter et redémarrer correctement le faux fournisseur de GPS.
J'ai un peu modifié son code et réécrit la classe pour qu’elle soit une AsyncTask au lieu d’un Thread. Cela nous permet de communiquer avec le thread d'interface utilisateur afin de pouvoir redémarrer le fournisseur à l'endroit où nous nous trouvions lorsque nous l'avons arrêté. Cela est pratique lorsque l'orientation de l'écran change.
Le code, ainsi qu'un exemple de projet pour Eclipse, peut être trouvé sur GitHub: https://github.com/paulhoux/Android-MockProviderGPS
Tout le mérite devrait aller à Pedro pour la majeure partie du travail acharné.
La fausse application GPS de Google Play a fait l'affaire pour moi. Assurez-vous simplement de lire toutes les instructions dans la description de l'application. Vous devez désactiver les autres services de localisation et lancer votre application après avoir activé "Fake GPS". Travaillait très bien pour ce dont j'avais besoin.
Voici le lien vers l'application sur GooglePlay: Fake GPS
Vous trouverez le didacticiel de Google à cet effet ici. Il fournit des exemples de code et explique le processus.
http://developer.Android.com/training/location/location-testing.html#SendMockLocations
Si votre appareil est branché sur votre ordinateur et que vous essayez d’en changer, envoyez des cordons GPS via la commande Emulator, cela ne fonctionnera pas.
.__ Ceci est une commande EMULATOR pour une raison.
Il suffit de le configurer pour vous mettre à jour sur le changement de GPS.
lm = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
ll = new LocationListener() {
public void onLocationChanged(Location location) {
// Called when a new location is found by the network location provider.
onGPSLocationChanged(location);
}
public void onStatusChanged(String provider, int status, Bundle extras) {
bigInfo.setText("Changed "+ status);
}
public void onProviderEnabled(String provider) {
bigInfo.setText("Enabled "+ provider);
}
public void onProviderDisabled(String provider) {
bigInfo.setText("Disabled "+ provider);
}
};
Lorsque le GPS est mis à jour, réécrivez la méthode suivante pour faire ce que vous voulez.
public void onGPSLocationChanged(Location location){
if(location != null){
double pLong = location.getLongitude();
double pLat = location.getLatitude();
textLat.setText(Double.toString(pLat));
textLong.setText(Double.toString(pLong));
if(autoSave){
saveGPS();
}
}
}
N'oubliez pas de les mettre dans le manifeste
Android.permission.ACCESS_FINE_LOCATION
Android.permission.ACCESS_MOCK_LOCATION
Ce n’est peut-être pas une approche de type "programmeur", mais si vous voulez gagner du temps et obtenir une solution opérationnelle sur-le-champ, essayez l'une des applications dédiées à la localisation factice disponibles dans Google Play:
Installez Fausse application GPS https://play.google.com/store/apps/details?id=com.incorporateapps.fakegps.fre&hl=fr
Options du développeur -> _ {Sélectionnez une application de localisation fictive (C'est moyen, l'application de localisation fictive est sélectionnée).
Fake GPS app:
Double onglet sur la carte à ajouter -> cliquez sur le bouton de lecture -> Afficher le toast "Faux localisations stoppées"
enfin, vérifiez avec Google Maps applications.
Ajouter à votre manifeste
<uses-permission Android:name="Android.permission.ACCESS_MOCK_LOCATION"
tools:ignore="MockLocation,ProtectedPermissions" />
Fonction de localisation simulée
void setMockLocation() {
LocationManager locationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
locationManager.addTestProvider(LocationManager.GPS_PROVIDER, false, false,
false, false, true, true, true, 0, 5);
locationManager.setTestProviderEnabled(LocationManager.GPS_PROVIDER, true);
Location mockLocation = new Location(LocationManager.GPS_PROVIDER);
mockLocation.setLatitude(-33.852); // Sydney
mockLocation.setLongitude(151.211);
mockLocation.setAltitude(10);
mockLocation.setAccuracy(5);
mockLocation.setTime(System.currentTimeMillis());
mockLocation.setElapsedRealtimeNanos(System.nanoTime());
locationManager.setTestProviderLocation(LocationManager.GPS_PROVIDER, mockLocation);
}
Utiliser cette permission dans le fichier manifeste
<uses-permission Android:name="Android.permission.ACCESS_MOCK_LOCATION">
Le studio Android recommandera que "l'emplacement fictif ne soit demandé que dans un fichier manifeste spécifique au test ou au débogage (généralement src/debug/AndroidManifest.xml)" Simplement désactive l'inspection
Assurez-vous maintenant que vous avez coché la case " Autoriser les emplacements fictifs " dans les paramètres de développement de votre téléphone.
Utiliser LocationManager
locationManager.addTestProvider(mocLocationProvider, false, false,
false, false, true, true, true, 0, 5);
locationManager.setTestProviderEnabled(mocLocationProvider, true);
Maintenant, définissez l'emplacement où vous voulez
Location mockLocation = new Location(mocLocationProvider);
mockLocation.setLatitude(lat);
mockLocation.setLongitude(lng);
mockLocation.setAltitude(alt);
mockLocation.setTime(System.currentTimeMillis());
locationManager.setTestProviderLocation( mocLocationProvider, mockLocation);
J'ai écrit une application qui exécute un serveur Web (similaire à REST) sur votre téléphone Android, afin que vous puissiez définir la position GPS à distance. Le site Web fournit une carte sur laquelle vous pouvez cliquer pour définir une nouvelle position ou utiliser les touches "wasd" pour vous déplacer dans n'importe quelle direction. L'application étant une solution rapide, il n'y a pratiquement aucune interface utilisateur ni documentation, mais sa mise en œuvre est simple et vous pouvez tout rechercher dans les quatre classes seulement.
Référentiel de projet: https://github.com/juliusmh/RemoteGeoFix
Utilisez le simulateur de localisation interactif très pratique et gratuit pour téléphones et tablettes Android (nommé CATLES). Il simule l'emplacement GPS à l'échelle du système (même dans les applications Google Maps ou Facebook) et fonctionne aussi bien sur les appareils physiques que virtuels:
Je me demande si vous avez besoin de la configuration élaborée de l'emplacement fictif. Dans mon cas, une fois que j'ai trouvé un emplacement, j'appelais une fonction pour faire quelque chose avec ce nouvel emplacement. Dans une minuterie, créez un emplacement fictif. Et appelez la fonction avec cet emplacement à la place. Sachant que dans peu de temps, le GPS fournirait un emplacement actuel réel. Ce qui est OK Si le temps de mise à jour est suffisamment long.