studio - Cómo configurar un temporizador en Android

cuenta regresiva en java

Question

¿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 UI)? 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)?

Answer 1

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 milisegundos) ...

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 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();

    }

}

Answer 2

Creo que la forma de hacerlo en el Android es que necesitas un servicio en segundo plano para que se ejecute. En esa aplicación de fondo, crea el temporizador. Cuando el temporizador "marca" (establece el intervalo de 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 actividades, servicios, intenciones y otros fundamentos básicos del desarrollo de Android)

Answer 3

Es situacional.

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

De lo contrario, debes usar Handler.

Nota: Alarm Manager está diseñado para casos en los que desee 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 las operaciones de temporización normales (ticks, tiempos de espera, etc.) es más fácil y mucho más eficiente usar Handler.

Answer 4

Espero que este sea útil y tome 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();

Answer 5

Estoy usando un controlador y ejecutable para crear un temporizador. Envuelvo esto en una clase abstracta. Simplemente deriva / impleméntalo y estás listo 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 se llama al handler.postDelayed antes del código que se ejecutará; esto hará que el temporizador se cierre más tiempo 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 intervalMS después de que la tarea finaliza, mueva el onTimer() llame a una línea arriba.

Answer 6

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 debes tener en cuenta que este método crea un nuevo hilo.

Puede considerar el uso de la práctica clase Handler (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 a través de las funciones de Handler postAtTime(java.lang.Runnable, long) o postDelayed(java.lang.Runnable, long) .

Answer 7

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

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

Answer 8

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 int named time. Establézcalo 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 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;
    }

});

Answer 9

Solía ​​usar ( Timer , TimerTask ) así como Handler para iniciar tareas (que consumen mucho tiempo) periódicamente. Ahora he cambiado todo a RxJava. RxJava proporciona Observable.timer que 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();
  }
}

Answer 10

Soy un novato de Android, pero aquí está la clase de temporizador que creé en función de 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);
        }
    }; 
}

Answer 11

Tal 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);

tarea es el método a ser ejecutado
después del tiempo para la ejecución inicial
( intervalo el tiempo para repetir la ejecución)

Answer 12

sí el temporizador de java se puede usar , pero a medida que la pregunta pregunta por una mejor manera (para dispositivos móviles). Lo cual se explica Here .

Por el bien de :

Como java.util.Timer crea un nuevo hilo, puede considerarse pesado,

si todo lo que necesita es obtener una devolución de llamada mientras se está ejecutando la actividad, se puede usar un Handler junto 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 Message

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

si necesita recuperar una llamada, incluso si su actividad no se está ejecutando, puede usar un AlarmManager