Comment exécuter du code synchrone et obtenir son résultat?

Vous pouvez utiliser un appel bloquant dans un thread séparé, par exemple via Thread ou AsyncTask (bien que ce dernier soit obsolète).

// Exemple avec Thread
fun performBlockingOperation(): String {
    // Simulation d'une opération longue
    Thread.sleep(2000)
    return "Résultat de l'opération synchrone"
}

fun runSynchronousCode() {
    // Créer un nouveau thread
    val thread = Thread {
        try {
            val result = performBlockingOperation()
            // Le résultat peut être renvoyé au thread principal
            // via Handler ou runOnUiThread
            println("Résultat obtenu : $result")
        } catch (e: Exception) {
            println("Erreur : ${e.message}")
        }
    }
    // Démarrer le thread
    thread.start()

    // Si vous souhaitez obtenir le résultat dans le thread UI
    // Handler(Looper.getMainLooper()).post {
    //    // Mise à jour de l'UI
    // }
}

Une approche moderne alternative consiste à utiliser des coroutines avec des dispatchers bloquants (bien que cela ne soit pas la meilleure option pour le thread UI).

import kotlinx.coroutines.*

suspend fun performBlockingCoroutineOperation(): String {
    // Simulation d'une opération longue
    delay(2000)
    return "Résultat de l'opération dans la coroutine"
}

fun runBlockingCoroutine() {
    // Lancer une coroutine bloquante
    runBlocking {
        try {
            val result = performBlockingCoroutineOperation()
            println("Résultat de la coroutine : $result")
        } catch (e: Exception) {
            println("Erreur dans la coroutine : ${e.message}")
        }
    }
}

Il est important d'éviter les appels bloquants dans le thread principal de l'UI (Main Thread) pour prévenir les ANR (Application Not Responding).