Wie stellt man einen Timer in Android ein?

Question

Kann jemand ein einfaches Beispiel für die Aktualisierung eines Textfeldes jede Sekunde oder so geben?

Ich möchte einen fliegenden Ball machen und muss die Koordinaten des Balls jede Sekunde berechnen/aktualisieren, deshalb brauche ich eine Art Timer.

Ich bekomme nichts von aquí .

Answer 1

Ich denke, Sie können es auf Rx-Art machen:

 timerSubscribe = Observable.interval(1, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1<Long>() {
                @Override
                public void call(Long aLong) {
                      //TODO do your stuff
                }
            });

Und stornieren Sie diese wie:

timerSubscribe.unsubscribe();

Rx-Zeitgeber http://reactivex.io/documentation/operators/timer.html

Answer 2

Ich bin überrascht, dass es keine Antwort gibt, die eine Lösung mit RxJava2 . Es ist wirklich einfach und bietet eine einfache Möglichkeit, Timer in Android einzurichten.

Zuerst müssen Sie die Gradle-Abhängigkeit einrichten, falls Sie dies nicht bereits getan haben:

implementation "io.reactivex.rxjava2:rxjava:2.x.y"

(ersetzen x y y con aktuelle Versionsnummer )

Denn wir haben nur eine einfache, NICHT WIEDERKEHRENDE AUFGABE können wir verwenden Completable Objekt:

Completable.timer(2, TimeUnit.SECONDS, Schedulers.computation())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(() -> {
            // Timer finished, do something...
        });

Für WIEDERHOLENDE AUFGABE können Sie verwenden Observable in ähnlicher Weise:

Observable.interval(2, TimeUnit.SECONDS, Schedulers.computation())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(tick -> {
            // called every 2 seconds, do something...
        }, throwable -> {
            // handle error
        });

Schedulers.computation() stellt sicher, dass unser Timer auf einem Hintergrund-Thread läuft und .observeOn(AndroidSchedulers.mainThread()) bedeutet, dass der Code, der nach Beendigung des Timers ausgeführt wird, im Hauptthread ausgeführt wird.

Um unerwünschte Speicherlecks zu vermeiden, sollten Sie sicherstellen, dass Sie sich abmelden, wenn die Aktivität/das Fragment zerstört wird.

Answer 3

Da diese Frage immer noch viele Nutzer aus der Google-Suche (über Android-Timer) anzieht, möchte ich meine zwei Münzen einfügen.

Erstens, die Zeitschaltuhr Klasse wird in Java 9 veraltet sein (lesen Sie die akzeptierte Antwort) .

Les offiziell Der vorgeschlagene Weg ist die Verwendung von ScheduledThreadPoolExecutor die effektiver und funktionsreicher ist und zusätzlich Befehle so planen kann, dass sie nach einer bestimmten Verzögerung oder in regelmäßigen Abständen ausgeführt werden. Außerdem bietet er zusätzliche Flexibilität und Fähigkeiten des ThreadPoolExecutor.

Hier ein Beispiel für die Verwendung einfacher Funktionalitäten.

1. Executor-Dienst erstellen:

   final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1);

2. Setzen Sie einfach einen Zeitplan für die Ausführung fest:

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

3. Sie können nun Folgendes verwenden future um die Aufgabe abzubrechen oder zu prüfen, ob sie beispielsweise erledigt ist:

   future.isDone();

Ich hoffe, Sie finden dies nützlich für die Erstellung einer Aufgabe in Android.

Vollständiges Beispiel:

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

Answer 4

Für alle, die das in Kotlin machen wollen:

val timer = fixedRateTimer(period = 1000L) {
            val currentTime: Date = Calendar.getInstance().time
            runOnUiThread {
                tvFOO.text = currentTime.toString()
            }
        }

um den Timer zu stoppen, können Sie dies verwenden:

timer.cancel()

diese Funktion hat viele weitere Optionen, probieren Sie es aus

Answer 5

import kotlin.concurrent.fixedRateTimer

val timer = fixedRateTimer("Tag", false, 1000, 2500) { /* Your code here */ }

Ziemlich einfach mit Kotlin