Android: requestLocationUpdates emplacement de mises à jour à la plupart des toutes les 45 secondes

Fond

Je suis en train d'écrire une application Android dont la fonction principale est le suivi de l'emplacement de l'utilisateur et en faisant une alerte lorsque l'utilisateur s'approche d'un certain point. Donc j'ai besoin de mettre à jour l'emplacement de l'utilisateur, à intervalles réguliers, et ces intervalles plus petits que l'utilisateur se rapproche de la cible. Ainsi, lorsque l'utilisateur est à l'intérieur, à 1 km de la cible, je veux l'emplacement pour être à jour toutes les 20 secondes et ainsi de suite, jusqu'à ce que l'utilisateur arrive.

Problème

Quand je l'ai tester (provider = LocationManager.NETWORK_PROVIDER), un appel à requestLocationUpdates(provider, minTime, minDistance, locationListener) avec tout minTime < 45000 a le même effet que minTime = 45000, c'est à dire-je obtenir les mises à jour, avec un intervalle de exactement 45 secondes.

Je sais que le temps minimum paramètre n'est qu'une "astuce", mais elle n'est pas prise comme un indice par mon application. Je reçois des mises à jour avec l'intervalle de temps spécifié jusqu'à ce que l'intervalle de passe en-dessous de 45 secondes. Il semble qu'un minimum de temps de 45 secondes entre l'emplacement des mises à jour est codé en dur dans Android, mais ce serait bizarre. En Plus je n'ai jamais entendu parler de ce problème avant, et je n'ai pas été capable de le trouver abordé ici sur Stackoverflow.

Parce que je ne suis pas en mesure d'obtenir des mises à jour fréquentes, ma solution (pour l'instant) est manuellement appel requestLocationUpdates chaque fois qu'un nouvel emplacement qui est nécessaire, puis il suffit d'utiliser la première position disponible. Pour ce faire, à de petits intervalles-je utiliser handler.postDelayed(myRunnable, updateInterval) pour retarder les appels, et myRunnable s'occupe ensuite de l'appeler requestLocationUpdates. Cependant, cette méthode ne fonctionne que sur 50 (apparemment aléatoire) pour cent du temps.

Quelqu'un connais le problème, et est-il un moyen de le réparer? Ou est ma seule option pour définir minTime = 0 et espérer pour le mieux?

Code Source

Voici le code source pour myRunnable, dont run() méthode que j'ai manuellement appel régulièrement avec handler.postDelayed(myRunnable, updateInterval):

public class MyRunnable implements Runnable {
    private LocationManager manager;
    private LocationListener listener;

    @Override
    public void run() {
        //This is called everytime a new update is requested
        //so that only one request is running at a time.
        removeUpdates();

        manager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

        listener = new LocationListener() {
            @Override
            public void onLocationChanged(Location loc) {
                location = loc;
                latitude = loc.getLatitude();
                longitude = loc.getLongitude();
                accuracy = Math.round(loc.getAccuracy());

                handler.sendMessage(Message.obtain(handler, KEY_MESSAGE_LOCATION_CHANGED));

                checkForArrival();
            }

            //Other overrides are empty.
        };

        if(!arrived)
            manager.requestLocationUpdates(provider, updateInterval, 0, listener);
    }

    /**
     * Removes location updates from the LocationListener.
     */
    public void removeUpdates() {
        if(!(manager == null || listener == null))
            manager.removeUpdates(listener);
    }

    //Another method for "cleaning up" when the user has arrived.
}

Et voici mon handler:

handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch(msg.what) {
            case KEY_MESSAGE_LOCATION_CHANGED:
                if(myRunnable != null) {
                    myRunnable.removeUpdates();
                    handler.postDelayed(myRunnable, updateInterval);
                }
                break;
            }
        }
    };

Informations supplémentaires

L'ensemble de l'emplacement de la mise à jour de chose s'exécute dans un service.

J'ai lu la doc plusieurs fois, Google avait le problème, et j'ai essayé diverses autres solutions de contournement. Rien de fait.

J'ai connecté la merde hors de cette chose, et la seule chose la plus intéressante à voir est un gros "ignorer" pour mes fréquentes demandes de localisation. Toutes les méthodes sont appelées.

Toute aide sera très apprécié!