Comment appeler une fonction après un délai dans Kotlin?

En tant que titre, existe-t-il un moyen d'appeler une fonction après un délai (1 seconde par exemple) dans Kotlin?

Vous pouvez utiliser Schedule

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

exemple (merci @Nguyen Minh Binh - trouvé ici: 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()
}

Il existe également une option à utiliser Handler -> postDelayed

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

Plusieurs façons

1. Utilisation de la Handlerclasse

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

2. Utilisation de la Timerclasse

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

Plus court

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

Le plus court

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

3. Utilisation de la Executorsclasse

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

Vous devez importer les deux bibliothèques suivantes:

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

et après cela, utilisez-le de cette manière:

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

Vous pouvez launchune coroutine, delaypuis appeler la fonction:

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

Si vous êtes en dehors d'une classe ou d'un objet prefend GlobalScopepour laisser la coroutine s'exécuter là-bas, sinon il est recommandé d'implémenter le CoroutineScopedans la classe environnante, ce qui permet d'annuler toutes les coroutines associées à cette portée si nécessaire.

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

Un exemple simple pour montrer un toast après 3 secondes :

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

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

Si vous recherchez un usage générique, voici ma suggestion:

Créez une classe nommée comme Run :

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

Et utilisez comme ceci:

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

J'ai recommandé d'utiliser SingleThread car vous n'avez pas à le tuer après utilisation. De plus, la méthode " stop ()" est obsolète en langage Kotlin.

private fun mDoThisJob(){

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

    }, 1, 1, TimeUnit.SECONDS)
}

De plus, vous pouvez l'utiliser pour un travail périodique. C'est très utile. Si vous souhaitez faire un travail pour chaque seconde, vous pouvez en définir les paramètres:

Executors.newSingleThreadScheduledExecutor (). ScheduleAtFixedRate (commande Runnable, long initialDelay, longue période, unité TimeUnit);

Les valeurs de TimeUnit sont: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS.

@canerkaseler