Come chiamare una funzione dopo il ritardo in Kotlin?

Come titolo, c'è un modo per chiamare una funzione dopo il ritardo (ad esempio 1 secondo) in Kotlin?

È possibile utilizzare Pianifica

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

esempio (grazie @Nguyen Minh Binh - l'ho trovato qui: 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()
}

C'è anche un'opzione da usare Handler -> postDelayed

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

Molti modi

1. Uso della Handlerclasse

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

2. Uso della Timerclasse

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

Più breve

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

Più breve

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

3. Uso della Executorsclasse

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

Devi importare le seguenti due librerie:

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

e dopo usalo in questo modo:

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

È possibile launchun coroutine, delayquindi chiamare la funzione:

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

Se si è al di fuori di una classe o di un oggetto anteposto GlobalScopeper consentire l'esecuzione della coroutine, altrimenti si consiglia di implementare la CoroutineScopeclasse circostante, che consente di annullare tutte le coroutine associate a tale ambito, se necessario.

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

Un semplice esempio per mostrare un brindisi dopo 3 secondi :

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

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

Se stai cercando un uso generico, ecco il mio suggerimento:

Crea una classe denominata come Run:

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

E usa così:

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

Ho consigliato di utilizzare SingleThread perché non è necessario ucciderlo dopo l'uso. Inoltre, il metodo " stop ()" è deprecato nel linguaggio Kotlin.

private fun mDoThisJob(){

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

    }, 1, 1, TimeUnit.SECONDS)
}

Inoltre, puoi usarlo per un lavoro periodico. E 'molto utile. Se desideri fare un lavoro per ogni secondo, puoi impostare perché i suoi parametri:

Executors.newSingleThreadScheduledExecutor (). ScheduleAtFixedRate (comando eseguibile, ritardo iniziale lungo, periodo lungo, unità TimeUnit);

I valori di TimeUnit sono: NANOSECONDI, MICROSECONDI, MILLISECONDI, SECONDI, MINUTI, ORE, GIORNI.

@canerkaseler