Cómo configurar un temporizador en android

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

O hay una mejor manera en android (manejador de android)?

La forma estándar de Java para 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 subproceso.

Puedes considerar usar la clase Handler muy conveniente (android.os.Handler) y enviar mensajes al manejador 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 a través de las funciones postAtTime(java.lang.Runnable, long) o postDelayed(java.lang.Runnable, long) Handler.

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


Por el bien de StackOverflow:

Dado que el temporizador crea un nuevo hilo, puede considerarse pesado,

Si todo lo que necesita es obtener una llamada de vuelta mientras la actividad está ejecutando un Handler puede ser utilizado en conjunción con un

Runnable :

 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 de lado este enfoque se puede utilizar, si desea ejecutar un pedazo de código en el hilo de interfaz de usuario de otro hilo.

Si necesita recibir una llamada incluso si su actividad no se está ejecutando, puede utilizar 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); 

Siendo la tarea el método a ejecutar
Después de la hora de la ejecución inicial
( Intervalo de tiempo para repetir la ejecución)

Es situacional.

La documentación de Android sugiere que debe utilizar AlarmManager para registrar una Intención que se disparará en el momento especificado si su aplicación no se está ejecutando.

De lo contrario, debe utilizar Handler.

Nota: El administrador de alarmas está diseñado para casos en los que desea que su código de aplicación se ejecute en un momento específico, incluso si su aplicación no se está ejecutando actualmente. Para operaciones normales de sincronización (ticks, timeouts, 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 primera 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 2ª 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(); } } 

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 ::

Programar el temporizador

Añada una nueva variable de tiempo denominada int. Establezca 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); 

Vaya al método run y agregue el código siguiente.

 //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; } }); 

Espero que este es útil y puede tomar menos esfuerzos para implementar, Android CountDownTimer clase

p.ej

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

Soy novato de Android, pero aquí está la clase de temporizador que creé basado en las respuestas anteriores. Funciona para mi aplicación pero acepto 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); } }; } 

Creo que la manera de hacer esto en el androide es que usted necesita un servicio de fondo para correr. En esa aplicación de fondo, cree el temporizador. Cuando el temporizador "marque" (establezca el intervalo durante el tiempo que desea esperar), inicie la actividad que desea iniciar.

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

Para la operación de temporización debe utilizar el controlador. Consulte http://developer.android.com/resources/articles/timed-ui-updates.html

Si necesita ejecutar un servicio de fondo, el AlarmManager es el camino a seguir. Echa un vistazo al BuzzBox SDK

http://hub.buzzbox.com/android-sdk/

Usted puede crear una tarea y programarla usando una cadena del cron y trabajará similar a crontab en linux

Solía ​​utilizar ( Timer , TimerTask ), así como Handler para iniciar tareas (tiempo) periódicamente. Ahora he cambiado el todo a RxJava. RxJava proporciona Observable.timer que es más simple, menos propenso a errores, sin complicaciones 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(); } } 

Estoy usando un manejador y runnable para crear un temporizador. Envuelvo esto en una clase abstracta. Sólo derivar / implementar y que son buenos para ir:

  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 el handler.postDelayed se llama antes de que el código que se ejecutará – esto hará que el cronómetro más cerrado cronometrado como "esperado". Sin embargo, en los casos en que el temporizador se ejecuta a menudo y la tarea ( onTimer() ) es larga – podría haber solapamientos. Si desea comenzar a contar intervalMS después de que la tarea se haya completado, mueva la línea onTimer() a una línea anterior.

FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.