Comment puis-je vérifier l'état actuel du récepteur GPS?

Comment puis-je vérifier l'état actuel du récepteur GPS? J'ai déjà vérifié la LocationListener onStatusChangedméthode mais il semble que cela ne fonctionne pas, ou tout simplement la mauvaise possibilité.

En gros, j'ai juste besoin de savoir si l'icône GPS en haut de l'écran clignote (pas de correctif réel) ou fixe (le correctif est disponible).

En tant que développeur de SpeedView: compteur de vitesse GPS pour Android, j'ai dû essayer toutes les solutions possibles à ce problème, toutes avec le même résultat négatif. Répétons ce qui ne fonctionne pas:

1. onStatusChanged () n'est pas appelé sur Eclair et Froyo.
2. Il est bien entendu inutile de simplement compter tous les satellites disponibles.
3. Vérifier si l'un des satellites retourne vrai pour usedInFix () n'est pas très utile également. Le système perd clairement le correctif mais continue de signaler qu'il y a encore plusieurs sats qui y sont utilisés.

Voici donc la seule solution fonctionnelle que j'ai trouvée, et celle que j'utilise réellement dans mon application. Disons que nous avons cette classe simple qui implémente le GpsStatus.Listener:

private class MyGPSListener implements GpsStatus.Listener {
    public void onGpsStatusChanged(int event) {
        switch (event) {
            case GpsStatus.GPS_EVENT_SATELLITE_STATUS:
                if (mLastLocation != null)
                    isGPSFix = (SystemClock.elapsedRealtime() - mLastLocationMillis) < 3000;

                if (isGPSFix) { // A fix has been acquired.
                    // Do something.
                } else { // The fix has been lost.
                    // Do something.
                }

                break;
            case GpsStatus.GPS_EVENT_FIRST_FIX:
                // Do something.
                isGPSFix = true;

                break;
        }
    }
}

OK, maintenant dans onLocationChanged () nous ajoutons ce qui suit:

@Override
public void onLocationChanged(Location location) {
    if (location == null) return;

    mLastLocationMillis = SystemClock.elapsedRealtime();

    // Do something.

    mLastLocation = location;
}

Et c'est tout. En gros, c'est la ligne qui fait tout:

isGPSFix = (SystemClock.elapsedRealtime() - mLastLocationMillis) < 3000;

Vous pouvez bien sûr modifier la valeur en millis, mais je suggérerais de la définir autour de 3-5 secondes.

Cela fonctionne réellement et bien que je n'ai pas regardé le code source qui dessine l'icône GPS native, cela est proche de reproduire son comportement. J'espère que cela aide quelqu'un.

L'icône GPS semble changer d'état en fonction des intentions de diffusion reçues. Vous pouvez modifier son état vous-même avec les exemples de code suivants:

Avertissez que le GPS a été activé:

Intent intent = new Intent("android.location.GPS_ENABLED_CHANGE");
intent.putExtra("enabled", true);
sendBroadcast(intent);

Avertissez que le GPS reçoit des correctifs:

Intent intent = new Intent("android.location.GPS_FIX_CHANGE");
intent.putExtra("enabled", true);
sendBroadcast(intent);

Avertissez que le GPS ne reçoit plus de correctifs:

Intent intent = new Intent("android.location.GPS_FIX_CHANGE");
intent.putExtra("enabled", false);
sendBroadcast(intent);

Avertissez que le GPS a été désactivé:

Intent intent = new Intent("android.location.GPS_ENABLED_CHANGE");
intent.putExtra("enabled", false);
sendBroadcast(intent);

Exemple de code pour enregistrer le récepteur selon les intentions:

// MyReceiver must extend BroadcastReceiver
MyReceiver receiver = new MyReceiver();
IntentFilter filter = new IntentFilter("android.location.GPS_ENABLED_CHANGE");
filter.addAction("android.location.GPS_FIX_CHANGE");
registerReceiver(receiver, filter);

En recevant ces intentions de diffusion, vous pouvez remarquer les changements d'état du GPS. Cependant, vous ne serez averti que lorsque l'état change. Il n'est donc pas possible de déterminer l'état actuel à l'aide de ces intentions.

nouveau membre donc malheureusement je suis incapable de commenter ou de voter, mais le message de Stephen Daye ci-dessus était la solution parfaite au même problème que j'ai cherché de l'aide.

une petite modification de la ligne suivante:

isGPSFix = (SystemClock.elapsedRealtime() - mLastLocationMillis) < 3000;

à:

isGPSFix = (SystemClock.elapsedRealtime() - mLastLocationMillis) < (GPS_UPDATE_INTERVAL * 2);

En gros, alors que je construis un jeu au rythme lent et que mon intervalle de mise à jour est déjà réglé à 5 secondes, une fois que le signal GPS est éteint pendant plus de 10 secondes, c'est le bon moment pour déclencher quelque chose.

salut mon pote, j'ai passé environ 10 heures à essayer de résoudre cette solution avant de trouver votre message :)

Ok, essayons donc une combinaison de toutes les réponses et mises à jour jusqu'à présent et faisons quelque chose comme ceci:

• Ajoutez l' ACCESS_FINE_LOCATIONautorisation à votre manifeste
• Obtenez une instance du système LocationManager
• Créez un GpsStatus.Listenerqui réagit àGPS_EVENT_SATELLITE_STATUS
• Enregistrer l'auditeur avec LocationManageravecaddGpsStatusListener

L'auditeur GPS pourrait être quelque chose comme ceci:

GpsStatus.Listener listener = new GpsStatus.Listener() {
    void onGpsStatusChanged(int event) {
        if (event == GPS_EVENT_SATELLITE_STATUS) {
            GpsStatus status = mLocManager.getGpsStatus(null);
            Iterable<GpsSatellite> sats = status.getSatellites();
            // Check number of satellites in list to determine fix state
        }
    }
}

Les API sont un peu floues sur le moment et la nature des informations GPS et satellite fournies, mais je pense qu'une idée serait de regarder combien de satellites sont disponibles. S'il est inférieur à trois, vous ne pouvez pas avoir de solution. Si c'est plus, vous devriez avoir une solution.

Les essais et erreurs sont probablement le moyen de déterminer la fréquence à laquelle Android rapporte les informations satellite et les informations que chaque GpsSatelliteobjet contient.

Après quelques années de travail avec le GPS sur Windows Mobile, j'ai réalisé que le concept de «perdre» un repère GPS pouvait être subjectif. Pour simplement écouter ce que le GPS vous dit, l'ajout d'un NMEAListener et l'analyse de la phrase vous diront si le correctif était "valide" ou non. Voir http://www.gpsinformation.org/dale/nmea.htm#GGA . Malheureusement, avec certains GPS, cette valeur fluctuera d'avant en arrière même pendant le cours normal du fonctionnement dans une zone de «bonne position».

Donc, l'autre solution consiste à comparer l'heure UTC de la position GPS avec l'heure du téléphone (convertie en UTC). S'ils sont séparés par un certain décalage horaire, vous pouvez supposer que vous avez perdu la position GPS.

entrer dans un problème similaire en travaillant sur mon projet MSc, il semble que la réponse de Daye a signalé par erreur "pas de solution" alors que l'appareil reste dans un emplacement statique. J'ai un peu modifié la solution, ce qui semble bien fonctionner pour moi dans un emplacement statique. Je ne sais pas comment cela affecterait la batterie car ce n'est pas ma principale préoccupation, mais voici comment je l'ai fait en redemandant les mises à jour de l'emplacement lorsqu'un correctif a expiré.

private class MyGPSListener implements GpsStatus.Listener {
    public void onGpsStatusChanged(int event) {
        switch (event) {
        case GpsStatus.GPS_EVENT_SATELLITE_STATUS:
            if (Global.getInstance().currentGPSLocation != null)
            {
                if((SystemClock.elapsedRealtime() - mLastLocationMillis) < 20000)
                {
                    if (!hasGPSFix) 
                        Log.i("GPS","Fix Acquired");
                    hasGPSFix = true;
                } 
                else
                {
                    if (hasGPSFix) 
                    {
                        Log.i("GPS","Fix Lost (expired)");
                        lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 10, locationListener);
                    }
                    hasGPSFix = false;
                }
            }
            break;
        case GpsStatus.GPS_EVENT_FIRST_FIX:
            Log.i("GPS", "First Fix/ Refix");
            hasGPSFix = true;
            break;
        case GpsStatus.GPS_EVENT_STARTED:
            Log.i("GPS", "Started!");
            break;
        case GpsStatus.GPS_EVENT_STOPPED:
            Log.i("GPS", "Stopped");
            break;
        }
    }
}

Eh bien, la mise en place de chaque approche de travail entraînera ceci (traitant également des obsolètes GpsStatus.Listener):

private GnssStatus.Callback mGnssStatusCallback;
@Deprecated private GpsStatus.Listener mStatusListener;
private LocationManager mLocationManager;

@Override
public void onCreate() {
    mLocationManager = (LocationManager) getSystemService(LOCATION_SERVICE);

    mLocationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
    if (checkPermission()) {
       mLocationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, GPS_UPDATE_INTERVAL, MIN_DISTANCE, this);
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        mGnssStatusCallback = new GnssStatus.Callback() {
            @Override
            public void onSatelliteStatusChanged(GnssStatus status) {
                satelliteStatusChanged();
            }

            @Override
            public void onFirstFix(int ttffMillis) {
                gpsFixAcquired();

            }
        };
        mLocationManager.registerGnssStatusCallback(mGnssStatusCallback);
    } else {
        mStatusListener = new GpsStatus.Listener() {
            @Override
            public void onGpsStatusChanged(int event) {
                switch (event) {
                    case GpsStatus.GPS_EVENT_SATELLITE_STATUS:
                        satelliteStatusChanged();
                        break;
                    case GpsStatus.GPS_EVENT_FIRST_FIX:
                        // Do something.
                        gpsFixAcquired();
                        break;
                }
            }
        };
        mLocationManager.addGpsStatusListener(mStatusListener);
    }
}

private void gpsFixAcquired() {
    // Do something.
    isGPSFix = true;
}

private void satelliteStatusChanged() {
    if (mLastLocation != null)
        isGPSFix = (SystemClock.elapsedRealtime() - mLastLocationMillis) < (GPS_UPDATE_INTERVAL * 2);

    if (isGPSFix) { // A fix has been acquired.
        // Do something.
    } else { // The fix has been lost.
        // Do something.
    }
}

@Override
public void onLocationChanged(Location location) {
    if (location == null) return;

    mLastLocationMillis = SystemClock.elapsedRealtime();

    mLastLocation = location;
}

@Override
public void onStatusChanged(String s, int i, Bundle bundle) {

}

@Override
public void onProviderEnabled(String s) {

}

@Override
public void onProviderDisabled(String s) {

}

Remarque: cette réponse est une combinaison des réponses ci-dessus.

Si vous avez juste besoin de savoir s'il existe un correctif, vérifiez le dernier emplacement connu fourni par le récepteur GPS et vérifiez la valeur .getTime () pour savoir quel âge a-t-il. Si c'est assez récent (comme ... quelques secondes), vous avez une solution.

   LocationManager lm = (LocationManager)context.getSystemService(LOCATION_SERVICE); 
   Location loc = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);

   // Get the time of the last fix
   long lastFixTimeMillis = loc.getTime(); 

... et enfin comparez cela à l'heure actuelle (en UTC!). Si c'est assez récent, vous avez un correctif.

Je fais cela dans mon application et jusqu'à présent tout va bien.

Vous pouvez essayer d'utiliser LocationManager.addGpsStatusListener pour être mis à jour lorsque l'état du GPS change. Il semble que GPS_EVENT_STARTED et GPS_EVENT_STOPPED soient peut-être ce que vous recherchez.

Je me trompe peut-être, mais il semble que les gens semblent s'éloigner du sujet

j'ai juste besoin de savoir si l'icône gps en haut de l'écran clignote (pas de solution réelle)

Cela se fait facilement avec

LocationManager lm = (LocationManager) getSystemService(LOCATION_SERVICE);
boolean gps_on = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);

Pour voir si vous avez une solution solide, les choses deviennent un peu plus délicates:

public class whatever extends Activity {
    LocationManager lm;
    Location loc;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);        
        lm = (LocationManager) getSystemService(LOCATION_SERVICE);
        loc = null;
        request_updates();        
    }

    private void request_updates() {
        if (lm.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
            // GPS is enabled on device so lets add a loopback for this locationmanager
            lm.requestLocationUpdates(LocationManager.GPS_PROVIDER,0, 0, locationListener);
        }      
    }

    LocationListener locationListener = new LocationListener() {
        public void onLocationChanged(Location location) {
            // Each time the location is changed we assign loc
            loc = location;
        }

         // Need these even if they do nothing. Can't remember why.
         public void onProviderDisabled(String arg0) {}
         public void onProviderEnabled(String provider) {}
         public void onStatusChanged(String provider, int status, Bundle extras) {}
    };

Maintenant, chaque fois que vous voulez voir si vous avez un correctif?

if (loc != null){
    // Our location has changed at least once
    blah.....
}

Si vous voulez être sophistiqué, vous pouvez toujours avoir un délai d'attente en utilisant System.currentTimeMillis () et loc.getTime ()

Fonctionne de manière fiable, au moins sur un N1 depuis la version 2.1.

Avec LocationManager, vous pouvez obtenirLastKnownLocation () après avoir obtenuBestProvider (). Cela vous donne un objet Location, qui a les méthodes getAccuracy () en mètres et getTime () en millisecondes UTC

Cela vous donne-t-il suffisamment d'informations?

Ou peut-être pourriez-vous parcourir les LocationProviders et découvrir si chacun répond aux critères (ACCURACY_COARSE)

tant de messages ...

GpsStatus.Listener gpsListener = new GpsStatus.Listener() {
                        public void onGpsStatusChanged(int event) {
                            if( event == GpsStatus.GPS_EVENT_FIRST_FIX){
                                showMessageDialog("GPS fixed");
                            }
                        }
                 };

l'ajout de ce code, avec addGpsListener ... showMessageDialog ... affiche simplement une fenêtre de dialogue standard avec la chaîne

a parfaitement fait le travail pour moi :) merci beaucoup: =) (sry pour ce message, pas encore en mesure de voter)

Si vous n'avez pas besoin d'une mise à jour au moment même où le correctif est perdu, vous pouvez modifier la solution de Stephen Daye de cette manière, que vous disposez d'une méthode qui vérifie si le correctif est toujours présent.

Ainsi, vous pouvez simplement le vérifier chaque fois que vous avez besoin de données GPS et que vous n'avez pas besoin de GpsStatus.Listener.

Les variables "globales" sont:

private Location lastKnownLocation;
private long lastKnownLocationTimeMillis = 0;
private boolean isGpsFix = false;

C'est la méthode qui est appelée dans "onLocationChanged ()" pour se souvenir de l'heure de mise à jour et de l'emplacement actuel. À côté de cela, il met à jour "isGpsFix":

private void handlePositionResults(Location location) {
        if(location == null) return;

        lastKnownLocation = location;
        lastKnownLocationTimeMillis = SystemClock.elapsedRealtime();

        checkGpsFix(); // optional
    }

Cette méthode est appelée chaque fois que j'ai besoin de savoir s'il existe un repère GPS:

private boolean checkGpsFix(){

    if (SystemClock.elapsedRealtime() - lastKnownLocationTimeMillis < 3000) {
        isGpsFix = true;

    } else {
        isGpsFix = false;
        lastKnownLocation = null;
    }
    return isGpsFix;
}

Dans mon implémentation, je lance d'abord checkGpsFix () et si le résultat est vrai, j'utilise la variable "lastKnownLocation" comme position actuelle.

Je sais que c'est un peu tard. Cependant, pourquoi ne pas utiliser le NMEAListener si vous voulez savoir si vous avez un correctif. D'après ce que j'ai lu, le NMEAListener vous donnera les phrases NMEA et à partir de là, vous choisirez la phrase correcte.

La phrase RMC contient l'état du correctif qui est soit A pour OK ou V pour avertissement. La phrase GGA contient la qualité de correction (0 invalide, 1 GPS ou 2 DGPS)

Je ne peux pas vous proposer de code java car je ne fais que commencer avec Android, mais j'ai créé une bibliothèque GPS en C # pour les applications Windows, que je souhaite utiliser avec Xamarin. Je suis tombé sur ce fil uniquement parce que je cherchais des informations sur les fournisseurs.

D'après ce que j'ai lu jusqu'à présent sur l'objet Location, je ne suis pas très à l'aise avec les méthodes comme getAccuracy () et hasAccuracy (). J'ai l'habitude d'extraire des phrases NMEA les valeurs HDOP et VDOP pour déterminer la précision de mes correctifs. Il est assez courant d'avoir un correctif, mais un HDOP médiocre, ce qui signifie que votre précision horizontale n'est pas du tout bonne. Par exemple, assis à votre bureau en train de déboguer avec un périphérique GPS Bluetooth externe contre une fenêtre, vous aurez probablement une solution, mais HDOP et VDOP très médiocres. Placez votre appareil GPS dans un pot de fleurs à l'extérieur ou quelque chose de similaire ou ajoutez une antenne externe au GPS et vous obtenez immédiatement de bonnes valeurs HDOP et VDOP.

C'est peut-être la meilleure possibilité de créer une TimerTask qui définit régulièrement l'emplacement reçu à une certaine valeur (nulle?). Si une nouvelle valeur est reçue par le GPSListener, il mettra à jour l'emplacement avec les données actuelles.

Je pense que ce serait une solution efficace.

Vous dites que vous avez déjà essayé onStatusChanged (), mais cela fonctionne pour moi.

Voici la méthode que j'utilise (je laisse la classe elle-même gérer le onStatusChanged):

private void startLocationTracking() {
    final int updateTime = 2000; // ms
    final int updateDistance = 10; // meter
    final Criteria criteria = new Criteria();
    criteria.setCostAllowed(false);
    criteria.setAccuracy(Criteria.ACCURACY_FINE);
    final String p = locationManager.getBestProvider(criteria, true);
    locationManager.requestLocationUpdates(p, updateTime, updateDistance,
            this);
}

Et je gère le onStatusChanged comme suit:

void onStatusChanged(final String provider, final int status,
        final Bundle extras) {
    switch (status) {
    case LocationProvider.OUT_OF_SERVICE:
        if (location == null || location.getProvider().equals(provider)) {
            statusString = "No Service";
            location = null;
        }
        break;
    case LocationProvider.TEMPORARILY_UNAVAILABLE:
        if (location == null || location.getProvider().equals(provider)) {
            statusString = "no fix";
        }
        break;
    case LocationProvider.AVAILABLE:
        statusString = "fix";
        break;
    }
}

Notez que les méthodes onProvider {Dis, En} abled () concernent l'activation et la désactivation du suivi GPS par l'utilisateur; pas ce que vous recherchez.

Définir un intervalle de temps pour vérifier le correctif n'est pas un bon choix .. j'ai remarqué que onLocationChanged n'est pas appelé si vous ne bougez pas .. ce qui est compréhensible puisque l'emplacement ne change pas :)

La meilleure façon serait par exemple:

• vérifier l'intervalle jusqu'au dernier emplacement reçu (en gpsStatusChanged)
• si cet intervalle est supérieur à 15 s, définissez la variable: long_interval = true
• supprimez l'écouteur d'emplacement et ajoutez-le à nouveau, généralement vous obtenez la position mise à jour si l'emplacement est vraiment disponible, sinon - vous avez probablement perdu l'emplacement
• dans onLocationChanged, vous venez de définir long_interval sur false ..