Android minuterie? Comment faire?

ok, puisque ce n'est pas libéré jusqu'à encore il y a 3 façons simples pour gérer cela.
Ci-dessous est un exemple montrant tous les 3 et à la partie inférieure est un exemple montrant juste la méthode que je crois est préférable. Pensez également à nettoyer vos tâches dans onPause, enregistrer l'état si nécessaire.

import java.util.Timer;
import java.util.TimerTask;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Handler.Callback;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class main extends Activity {
TextView text, text2, text3;
long starttime = 0;
//this  posts a message to the main thread from our timertask
//and updates the textfield
final Handler h = new Handler(new Callback() {
@Override
public boolean handleMessage(Message msg) {
long millis = System.currentTimeMillis() - starttime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds     = seconds % 60;
text.setText(String.format("%d:%02d", minutes, seconds));
return false;
}
});
//runs without timer be reposting self
Handler h2 = new Handler();
Runnable run = new Runnable() {
@Override
public void run() {
long millis = System.currentTimeMillis() - starttime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds     = seconds % 60;
text3.setText(String.format("%d:%02d", minutes, seconds));
h2.postDelayed(this, 500);
}
};
//tells handler to send a message
class firstTask extends TimerTask {
@Override
public void run() {
h.sendEmptyMessage(0);
}
};
//tells activity to run on ui thread
class secondTask extends TimerTask {
@Override
public void run() {
main.this.runOnUiThread(new Runnable() {
@Override
public void run() {
long millis = System.currentTimeMillis() - starttime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds     = seconds % 60;
text2.setText(String.format("%d:%02d", minutes, seconds));
}
});
}
};
Timer timer = new Timer();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
text = (TextView)findViewById(R.id.text);
text2 = (TextView)findViewById(R.id.text2);
text3 = (TextView)findViewById(R.id.text3);
Button b = (Button)findViewById(R.id.button);
b.setText("start");
b.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Button b = (Button)v;
if(b.getText().equals("stop")){
timer.cancel();
timer.purge();
h2.removeCallbacks(run);
b.setText("start");
}else{
starttime = System.currentTimeMillis();
timer = new Timer();
timer.schedule(new firstTask(), 0,500);
timer.schedule(new secondTask(),  0,500);
h2.postDelayed(run, 0);
b.setText("stop");
}
}
});
}
@Override
public void onPause() {
super.onPause();
timer.cancel();
timer.purge();
h2.removeCallbacks(run);
Button b = (Button)findViewById(R.id.button);
b.setText("start");
}
}
 

la principale chose à retenir est que l'INTERFACE utilisateur ne peut être modifié à partir de l'interface utilisateur principale de fil, utiliser un gestionnaire ou de l'activité.runOnUIThread(Runnable r);

Voici ce que je considère être la méthode préférée.

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class TestActivity extends Activity {
TextView timerTextView;
long startTime = 0;
//runs without a timer by reposting this handler at the end of the runnable
Handler timerHandler = new Handler();
Runnable timerRunnable = new Runnable() {
@Override
public void run() {
long millis = System.currentTimeMillis() - startTime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds = seconds % 60;
timerTextView.setText(String.format("%d:%02d", minutes, seconds));
timerHandler.postDelayed(this, 500);
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.test_activity);
timerTextView = (TextView) findViewById(R.id.timerTextView);
Button b = (Button) findViewById(R.id.button);
b.setText("start");
b.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Button b = (Button) v;
if (b.getText().equals("stop")) {
timerHandler.removeCallbacks(timerRunnable);
b.setText("start");
} else {
startTime = System.currentTimeMillis();
timerHandler.postDelayed(timerRunnable, 0);
b.setText("stop");
}
}
});
}
@Override
public void onPause() {
super.onPause();
timerHandler.removeCallbacks(timerRunnable);
Button b = (Button)findViewById(R.id.button);
b.setText("start");
}
}
 

Si vous aussi vous avez besoin pour exécuter votre code sur le thread d'INTERFACE utilisateur (et non pas sur le thread horloge), prendre un coup d'oeil sur le blog: http://steve.odyfamily.com/?p=12

public class myActivity extends Activity {
private Timer myTimer;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);
myTimer = new Timer();
myTimer.schedule(new TimerTask() {          
@Override
public void run() {
TimerMethod();
}
}, 0, 1000);
}
private void TimerMethod()
{
//This method is called directly by the timer
//and runs in the same thread as the timer.
//We call the method that will work with the UI
//through the runOnUiThread method.
this.runOnUiThread(Timer_Tick);
}
private Runnable Timer_Tick = new Runnable() {
public void run() {
//This method runs in the same thread as the UI.               
//Do something to the UI thread here
}
};
}

C'est un code simple pour un minuteur:

Timer timer = new Timer();
TimerTask t = new TimerTask() {       
@Override
public void run() {
System.out.println("1");
}
};
timer.scheduleAtFixedRate(t,1000,1000);

Parce que cette question est toujours d'attirer un grand nombre d'utilisateurs de google search(sur Android timer) je voudrais insérer mon deux pièces de monnaie.

Tout d'abord, la Minuterie classe sera obsolète dans Java 9 (lire la accepté de répondre).

La officiel suggéré façon est d'utiliser des ScheduledThreadPoolExecutor qui est plus efficace et des fonctionnalités riches qui peuvent en outre calendrier de commandes à exécuter qu'après un certain délai, ou à exécuter périodiquement. De Plus,il offre davantage de flexibilité et de capacités de ThreadPoolExecutor.

Voici un exemple d'utilisation de la plaine de fonctionnalités.

1. Créer exécuteur de service:

   final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1);

2. Juste horaire vous praticable:

   final Future<?> future = SCHEDULER.schedule(Runnable task, long delay,TimeUnit unit);

3. Vous pouvez maintenant utiliser future pour annuler la tâche ou vérifier si il est fait par exemple:

   future.isDone();

Espère que vous trouverez ce utile pour la création d'une tâche dans Android.

Exemple complet:

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
Future<?> sampleFutureTimer = scheduler.schedule(new Runnable(), 120, TimeUnit.SECONDS);
if (sampleFutureTimer.isDone()){
//Do something which will save world.
}

Il es est plus simple solution fonctionne très bien dans mon app.

  public class MyActivity extends Acitivity {
TextView myTextView;
boolean someCondition=true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.my_activity);
myTextView = (TextView) findViewById(R.id.refreshing_field);
//starting our task which update textview every 1000 ms
new RefreshTask().execute();
}
//class which updates our textview every second
class RefreshTask extends AsyncTask {
@Override
protected void onProgressUpdate(Object... values) {
super.onProgressUpdate(values);
String text = String.valueOf(System.currentTimeMillis());
myTextView.setText(text);
}
@Override
protected Object doInBackground(Object... params) {
while(someCondition) {
try {
//sleep for 1s in background...
Thread.sleep(1000);
//and update textview in ui thread
publishProgress();
} catch (InterruptedException e) {
e.printStackTrace(); 
};
return null;
}
}
}

Ici est un simple moyen fiable...

Placez le code suivant dans votre Activité, et de la méthode tick() sera appelée à chaque seconde dans le thread de l'INTERFACE utilisateur, tandis que votre activité est en de la "reprise" de l'état. Bien sûr, vous pouvez modifier la méthode tick() pour faire ce que vous voulez, ou d'être appelé plus ou moins fréquemment.

@Override
public void onPause() {
_handler = null;
super.onPause();
}
private Handler _handler;
@Override
public void onResume() {
super.onResume();
_handler = new Handler();
Runnable r = new Runnable() {
public void run() {
if (_handler == _h0) {
tick();
_handler.postDelayed(this, 1000);
}
}
private final Handler _h0 = _handler;
};
r.run();
}
private void tick() {
System.out.println("Tick " + System.currentTimeMillis());
}

Pour ceux que cela intéresse, le "_h0=_handler" code est nécessaire pour éviter les deux minuteries en cours d'exécution simultanément si votre activité est en pause et la reprise au sein de la tique période.

Vous avez besoin pour créer un thread pour gérer la mise à jour de boucle et de l'utiliser pour mettre à jour le textarea. La partie délicate est que seul le thread principal peut effectivement modifier l'interface utilisateur de sorte que la mise à jour de boucle de fil besoins de signal le thread principal pour faire la mise à jour. Ceci est fait en utilisant un Gestionnaire.

Consultez ce lien: http://developer.android.com/guide/topics/ui/dialogs.html#
Cliquez sur la section intitulée "Exemple ProgressDialog avec un deuxième thread". C'est un exemple de ce que vous devez faire, sauf avec une boîte de dialogue de progression au lieu d'un champ de texte.

Si quelqu'un est intéressé, j'ai commencé à jouer avec la création d'un objet standard pour fonctionner sur une des activités thread d'INTERFACE utilisateur. Semble fonctionner ok. Commentaires bienvenus. J'aimerai bien que cela soit disponible sur le layout designer en tant que composante de glisser une Activité. Ne peux pas croire que quelque chose comme ça n'existe pas déjà.

package com.example.util.timer;
import java.util.Timer;
import java.util.TimerTask;
import android.app.Activity;
public class ActivityTimer {
private Activity m_Activity;
private boolean m_Enabled;
private Timer m_Timer;
private long m_Delay;
private long m_Period;
private ActivityTimerListener m_Listener;
private ActivityTimer _self;
private boolean m_FireOnce;
public ActivityTimer() {
m_Delay = 0;
m_Period = 100;
m_Listener = null;
m_FireOnce = false;
_self = this;
}
public boolean isEnabled() {
return m_Enabled;
}
public void setEnabled(boolean enabled) {
if (m_Enabled == enabled)
return;
//Disable any existing timer before we enable a new one
Disable();
if (enabled) {
Enable();
}
}
private void Enable() {
if (m_Enabled)
return;
m_Enabled = true;
m_Timer = new Timer();
if (m_FireOnce) {
m_Timer.schedule(new TimerTask() {
@Override
public void run() {
OnTick();
}
}, m_Delay);
} else {
m_Timer.schedule(new TimerTask() {
@Override
public void run() {
OnTick();
}
}, m_Delay, m_Period);
}
}
private void Disable() {
if (!m_Enabled)
return;
m_Enabled = false;
if (m_Timer == null)
return;
m_Timer.cancel();
m_Timer.purge();
m_Timer = null;
}
private void OnTick() {
if (m_Activity != null && m_Listener != null) {
m_Activity.runOnUiThread(new Runnable() {
@Override
public void run() {
m_Listener.OnTimerTick(m_Activity, _self);
}
});
}
if (m_FireOnce)
Disable();
}
public long getDelay() {
return m_Delay;
}
public void setDelay(long delay) {
m_Delay = delay;
}
public long getPeriod() {
return m_Period;
}
public void setPeriod(long period) {
if (m_Period == period)
return;
m_Period = period;
}
public Activity getActivity() {
return m_Activity;
}
public void setActivity(Activity activity) {
if (m_Activity == activity)
return;
m_Activity = activity;
}
public ActivityTimerListener getActionListener() {
return m_Listener;
}
public void setActionListener(ActivityTimerListener listener) {
m_Listener = listener;
}
public void start() {
if (m_Enabled)
return;
Enable();
}
public boolean isFireOnlyOnce() {
return m_FireOnce;
}
public void setFireOnlyOnce(boolean fireOnce) {
m_FireOnce = fireOnce;
}
}

Dans l'activité, j'ai ce démarrage:

@Override
protected void onStart() {
super.onStart();
m_Timer = new ActivityTimer();
m_Timer.setFireOnlyOnce(true);
m_Timer.setActivity(this);
m_Timer.setActionListener(this);
m_Timer.setDelay(3000);
m_Timer.start();
}

Pour ceux qui ne peuvent pas compter sur Chronomètre, j'ai fait une classe utilitaire de l'une des suggestions:

public class TimerTextHelper implements Runnable {
private final Handler handler = new Handler();
private final TextView textView;
private volatile long startTime;
private volatile long elapsedTime;
public TimerTextHelper(TextView textView) {
this.textView = textView;
}
@Override
public void run() {
long millis = System.currentTimeMillis() - startTime;
int seconds = (int) (millis / 1000);
int minutes = seconds / 60;
seconds = seconds % 60;
textView.setText(String.format("%d:%02d", minutes, seconds));
if (elapsedTime == -1) {
handler.postDelayed(this, 500);
}
}
public void start() {
this.startTime = System.currentTimeMillis();
this.elapsedTime = -1;
handler.post(this);
}
public void stop() {
this.elapsedTime = System.currentTimeMillis() - startTime;
handler.removeCallbacks(this);
}
public long getElapsedTime() {
return elapsedTime;
}

}

à utiliser..tout simplement:

 TimerTextHelper timerTextHelper = new TimerTextHelper(textView);
timerTextHelper.start();

.....

 timerTextHelper.stop();
long elapsedTime = timerTextHelper.getElapsedTime();