Como chamar uma função após atraso no Kotlin?

Como o título, existe alguma maneira de chamar uma função após um atraso (1 segundo por exemplo) em Kotlin?

Você pode usar o Schedule

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

exemplo (obrigado @Nguyen Minh Binh - encontre-o aqui: 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()
}

Há também uma opção para usar Handler -> postDelayed

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

Várias maneiras

1. Usando Handlerclasse

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

2. Usando Timerclasse

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

Mais curta

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

Mais curto

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

3. Usando Executorsclasse

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

Você precisa importar as duas bibliotecas a seguir:

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

e depois disso use-o desta maneira:

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

Você poderia launchuma corotina, delaye depois chamar a função:

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

Se você estiver fora de uma classe ou objeto antes GlobalScopede permitir que a corotina seja executada lá, caso contrário, é recomendável implementar a CoroutineScopeclasse circundante, o que permite cancelar todas as corotinas associadas a esse escopo, se necessário.

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

Um exemplo simples para mostrar um brinde após 3 segundos :

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

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

Se você estiver procurando por uso genérico, aqui está minha sugestão:

Crie uma classe chamada como Run:

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

E use assim:

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

Eu recomendei o uso do SingleThread porque você não precisa matá-lo após o uso. Além disso, o método " stop ()" foi descontinuado no idioma Kotlin.

private fun mDoThisJob(){

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

    }, 1, 1, TimeUnit.SECONDS)
}

Além disso, você pode usá-lo para trabalhos periódicos. É muito útil. Se você deseja fazer o trabalho a cada segundo, é possível definir os parâmetros:

Executors.newSingleThreadScheduledExecutor (). ScheduleAtFixedRate (comando Runnable, long initialDelay, longo período, unidade TimeUnit);

Os valores de TimeUnit são: NANOSECONDS, MICROSECONDS, MILISECONDS, SECONDS, MINUTES, HOURS, DIAS.

@canerkaseler