Wie rufe ich eine Funktion nach einer Verzögerung in Kotlin auf?

Gibt es als Titel eine Möglichkeit, eine Funktion nach einer Verzögerung (z. B. 1 Sekunde) in aufzurufen Kotlin ?

Sie können Schedule verwenden

inline fun Timer.schedule(
    delay: Long, 
    crossinline action: TimerTask.() -> Unit
): TimerTask (source)

Beispiel (danke @Nguyen Minh Binh - fand es hier: http://jamie.mccrindle.org/2013/02/exploring-kotlin-standard-library-part-3.html )

import java.util.Timer
import kotlin.concurrent.schedule

Timer("SettingUp", false).schedule(500) { 
   doSomething()
}

Es gibt auch eine Option zu verwenden Handler -> postDelayed

 Handler().postDelayed({
                    //doSomethingHere()
                }, 1000)

Viele Möglichkeiten

1. HandlerKlasse verwenden

Handler().postDelayed({
    TODO("Do something")
    }, 2000)

2. TimerKlasse verwenden

Timer().schedule(object : TimerTask() {
    override fun run() {
        TODO("Do something")
    }
}, 2000)

Kürzer

Timer().schedule(timerTask {
    TODO("Do something")
}, 2000)

Kürzeste

Timer().schedule(2000) {
    TODO("Do something")
}

3. ExecutorsKlasse verwenden

Executors.newSingleThreadScheduledExecutor().schedule({
    TODO("Do something")
}, 2, TimeUnit.SECONDS)

Sie müssen die folgenden zwei Bibliotheken importieren:

import java.util.*
import kotlin.concurrent.schedule

und danach verwenden Sie es auf diese Weise:

Timer().schedule(10000){
    //do something
}

Sie könnten launcheine Coroutine, delayes und dann die Funktion aufrufen:

 /*GlobalScope.*/launch {
   delay(1000)
   yourFn()
 }

Wenn Sie sich außerhalb einer Klasse oder eines Objekts befinden GlobalScope, müssen Sie die Coroutine dort ausführen, andernfalls wird empfohlen, die CoroutineScopein der umgebenden Klasse zu implementieren , um bei Bedarf alle diesem Bereich zugeordneten Coroutinen abzubrechen.

val timer = Timer()
timer.schedule(timerTask { nextScreen() }, 3000)

Ein einfaches Beispiel, um einen Toast nach 3 Sekunden zu zeigen :

fun onBtnClick() {
    val handler = Handler()
    handler.postDelayed({ showToast() }, 3000)
}

fun showToast(){
    Toast.makeText(context, "Its toast!", Toast.LENGTH_SHORT).show()
}

Wenn Sie nach einer generischen Verwendung suchen, ist hier mein Vorschlag:

Erstellen Sie eine Klasse mit dem Namen Run:

class Run {
    companion object {
        fun after(delay: Long, process: () -> Unit) {
            Handler().postDelayed({
                process()
            }, delay)
        }
    }
}

Und verwenden Sie wie folgt:

Run.after(1000, {
    // print something useful etc.
})

Ich habe die Verwendung von SingleThread empfohlen, da Sie es nach der Verwendung nicht beenden müssen. Außerdem ist die Methode " stop ()" in der Kotlin-Sprache veraltet.

private fun mDoThisJob(){

    Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate({
        //TODO: You can write your periodical job here..!

    }, 1, 1, TimeUnit.SECONDS)
}

Darüber hinaus können Sie es für regelmäßige Arbeiten verwenden. Es ist sehr nützlich. Wenn Sie für jede Sekunde einen Job ausführen möchten, können Sie folgende Parameter festlegen:

Executors.newSingleThreadScheduledExecutor (). ScheduleAtFixedRate (Ausführbarer Befehl, lange Anfangsverzögerung, langer Zeitraum, TimeUnit-Einheit);

TimeUnit-Werte sind: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTEN, STUNDEN, TAGE.

@canerkaseler