코틀린에서 지연 후 함수를 어떻게 호출합니까?

코틀린에서 지연 후 함수를 어떻게 호출합니까?

제목처럼, 지연 후 함수를 호출할 수 있는 방법이 있습니까(예: 1초).Kotlin?

사용할 수 있는 옵션도 있습니다.Handler -> postDelayed

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

다양한 방법

사용Handler학급

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

사용Timer학급

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

// Shorter

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


// Shortest

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

사용Executors학급

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

예약을 사용할 수 있습니다.

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

예 (고마워요 @Nguyen Minh Binh - 여기서 찾았어요: 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()
}

할 수 있습니다launch코루틴,delay그런 다음 함수를 호출합니다.

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

클래스 또는 오브젝트 프리펜드 외부에 있는 경우GlobalScope여기서 코루틴을 실행하도록 허용합니다. 그렇지 않으면 필요한 경우 해당 범위와 연결된 모든 코루틴을 취소할 수 있는 를 주변 클래스에 구현하는 것이 좋습니다.

다음 두 라이브러리를 가져와야 합니다.

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

그 후에는 다음과 같은 방법으로 사용합니다.

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

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

최신 Android API를 사용하는 경우 Handler 빈 생성자가 더 이상 사용되지 않으므로 Looper를 포함해야 합니다.당신은 쉽게 통과할 수 있습니다.Looper.getMainLooper().

    Handler(Looper.getMainLooper()).postDelayed({
        //Your code
    }, 2000) //millis

viewModel 범위가 있는 조각에 있는 경우 Kotlin 코루틴을 사용할 수 있습니다.

    myViewModel.viewModelScope.launch {
        delay(2000)
        // DoSomething()
    }

3초 후에 건배하는 간단한 예:

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

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

일반적인 용도를 찾고 있다면 다음과 같이 제안합니다.

이름이 다음인 클래스를 만듭니다.Run:

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

다음과 같이 사용합니다.

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

저는 코틀린 코루틴을 사용할 것을 제안하고 만약 당신이 그것을 취소하고 싶다면.그것의 간단하고 가벼운 무게.

fun repeatFun(): Job {
    return coroutineScope.launch {  
        while(isActive) {
            //do your work here
            delay(1000)
        }
    }
}

//start the loop
val repeatFun = repeatRequest()

//Cancel the loop
repeatFun.cancel()

싱글스레드는 사용 후 삭제할 필요가 없기 때문에 추천합니다.또한 "stop()" 메서드는 코틀린 언어에서 더 이상 사용되지 않습니다.

private fun mDoThisJob(){

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

    }, 1, 1, TimeUnit.SECONDS)
}

게다가, 당신은 그것을 정기적인 일에 사용할 수 있습니다.그것은 매우 유용하다.각 초당 작업을 수행하려면 다음과 같이 설정할 수 있습니다.

Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(실행 가능 명령, 긴 초기 지연, 긴 기간, TimeUnit 단위);

TimeUnit 값은 다음과 같습니다. 나노초, 마이크로초, 밀리초, 초, 분, 시간, 일.

다음 기능을 사용합니다.

fun <T> delayedAsyncTask(delayMs: Long = 0, task: () -> T): ScheduledFuture<T> {
    return Executors
        .newSingleThreadScheduledExecutor()
        .schedule(Callable<T> { task() }, delayMs, TimeUnit.MILLISECONDS)
}

fun <T> asyncTask(task: () -> T) = delayedAsyncTask(0, task)

지연된 기능에 대한 유닛 테스트입니다.물론 반환된 미래를 사용하는 것은 선택 사항입니다.

    @Test
    fun `delayed task work correctly`() {
        val future = delayedAsyncTask(1000) {
            "lambda returns hello world"
        }
        assertEquals(false, future.isDone)
        Thread.sleep(1100)
        assertEquals(true, future.isDone)
        assertEquals("lambda returns hello world", future.get())
    }

이 외에 중복 작업을 생성하는 또 다른 방법으로, 기능을 일시 중단할 필요가 없습니다.

   val repeatableJob = CoroutineScope(Dispatchers.IO).launch {
        while (true) {
            delay(1000)
        }
    }

완료되면 취소 -repeatableJob.cancel()

UI에서 호출 기능인 경우.

Timer().schedule(1000) {
  activity?.runOnUiThread {
    doSomething()
  }
}

언급URL : https://stackoverflow.com/questions/43348623/how-to-call-a-function-after-delay-in-kotlin