Jak wywołać funkcję po opóźnieniu w Kotlinie?

W tytule, czy istnieje sposób wywołania funkcji po opóźnieniu (na przykład 1 sekundę) w Kotlin?

Możesz użyć harmonogramu

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

przykład (dzięki @Nguyen Minh Binh - znalazłem go tutaj: 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()
}

Istnieje również opcja użycia Handler -> postDelayed

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

Wiele sposobów

1. Korzystanie z Handlerklasy

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

2. Korzystanie z Timerklasy

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

Krótszy

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

Najkrótsza

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

3. Korzystanie z Executorsklasy

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

Musisz zaimportować następujące dwie biblioteki:

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

a potem użyj go w ten sposób:

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

Mógłbyś launchcoroutine, delaya następnie wywołać funkcję:

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

Jeśli jesteś poza klasą lub obiektem, GlobalScopedołącz poprzednik, aby pozwolić programowi działać w tym miejscu, w przeciwnym razie zaleca się zaimplementowanie CoroutineScopew otaczającej klasie, co pozwala w razie potrzeby anulować wszystkie procedury powiązane z tym zakresem.

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

Prosty przykład pokazujący toast po 3 sekundach :

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

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

Jeśli szukasz ogólnego zastosowania, oto moja sugestia:

Utwórz klasę o nazwie Run:

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

I użyj w ten sposób:

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

Polecam używanie SingleThread, ponieważ nie musisz go zabijać po użyciu. Ponadto metoda „ stop ()” jest przestarzała w języku Kotlin.

private fun mDoThisJob(){

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

    }, 1, 1, TimeUnit.SECONDS)
}

Ponadto możesz go używać do pracy okresowej. To jest bardzo użyteczne. Jeśli chcesz wykonywać pracę na każdą sekundę, możesz ustawić jej parametry:

Executors.newSingleThreadScheduledExecutor (). ScheduleAtFixedRate (polecenie Runnable, long initialDelay, long period, unit TimeUnit);

Wartości TimeUnit to: NANOSECONDS, MICROSECONDS, MILISECONDS, SECONDS, MINUTES, HOURS, DAYS.

@canerkaseler