Qual è l'equivalente di un setInterval / setTimeout di JavaScript in Android / Java?

Qualcuno può dirmi se esiste un equivalente per setInterval / setTimeout per Android? Qualcuno ha qualche esempio su come farlo?

Come sempre con Android ci sono molti modi per farlo, ma supponendo che tu voglia semplicemente eseguire un pezzo di codice un po 'più tardi sullo stesso thread, io uso questo:

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

.. questo è praticamente equivalente a

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

setInterval ()

funzione che si ripete ogni n millisecondi

Javascript

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

Java approssimativo equivalente

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

setTimeout ()

funzione che funziona solo dopo n millisecondi

Javascript

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

Java approssimativo equivalente

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

Se non sei preoccupato di riattivare il telefono o riportare la tua app da zero, prova:

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

A seconda di ciò che vuoi effettivamente ottenere, dovresti dare un'occhiata ai gestori Android:

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

Se in precedenza hai utilizzato javascript setTimeout () ecc. Per pianificare l'esecuzione di un'attività in futuro, questo è il modo Android di farlo (postDelayed / sendMessageDelayed).

Si noti che né i gestori né i timer fanno svegliare un telefono Android dalla modalità di sospensione. In altre parole, se si desidera programmare qualcosa che accada effettivamente anche se lo schermo è spento / cpu è inattivo, è necessario controllare anche AlarmManager.

Non so molto su JavaScript, ma penso che i timer possano essere quello che stai cercando.

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

Dal link:

È previsto l'esecuzione di uno scatto in un momento assoluto o dopo un ritardo relativo. Le attività ricorrenti sono programmate con un periodo fisso o un tasso fisso.

La prima risposta è sicuramente la risposta corretta ed è ciò su cui ho basato questa versione lambda, che è molto più breve nella sintassi. Poiché Runnable ha solo 1 metodo di sostituzione "run ()", possiamo usare 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();
    }
}

Ecco un equivalente di setTimeout, utile soprattutto quando si tenta di aggiornare l'interfaccia utente dopo un ritardo.

Come forse saprai, l'aggiornamento dell'interfaccia utente può essere eseguito solo dal thread dell'interfaccia utente. AsyncTask lo fa per te chiamando il suo metodo onPostExecute da quel 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();

Stavo creando un lettore mp3 per Android, volevo aggiornare l'ora corrente ogni 500 ms, quindi l'ho fatto in questo modo

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

che chiama ricorsivamente lo stesso metodo