Quel est l'équivalent d'un JavaScript setInterval / setTimeout sous Android / Java?

Quelqu'un peut-il me dire s'il existe un équivalent pour setInterval / setTimeout pour Android? Quelqu'un a-t-il un exemple sur la façon de le faire?

Comme toujours avec Android, il existe de nombreuses façons de le faire, mais en supposant que vous souhaitiez simplement exécuter un morceau de code un peu plus tard sur le même thread, j'utilise ceci:

new android.os.Handler().postDelayed(
    new Runnable() {
        public void run() {
            Log.i("tag", "This'll run 300 milliseconds later");
        }
    }, 
300);

.. c'est à peu près équivalent à

setTimeout( 
    function() {
        console.log("This will run 300 milliseconds later");
    },
300);

setInterval ()

fonction qui se répète toutes les n millisecondes

Javascript

 setInterval(function(){ Console.log("A Kiss every 5 seconds"); }, 5000);

Equivalent Java approximatif

new Timer().scheduleAtFixedRate(new TimerTask(){
    @Override
    public void run(){
       Log.i("tag", "A Kiss every 5 seconds");
    }
},0,5000);

setTimeout ()

fonction qui ne fonctionne qu'après n millisecondes

Javascript

setTimeout(function(){ Console.log("A Kiss after 5 seconds"); },5000);

Equivalent Java approximatif

new android.os.Handler().postDelayed(
    new Runnable() {
        public void run() {
            Log.i("tag","A Kiss after 5 seconds");
        }
}, 5000);

Si vous ne craignez pas de réveiller votre téléphone ou de ramener votre application d'entre les morts, essayez:

// Param is optional, to run task on UI thread.     
Handler handler = new Handler(Looper.getMainLooper());
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        // Do the task...
        handler.postDelayed(this, milliseconds) // Optional, to repeat the task.
    }
};
handler.postDelayed(runnable, milliseconds);

// Stop a repeating task like this.
handler.removeCallbacks(runnable);

En fonction de ce que vous souhaitez réellement réaliser, vous devriez jeter un œil aux gestionnaires Android:

http://developer.android.com/reference/android/os/Handler.html

Si vous avez précédemment utilisé javascript setTimeout () etc. pour planifier une tâche à exécuter à l'avenir, c'est la manière Android de le faire (postDelayed / sendMessageDelayed).

Notez que ni les gestionnaires ni les minuteries ne permettent à un téléphone Android de sortir du mode veille. En d'autres termes, si vous souhaitez programmer quelque chose qui se produise réellement même si l'écran est éteint / le processeur est en veille, vous devez également consulter le AlarmManager.

Je ne connais pas grand chose à JavaScript, mais je pense que les timers sont peut-être ce que vous recherchez.

http://developer.android.com/reference/java/util/Timer.html

Depuis le lien:

One-shot est programmé pour s'exécuter à une heure absolue ou après un délai relatif. Les tâches récurrentes sont planifiées avec une période fixe ou un taux fixe.

La première réponse est certainement la bonne réponse et c'est ce sur quoi j'ai basé cette version lambda, qui est beaucoup plus courte en syntaxe. Puisque Runnable n'a qu'une seule méthode de remplacement "run ()", nous pouvons utiliser un lambda:

this.m_someBoolFlag = false;
new android.os.Handler().postDelayed(() -> this.m_someBoolFlag = true, 300);

import java.util.Timer;
import java.util.TimerTask;

class Clock {
    private Timer mTimer = new Timer();

    private int mSecondsPassed = 0;
    private TimerTask mTask = new TimerTask() {
        @Override
        public void run() {
            mSecondsPassed++;
            System.out.println("Seconds passed: " + mSecondsPassed);
        }
    };

    private void start() {
        mTimer.scheduleAtFixedRate(mTask, 1000, 1000);
    }

    public static void main(String[] args) {
        Clock c = new Clock();
        c.start();
    }
}

Voici un équivalent setTimeout, surtout utile lorsque vous essayez de mettre à jour l'interface utilisateur après un certain délai.

Comme vous le savez peut-être, la mise à jour de l'interface utilisateur ne peut être effectuée qu'à partir du thread d'interface utilisateur. AsyncTask fait cela pour vous en appelant sa méthode onPostExecute à partir de ce thread.

new AsyncTask<Void, Void, Void>() {
        @Override
        protected Void doInBackground(Void... params) {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
            }

            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            // Update the User Interface
        }

    }.execute();

Je créais un lecteur mp3 pour Android, je voulais mettre à jour l'heure actuelle toutes les 500ms donc je l'ai fait comme ça

setInterval

private void update() {
    new android.os.Handler().postDelayed(new Runnable() {
        @Override
        public void run() {
            long cur = player.getCurrentPosition();
            long dur = player.getDuration();
            currentTime = millisecondsToTime(cur);
            currentTimeView.setText(currentTime);
            if (cur < dur) {
                updatePlayer();
            }

            // update seekbar
            seekBar.setProgress( (int) Math.round((float)cur / (float)dur * 100f));
        }
    }, 500);
}

qui appelle la même méthode récursivement