Home / Questions / 224549
Accepted
Bruno Sosa Fast Tag
Asked: 2020-12-20 12:21:06 +0800 CST 2020-12-20 12:21:06 +0800 CST

Unstable CountDownTimer depending on Android version / Battery Saving

  • 772

Currently I need my application to perform an action after 5 minutes, in my case close the session, in my emulators and my physical phone is 10 but on some phones it does not work, I am not sure if the battery saving could make it not count time with CountDownTimer or that could make the time not decrease, I need the time to count even if the screen is locked or in the background I currently use

public class MyCountDownTimer extends CountDownTimer {
    Context context = null;
    public MyCountDownTimer(long startTime, long interval,Context context) {
        super(startTime, interval);
        this.context = context;
    }
    @Override
    public void onTick(long millisUntilFinished) {

    }
    @Override
    public void onFinish() {

        Intent intent = new Intent(context, Login.class);

        Toast.makeText(context, context.getString(R.string.SessionExpirada),Toast.LENGTH_LONG).show();
        context.startActivity(intent);
    }
}

Then I have another method that restarts when the person interacts

@Override
public void onUserInteraction(){
    super.onUserInteraction();
   if(!Globals.getContadorSalidaON()){
       countDownTimer.cancel();
       countDownTimer.start();
   }
}

For what this works for me in some and in others it simply does not work, I could use another component that meets my requirements or I could fix the CountDownTimer so that it always works even in the background and in battery saving

java

1 Answers

  1. Best Answer

    @Juan it's locally, and I use a timer because I just want to measure times

    This answer does not answer how to implement a timer that triggers a logoff, but rather how to "close" a local session by measuring the elapsed time and comparing it against a predefined limit.

    The solution is to store a value longwith the time returned for System.currentTimeMillis()each time the app is interacted with, and compare this value against the previous one to determine if more than the time limit has elapsed.

    The comparison is achieved by making the difference horaInteraccionActual - horaUltimaInteracción. The result of the difference is milliseconds so to take it to minutes you have to divide by 60000.

    To preserve the value of the last iteration we can persist it in SharedPreferences. This variable can be read in onResume()and stored in onPause().

    The solution is simple compared to alternatives that involve using a service with CountdownTimer, or using the AlarmManager. And from a practical point of view, what is obtained as a result is very similar: After a certain time has elapsed, the user cannot use the app without authenticating .

    The difference is that you cannot be notified of the logoff at the time (5 minutes in the question), and if any logoff work needs to be done, it is delayed until the next user interaction. (Although this is debatable since a solution with AlarmManager may be subject to delay as well.)

    The activity:

    public class TimedActivity extends AppCompatActivity {
    private static final String APP_PREFS = "AppPrefs";
    private static final String PRF_UMA_INTERACCION = "ultima_interaccion";
    private static final int TIEMPO_LIMITE_MINS = 5;
    private long ultimaInteraccion = -1;
    private SharedPreferences prefs = null;


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        prefs = getSharedPreferences(APP_PREFS, MODE_PRIVATE);
    }

    @Override
    protected void onResume() {
        super.onResume();
        ultimaInteraccion = prefs.getLong(PRF_UMA_INTERACCION, -1);
    }

    @Override
    protected void onPause() {
        SharedPreferences.Editor editor = prefs.edit();
        editor.putLong(PRF_UMA_INTERACCION, ultimaInteraccion);
        editor.commit();
        super.onPause();
    }

    /** Un ejemplo de interaccion **/
    public void unaInteraccion(){
        if(isSesionValida()){

            //Ejecutar interaccion

            interaccionConcretada();
        }else{
            cerrarSesion();
            pedirLogin();
        }
    }

    /**
     * Valida que se esté en la ventana de tiempo permitida para la sesión
     * @return true si se está en la ventana, y false si se está en la ventana o si no
     * hay una última interacción contra que comparar
     */
    private boolean isSesionValida(){
        boolean rtn;
        if(ultimaInteraccion == -1){
            rtn = false;
        }else {
            long horaActual = System.currentTimeMillis();
            int tiempoTranscurridoMins = (int) ((horaActual - ultimaInteraccion) / 60000);
            rtn = tiempoTranscurridoMins <= TIEMPO_LIMITE_MINS;
        }
        return rtn;
    }

    /**
     * Método de conveniencia para llamar cuando se quiere acutalizar la hora de la
     * última interacción. Presumiblemente, después de procesar la interacción actual.
     */
    private void interaccionConcretada(){
        ultimaInteraccion = System.currentTimeMillis();
    }

    private void cerrarSesion(){
        // Si el cierre de sesión requiere hacer algo más se puede hacer acá
    }


    private void pedirLogin(){
        boolean autenticado = false;

        // Pedir autenticación para abrir nuevamente una sesion.

        autenticado = <resultado de la autenticación>; // true si se autentica al usuario y false si no se autentica
        if(autenticado){
            interaccionConcretada();
            ...; //Ir a pantalla principal por ejemplo
        }
    }
}
    • 1