Was entspricht einem JavaScript setInterval / setTimeout in Android / Java?

Kann mir jemand sagen, ob es für Android ein Äquivalent für setInterval / setTimeout gibt? Hat jemand ein Beispiel dafür, wie es geht?

Wie immer bei Android gibt es viele Möglichkeiten, dies zu tun, aber vorausgesetzt, Sie möchten einfach ein Stück Code etwas später im selben Thread ausführen, verwende ich Folgendes:

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

.. das ist so ziemlich gleichbedeutend mit

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

setInterval ()

Funktion, die sich alle n Millisekunden wiederholt

Javascript

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

Ungefähres Java- Äquivalent

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

setTimeout ()

Funktion, die erst nach n Millisekunden funktioniert

Javascript

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

Ungefähres Java- Äquivalent

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

Wenn Sie sich keine Sorgen machen, Ihr Telefon aufzuwecken oder Ihre App von den Toten zurückzubringen, versuchen Sie Folgendes:

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

Je nachdem, was Sie tatsächlich erreichen möchten, sollten Sie sich die Android-Handler ansehen:

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

Wenn Sie zuvor Javascript setTimeout () usw. verwendet haben, um eine Aufgabe zu planen, die in Zukunft ausgeführt werden soll, ist dies die Android-Methode (postDelayed / sendMessageDelayed).

Beachten Sie, dass weder Handler noch Timer ein Android-Telefon aus dem Ruhemodus aktivieren. Mit anderen Worten, wenn Sie planen möchten, dass tatsächlich etwas passiert, obwohl der Bildschirm ausgeschaltet ist / die CPU schläft, müssen Sie auch den AlarmManager überprüfen.

Ich weiß nicht viel über JavaScript, aber ich denke, Timer könnten das sein, wonach Sie suchen.

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

Über den Link:

One-Shot soll zu einem absoluten Zeitpunkt oder nach einer relativen Verzögerung ausgeführt werden. Wiederkehrende Aufgaben werden entweder mit einem festen Zeitraum oder einer festen Rate geplant.

Die erste Antwort ist definitiv die richtige Antwort und das ist es, worauf ich diese Lambda-Version gestützt habe, deren Syntax viel kürzer ist. Da Runnable nur eine Überschreibungsmethode "run ()" hat, können wir ein Lambda verwenden:

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

Hier ist ein setTimeout-Äquivalent, das vor allem nützlich ist, wenn Sie versuchen, die Benutzeroberfläche nach einer Verzögerung zu aktualisieren.

Wie Sie vielleicht wissen, kann die Aktualisierung der Benutzeroberfläche nur über den UI-Thread erfolgen. AsyncTask erledigt dies für Sie, indem es die onPostExecute-Methode von diesem Thread aus aufruft.

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

Ich habe einen MP3-Player für Android erstellt und wollte die aktuelle Zeit alle 500 ms aktualisieren also habe ich es so gemacht

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

das ruft die gleiche Methode rekursiv auf