Cómo configurar un temporizador en Android

¿Cuál es la forma correcta de configurar un temporizador en Android para iniciar una tarea (una función que creo que no cambia la interfaz de usuario)? Use esto de la manera Java: http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html

¿O hay una mejor manera en Android (controlador de Android)?

La forma estándar de Java de usar temporizadores a través de java.util.Timer y java.util.TimerTask funciona bien en Android, pero debe tener en cuenta que este método crea un nuevo hilo.

Puede considerar utilizar la clase Handler muy conveniente (android.os.Handler) y enviar mensajes al controlador a través de sendMessageAtTime(android.os.Message, long)o sendMessageDelayed(android.os.Message, long). Una vez que reciba un mensaje, puede ejecutar las tareas deseadas. La segunda opción sería crear un objeto Runnable y programarlo mediante las funciones de Handler postAtTime(java.lang.Runnable, long)o postDelayed(java.lang.Runnable, long).

Sí, se puede usar el temporizador de Java , pero como la pregunta pide una mejor manera (para dispositivos móviles). Lo cual se explica aquí .

Por el bien de StackOverflow:

Como Timer crea un nuevo hilo, puede considerarse pesado,

si todo lo que necesita es conseguir es una llamada de vuelta, mientras que la actividad se está ejecutando un manejador puede ser usado en conjunción con una

Ejecutable :

private final int interval = 1000; // 1 Second
private Handler handler = new Handler();
private Runnable runnable = new Runnable(){
    public void run() {
        Toast.makeText(MyActivity.this, "C'Mom no hands!", Toast.LENGTH_SHORT).show();
    }
};
...
handler.postAtTime(runnable, System.currentTimeMillis()+interval);
handler.postDelayed(runnable, interval);

o un mensaje

private final int EVENT1 = 1; 
private Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {         
        case Event1:
            Toast.makeText(MyActivity.this, "Event 1", Toast.LENGTH_SHORT).show();
            break;

        default:
            Toast.makeText(MyActivity.this, "Unhandled", Toast.LENGTH_SHORT).show();
            break;
        }
    }
};

...

Message msg = handler.obtainMessage(EVENT1);
handler.sendMessageAtTime(msg, System.currentTimeMillis()+interval);
handler.sendMessageDelayed(msg, interval);

en una nota al margen, este enfoque se puede usar, si desea ejecutar un fragmento de código en el hilo de la interfaz de usuario desde otro hilo.

si necesita que le devuelvan la llamada incluso si su actividad no se está ejecutando, puede usar un AlarmManager

Como lo he visto, java.util.Timer es el más utilizado para implementar un temporizador.

Para una tarea repetitiva:

new Timer().scheduleAtFixedRate(task, after, interval);

Para una sola ejecución de una tarea:

new Timer().schedule(task, after);

la tarea es el método que se ejecutará
después del tiempo de ejecución inicial
( intervalo del tiempo para repetir la ejecución)

Espero que esto sea útil y que requiera menos esfuerzo implementarlo, clase Android CountDownTimer

p.ej

 new CountDownTimer(30000, 1000) {
      public void onTick(long millisUntilFinished) {
          mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
      }

      public void onFinish() {
          mTextField.setText("done!");
      }  
}.start();

Probablemente Timerconcept

new CountDownTimer(40000, 1000) { //40000 milli seconds is total time, 1000 milli seconds is time interval

 public void onTick(long millisUntilFinished) {
  }
  public void onFinish() {
 }
}.start();

o

Método 2 ::

Programe el temporizador

Agregue una nueva variable de tiempo con nombre int. Configúrelo en 0. Agregue el siguiente código a la función onCreate en MainActivity.java.

//Declare the timer
Timer t = new Timer();
//Set the schedule function and rate
t.scheduleAtFixedRate(new TimerTask() {

    @Override
    public void run() {
        //Called each time when 1000 milliseconds (1 second) (the period parameter)
    }

},
//Set how long before to start calling the TimerTask (in milliseconds)
0,
//Set the amount of time between each execution (in milliseconds)
1000);

Ingrese al método de ejecución y agregue el siguiente código.

//We must use this function in order to change the text view text
runOnUiThread(new Runnable() {

    @Override
    public void run() {
        TextView tv = (TextView) findViewById(R.id.main_timer_text);
        tv.setText(String.valueOf(time));
        time += 1;
    }

});

Es situacional.

La documentación de Android sugiere que debe usar AlarmManager para registrar una Intención que se disparará a la hora especificada si su aplicación no se está ejecutando.

De lo contrario, debe usar Handler.

Nota: El Administrador de alarmas está destinado a casos en los que desea ejecutar el código de su aplicación en un momento específico, incluso si su aplicación no se está ejecutando actualmente. Para operaciones de temporización normales (ticks, tiempos de espera, etc.) es más fácil y mucho más eficiente usar Handler.

Aquí vamos. Necesitaremos dos clases. Estoy publicando un código que cambia el perfil de audio móvil después de cada 5 segundos (5000 mili segundos) ...

Nuestra 1ra clase

public class ChangeProfileActivityMain extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);

        Timer timer = new Timer();
        TimerTask updateProfile = new CustomTimerTask(ChangeProfileActivityMain.this);
        timer.scheduleAtFixedRate(updateProfile, 0, 5000);
    }

}

Nuestra 2da clase

public class CustomTimerTask extends TimerTask {

    private AudioManager audioManager;
    private Context context;
    private Handler mHandler = new Handler();

    // Write Custom Constructor to pass Context
    public CustomTimerTask(Context con) {
        this.context = con;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub

        // your code starts here.
        // I have used Thread and Handler as we can not show Toast without starting new thread when we are inside a thread.
        // As TimePicker has run() thread running., So We must show Toast through Handler.post in a new Thread. Thats how it works in Android..
        new Thread(new Runnable() {
            @Override
            public void run() {
                audioManager = (AudioManager) context.getApplicationContext().getSystemService(Context.AUDIO_SERVICE);
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        if(audioManager.getRingerMode() == AudioManager.RINGER_MODE_SILENT) {
                            audioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
                            Toast.makeText(context, "Ringer Mode set to Normal", Toast.LENGTH_SHORT).show();
                        } else {
                            audioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT);
                            Toast.makeText(context, "Ringer Mode set to Silent", Toast.LENGTH_SHORT).show();
                        }
                    }
                });
            }
        }).start();

    }

}

Soy un novato en Android, pero aquí está la clase de temporizador que creé en base a las respuestas anteriores. Funciona para mi aplicación, pero agradezco cualquier sugerencia.

Ejemplo de uso:

...{
public Handler uiHandler = new Handler();

  private Runnable runMethod = new Runnable()
    {
        public void run()
        {
              // do something
        }
    };

    timer = new UITimer(handler, runMethod, timeoutSeconds*1000);       
        timer.start();
}...

public class UITimer
{
    private Handler handler;
    private Runnable runMethod;
    private int intervalMs;
    private boolean enabled = false;
    private boolean oneTime = false;

    public UITimer(Handler handler, Runnable runMethod, int intervalMs)
    {
        this.handler = handler;
        this.runMethod = runMethod;
        this.intervalMs = intervalMs;
    }

    public UITimer(Handler handler, Runnable runMethod, int intervalMs, boolean oneTime)
    {
        this(handler, runMethod, intervalMs);
        this.oneTime = oneTime;
    }

    public void start()
    {
        if (enabled)
            return;

        if (intervalMs < 1)
        {
            Log.e("timer start", "Invalid interval:" + intervalMs);
            return;
        }

        enabled = true;
        handler.postDelayed(timer_tick, intervalMs);        
    }

    public void stop()
    {
        if (!enabled)
            return;

        enabled = false;
        handler.removeCallbacks(runMethod);
        handler.removeCallbacks(timer_tick);
    }

    public boolean isEnabled()
    {
        return enabled;
    }

    private Runnable timer_tick = new Runnable()
    {
        public void run()
        {
            if (!enabled)
                return;

            handler.post(runMethod);

            if (oneTime)
            {
                enabled = false;
                return;
            }

            handler.postDelayed(timer_tick, intervalMs);
        }
    }; 
}

Estoy usando un controlador y ejecutable para crear un temporizador. Envuelvo esto en una clase abstracta. Simplemente deríbalo / impleméntalo y listo:

 public static abstract class SimpleTimer {
    abstract void onTimer();

    private Runnable runnableCode = null;
    private Handler handler = new Handler();

    void startDelayed(final int intervalMS, int delayMS) {
        runnableCode = new Runnable() {
            @Override
            public void run() {
                handler.postDelayed(runnableCode, intervalMS);
                onTimer();
            }
        };
        handler.postDelayed(runnableCode, delayMS);
    }

    void start(final int intervalMS) {
        startDelayed(intervalMS, 0);
    }

    void stop() {
        handler.removeCallbacks(runnableCode);
    }
}

Tenga en cuenta que handler.postDelayedse llama antes del código que se ejecutará; esto hará que el temporizador esté más cerrado como "esperado". Sin embargo, en los casos en que el temporizador se ejecuta con frecuencia y la tarea ( onTimer()) es larga, puede haber superposiciones. Si desea comenzar a contar intervalMSdespués de que la tarea haya terminado, mueva la onTimer()llamada una línea arriba.

Creo que la forma de hacer esto en Android es que necesita un servicio en segundo plano para ejecutarse. En esa aplicación de fondo, cree el temporizador. Cuando el temporizador "marque" (establezca el intervalo de cuánto tiempo desea esperar), inicie la actividad que desea comenzar.

http://developer.android.com/guide/topics/fundamentals.html (<- este artículo explica la relación entre actividades, servicios, intenciones y otros fundamentos básicos del desarrollo de Android)

Solía ​​usar ( Timer, TimerTask) así como Handleriniciar tareas (que consumen mucho tiempo) periódicamente. Ahora he cambiado todo a RxJava. RxJava proporciona Observable.timercuál es más simple, menos propenso a errores y fácil de usar.

public class BetterTimerFragment extends Fragment {
  public static final String TAG = "BetterTimer";
  private TextView timeView;
  private Subscription timerSubscription;

  @Override
  public View onCreateView(LayoutInflater inflater,
                           @Nullable ViewGroup container,
                           @Nullable Bundle savedInstanceState) {
    return inflater.inflate(R.layout.fragment_timer, container, false);
  }

  @Override
  public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    timeView = (TextView) view.findViewById(R.id.timeView);
  }

  @Override
  public void onResume() {
    super.onResume();

    // Right after the app is visible to users, delay 2 seconds
    // then kick off a (heavy) task every 10 seconds.
    timerSubscription = Observable.timer(2, 10, TimeUnit.SECONDS)
        .map(new Func1<Long, String>() {
          @Override
          public String call(Long unused) {
            // TODO: Probably do time-consuming work here.
            // This runs on a different thread than the main thread.
            return "Time: " + System.currentTimeMillis();
          }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Action1<String>() {
          @Override
          public void call(String timeText) {
            // The result will then be propagated back to the main thread.
            timeView.setText(timeText);
          }
        }, new Action1<Throwable>() {
          @Override
          public void call(Throwable throwable) {
            Log.e(TAG, throwable.getMessage(), throwable);
          }
        });
  }

  @Override
  public void onPause() {
    super.onPause();

    // Don't kick off tasks when the app gets invisible.
    timerSubscription.unsubscribe();
  }
}

Para la operación de temporización, debe usar Handler .

Si necesita ejecutar un servicio en segundo plano, AlarmManager es el camino a seguir.

este ejemplo inicia la unidad de temporizador destruida en Kotlin

private lateinit var timerTask: TimerTask

 timerTask = object : TimerTask() {
        override fun run() {
            Log.d("KTZ", "$minutes:$seconds");
            timeRecordingLiveData.postValue("$minutes:$seconds")
            seconds += 1;
            if (seconds == 60) {
                Log.d("KTZ", "$minutes:$seconds");
                timeRecordingLiveData.postValue("$minutes:$seconds")
                seconds = 0;
                minutes += 1;
            }
        }

    }

Cancele el horario en onDestroy ()

timerTask.cancel()