Cómo agotar la adquisición de señal GPS

Question

Mi aplicación utiliza el LocationListener para obtener una posición fija y luego removeUpdates() una vez por minuto (para conservar la batería). El problema es que si un usuario se mueve dentro, buscará una señal perpetuamente, quemando más batería. Me preguntaba si alguien sabe de un método público en el Administrador de ubicaciones que puedo usar para eliminar Actualizaciones si una señal no se adquiere en 15 segundos. Luego verificaría una posición fija cada cinco minutos hasta que el usuario vuelva a salir al aire libre. ¿Esto tiene sentido? ¿Tal vez hay un método mejor para agotar el tiempo de adquisición de la señal GPS? Revisé los métodos públicos de Location Manager, pero parece que no puedo encontrar la forma de hacerlo. ¡Muchas gracias por su ayuda! -Dom

Answer 1

Aunque la respuesta de GPSmaster se acepta, quiero enviar el enlace a más elegante y la solución más simple, Creo que - https://gist.github.com/777790/86b405debd6e3915bfcd8885c2ee11db2b96e3df. He probado a mí mismo y funcionó =)

En caso de que el enlace no funciona, esto es una costumbre LocationListener por amay077:

/** 
* Initialize instance. 
* 
* @param locaMan the base of LocationManager, can't set null. 
* @param timeOutMS timeout elapsed (mili seconds) 
* @param timeoutListener if timeout, call onTimeouted method of this. 
*/ 
public TimeoutableLocationListener(LocationManager locaMan, long timeOutMS, 
     final TimeoutLisener timeoutListener) { 
    this.locaMan = locaMan; 
    timerTimeout.schedule(new TimerTask() { 

     @Override 
     public void run() { 
      if (timeoutListener != null) { 
       timeoutListener.onTimeouted(TimeoutableLocationListener.this); 
      } 
      stopLocationUpdateAndTimer(); 
     } 
    }, timeOutMS); 
} 

/*** 
* Location callback. 
* 
* If override on your concrete class, must call base.onLocation(). 
*/ 
@Override 
public void onLocationChanged(Location location) { 
    stopLocationUpdateAndTimer(); 
} 

@Override 
public void onProviderDisabled(String s) { } 

@Override 
public void onProviderEnabled(String s) { } 

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

private void stopLocationUpdateAndTimer() { 
    locaMan.removeUpdates(this); 

    timerTimeout.cancel(); 
    timerTimeout.purge(); 
    timerTimeout = null; 
} 

public interface TimeoutLisener { 
    void onTimeouted(LocationListener sender); 
} 

Answer 2

Así que esto es lo que terminé haciendo.

Esto es lo que he añadido a la nota LocationListener las variables globales y timertest loccounter:

public class MyLocationListener implements LocationListener 

{ 
    public void onStart() { 
     if (timertest==false) { 
      timertest=true; 
      serviceHandler = new Handler(); 
      serviceHandler.postDelayed(new timer(),1000L); 
     } 
    } 
    class timer implements Runnable { 
      public void run() { 
      ++loccounter; 
      if (runtest==true && loccounter>8) { 
       dt=200; 
       runtest=false; 
       stoplistening(); 
      } else serviceHandler.postDelayed(this, 1000L); 
      } 
    } 
} 

Me marcha el temporizador de la derecha antes de solicitar actualizaciones de ubicación.

public void locupdate(int minTime, float minDistance) { 
    mlocManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE); 
    mlocListener = new MyLocationListener(); 
    if (mlocListener != null && mlocManager != null) { 
     mlocManager.removeUpdates(mlocListener); 
    } 
    loccounter=0; 
    ((MyLocationListener) mlocListener).onStart(); 
    runtest=true; 
    mlocManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 
       minTime, minDistance, mlocListener); 
} 

y un último método dentro del oyente ubicación:

public void stoplistening() { 
     mlocManager.removeUpdates(mlocListener); 
     loccounter=0; 
    } 

Espero que esto ayude a alguien

Answer 3

Bueno, mi solución a este problema es algo muy simple y no sé si es una buena práctica. Supongamos que tenemos un llamado longtimeToQuit que determina la cantidad de Millis quieres esperar antes de abortar la búsqueda de una posición sólo hay que poner:

locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 
           2000, 0, locationListener); 
Handler handler = new Handler(); // android.os.Handler 
Runnable runnable = new Runnable() { 
    @Override 
    public void run() { 
     locationManager.removeUpdates(locationListener); 
    } 
}; 
handler.postDelayed(runnable, timeToQuit); 

Por supuesto, usted tiene que tener un LocationListener y su propia LocationListener. Valores en locationManager.requestLocationUpdates son de mi aplicación por lo que debes adaptarlos. Este código funciona como un encanto para mí. Sé que llegué un poco tarde, pero no pude encontrar este enfoque por ningún lado y, de manera muy provechosa, ayuda a alguien. Cheers