Comment mettre un timer sur android

Java Standard de façon à utiliser des compteurs via java.util.Minuterie et java.util.TimerTask fonctionne très bien sous Android, mais vous devez être conscient que cette méthode crée un nouveau thread.

Vous pouvez envisager d'utiliser les très pratique Gestionnaire classe (android.os.Gestionnaire) et envoyer des messages via le gestionnaire sendMessageAtTime(android.os.Message, long) ou sendMessageDelayed(android.os.Message, long). Une fois que vous recevez un message, vous pouvez exécuter les tâches désirées. La deuxième option serait de créer un Praticable objet et à le programmer via le Gestionnaire de fonctions postAtTime(java.lang.Runnable, long) ou postDelayed(java.lang.Runnable, long).

Que je l'ai vu, java.util.Minuterie est le plus utilisé pour la mise en œuvre d'une minuterie.

Pour une répétition de la tâche:

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

Pour une seule exécution d'une tâche:

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

tâche être la méthode à exécuter

après le temps d'exécution initiale

(intervalle le temps pour la répétition de l'exécution)

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

ou

Méthode 2 ::

Programme de la minuterie

Ajouter une nouvelle variable de type int nommé temps. Mettre à 0.
Ajoutez le code suivant à la fonction onCreate dans 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);

Aller dans la méthode run et ajoutez le code suivant.

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

});

Nous y voilà.. Nous aurons besoin de deux classes. J'ai écris un code qui change de mobile profil audio après chaque 5 secondes (5000 mili secondes) ...

Notre 1ère Classe

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

}

Notre 2ème Classe

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

    }

}

Je suis en utilisant un gestionnaire et praticable pour créer un timer. Je wrapper ce dans une classe abstraite. Juste tirer/la mettre en œuvre et vous êtes bon pour aller:

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

Noter que le handler.postDelayed est appelé avant l'exécution d'un code - ce qui va faire la minuterie plus fermé chronométré comme "prévu". Toutefois, dans les cas ont été le minuteur s'exécute fréquemment et la tâche (onTimer()) est longue, il pourrait y avoir des recoupements. Si vous voulez commencer à compter intervalMS après la tâche est terminée, déplacez le onTimer() appeler une ligne au-dessus.

J'ai l'habitude d'utiliser (Timer, TimerTask) ainsi que Handler le coup d'envoi (de temps) tâches périodiquement. Maintenant, j'ai basculé l'ensemble de RxJava. RxJava fournit Observable.timer qui est plus simple, moins sujettes à l'erreur, sans tracas à utiliser.

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