Kotlin - Wait function

Is there a wait function in kotlin? (I don't mean a Timer Schedule, but actually pause the execution). I have read that you can use Thread.sleep(). However, it doesn't work for me, because the function can't be found.

Thread sleep always takes a time how long to wait: https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#sleep(long)

public static void sleep(long millis)
                  throws InterruptedException

e.g.

Thread.sleep(1_000)  // wait for 1 second

---

If you want to wait for some other Thread to wake you, maybe `Object#wait()' would be better

https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#wait()

public final void wait()
                throws InterruptedException

Then another thread has to call yourObject#notifyAll()

e.g. Thread1 and Thread2 shares an Object o = new Object()

Thread1: o.wait()      // sleeps until interrupted or notified
Thread2: o.notifyAll() // wake up ALL waiting Threads of object o

Please try this, it will work for Android:

Handler(Looper.getMainLooper()).postDelayed(
    {
        // This method will be executed once the timer is over
    },
    1000 // value in milliseconds
)

Since new coroutines feature became available in Kotlin version 1.1 you can use non-blocking delay function with such signature:

suspend fun delay(time: Long, unit: TimeUnit = TimeUnit.MILLISECONDS)

In Kotlin 1.2 it is still located in kotlinx.coroutines.experimental package. Experimental status of coroutines is described here.

UPD: Kotlin 1.3 was released, coroutines were moved to kotlinx.coroutines package, they are no longer experimental feature.

UPD 2: To use this method inside non-suspendable methods it's possible to make it blocking, like any other suspendable methods, by surrounding with runBlocking {}:

runBlocking {
    delay(2, TimeUnit.SECONDS)
}

You can use stuff of the standard JDK.

Another response suggests Thread.sleep(millis: Long). Personally I prefer the TimeUnit class (since Java 1.5) which provides a more comprehensive syntax.

TimeUnit.SECONDS.sleep(1L)
TimeUnit.MICROSECONDS.sleep(1000_000L)

They use Thread.sleep behind the scene, and they can throw InterruptedException too. Unfortunately, as pointed by @AndroidDev in a comment, they do not cooperate with Kotlin coroutines (since Kotlin 1.1). So we should prefer delay function in this context.

public suspend fun delay(timeMillis: Long): Unit
public suspend fun delay(duration: Duration): Unit

You can achieve this easily with Kotlin coroutines

class SplashActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_splash)

        CoroutineScope(Dispatchers.IO).launch {
            delay(TimeUnit.SECONDS.toMillis(3))
            withContext(Dispatchers.Main) {
                Log.i("TAG", "this will be called after 3 seconds")
                finish()
            }
        }
        Log.i("TAG", "this will be called immediately")
    }
}

build.gradle(app)

dependencies {
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.1'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1'
}

you can use to wait or sleep for 2 seconds

TimeUnit.SECONDS.sleep(2L)

*

TimeUnit.SECONDS.sleep((seconds you want to sleep) + L)

You can use

SystemClock.sleep(1000)