Comment appeler une fonction avec un délai en Kotlin : guide complet avec code

Pourquoi vous en avez besoin maintenant

Imaginez : vous écrivez une application et vous devez afficher une notification à l'utilisateur 5 secondes après avoir cliqué sur un bouton. Ou exécuter une requête vers le serveur seulement 2 secondes après que l'utilisateur a fini de taper du texte. Ou simplement faire une belle animation avec un délai. Sans savoir appeler une fonction avec un délai en Kotlin, vous êtes coincé.

Cette question est l'une des plus populaires sur Stack Overflow (des milliers de vues !), et ce n'est pas pour rien. Kotlin propose 4 façons de faire un appel différé, et chacune convient à une situation spécifique. Dans cet article, nous allons toutes les détailler : du simple delay() dans les coroutines au classique Handler pour Android. Vous apprendrez quelle méthode choisir et pourquoi, et surtout, vous verrez du code fonctionnel que vous pouvez immédiatement copier dans votre projet.

Méthode 1 : Coroutines et delay() (moderne et recommandée)

C'est la méthode la plus élégante et recommandée en Kotlin moderne. Les coroutines sont des threads légers qui ne bloquent pas le thread principal. La méthode delay() suspend la coroutine pendant un temps donné, puis la reprend.

Pour utiliser les coroutines, vous devez ajouter la dépendance dans build.gradle.kts :

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")

Voici à quoi cela ressemble en code :

import kotlinx.coroutines.*\n\nfun main() = runBlocking {\n    println("Début : ${System.currentTimeMillis()}")\n\n    // Lance une coroutine avec un délai\n    launch {\n        delay(3000L) // attend 3 secondes\n        println("3 secondes écoulées : ${System.currentTimeMillis()}")\n        myDelayedFunction() // appelle la fonction souhaitée\n    }\n\n    println("En attente... (ceci s'exécute immédiatement)")\n}\n\nfun myDelayedFunction() {\n    println("Fonction exécutée !")

Important : delay() est une fonction suspendue (suspend function). Elle ne peut être appelée qu'à l'intérieur d'une coroutine ou d'une autre fonction suspendue. Si vous essayez d'appeler delay() en dehors d'une coroutine, le compilateur générera une erreur.

Comment faire un appel différé dans Android avec les coroutines

Dans le développement Android, les coroutines sont le standard de facto. Voici un exemple pour une Activity :

import androidx.appcompat.app.AppCompatActivity\nimport android.os.Bundle\nimport kotlinx.coroutines.*\n\nclass MainActivity : AppCompatActivity() {\n\n    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())\n\n    override fun onCreate(savedInstanceState: Bundle?) {\n        super.onCreate(savedInstanceState)\n        setContentView(R.layout.activity_main)\n\n        // Afficher un toast après 2 secondes\n        scope.launch {\n            delay(2000L)\n            showToast("2 secondes écoulées !")\n        }\n    }\n\n    private fun showToast(message: String) {\n        android.widget.Toast.makeText(this, message, android.widget.Toast.LENGTH_SHORT).show()\n    }\n\n    override fun onDestroy() {\n        super.onDestroy()\n        scope.cancel() // annule toutes les tâches lors de la destruction de l'Activity\n    }\n}

Notez que nous utilisons Dispatchers.Main pour travailler avec l'interface utilisateur. Et nous annulons obligatoirement le scope dans onDestroy() pour éviter les fuites mémoire.

Méthode 2 : Handler et postDelayed() (classique Android)

Si vous développez pour Android et que vous ne voulez pas (ou ne pouvez pas) utiliser les coroutines, le bon vieux Handler fonctionne toujours. Cette méthode était populaire avant l'ère des coroutines.

import android.os.Bundle\nimport android.os.Handler\nimport android.os.Looper\nimport androidx.appcompat.app.AppCompatActivity\n\nclass MainActivity : AppCompatActivity() {\n\n    private val handler = Handler(Looper.getMainLooper())\n\n    override fun onCreate(savedInstanceState: Bundle?) {\n        super.onCreate(savedInstanceState)\n        setContentView(R.layout.activity_main)