AsyncTask est mort dans Android 11 : 3 alternatives et erreurs typiques

AsyncTask est mort ? Vive les coroutines ! Guide complet de migration vers Kotlin

Si vous avez ouvert Android Studio ces dernières années, vous avez sûrement vu cet avertissement triste : AsyncTask is deprecated. Oui, ce fidèle assistant pour les tâches en arrière-plan qui nous sauvait depuis Android 1.5 est officiellement considéré comme obsolète à partir d'Android 11 (API 30).

Mais ne paniquez pas ! Google n'a pas « tué » AsyncTask pour rien. Il était rempli de bugs cachés, de fuites mémoire et de problèmes de cycle de vie. Dans cet article, nous analyserons les principales erreurs lors de la migration depuis AsyncTask et montrerons quels outils modernes l'ont remplacé. Vous apprendrez à écrire un code propre, sûr et performant en Kotlin sans maux de tête.

Pourquoi AsyncTask est-il devenu un problème ? (Petit rappel)

Avant de chercher des alternatives, rappelons ce qui rendait AsyncTask si « agaçant » :

• Fuites mémoire : Si une Activity est détruite (rotation d'écran) alors qu'AsyncTask est encore en cours, il conserve une référence à l'ancienne Activity que le GC ne peut pas collecter.
• Complexité du cycle de vie : L'exécution de la tâche n'est pas liée au cycle de vie du composant. Le résultat peut arriver dans une Activity déjà détruite.
• Exécution séquentielle : Sur Android 3.0+, AsyncTask s'exécute par défaut séquentiellement dans un seul thread, ce qui tue toute idée de parallélisme.
• Absence d'annulation : La méthode cancel() fonctionne mal et ne stoppe souvent pas le thread.

Maintenant que nous avons rappelé ces douleurs, passons aux solutions modernes proposées par Kotlin et Android Jetpack.

Top 3 des alternatives à AsyncTask dans Android 11+ (Kotlin)

Au lieu de réinventer la roue, utilisons des outils éprouvés. Voici les meilleurs remplacements d'AsyncTask que vous devez connaître :

1. Kotlin Coroutines (Coroutines) — Le principal tueur d'AsyncTask

C'est la méthode la plus moderne et recommandée par Google. Les coroutines sont légères, sûres et s'intègrent parfaitement avec Jetpack (ViewModel, LiveData, Room).

Exemple : Chargement de données depuis le réseau (remplacement d'AsyncTask)

Au lieu d'écrire :

// Ancien AsyncTask (NE FAITES PAS CELA)class MyAsyncTask : AsyncTask<String, Void, String>() {    override fun doInBackground(vararg params: String?): String {        // Opération longue        Thread.sleep(3000)        return "Result"    }    override fun onPostExecute(result: String?) {        textView.text = result    }}

Utilisez maintenant les coroutines :

// Nouvelle approche avec Kotlin Coroutinesclass MyViewModel : ViewModel() {    private val _result = MutableLiveData<String>()    val result: LiveData<String> = _result

    fun fetchData() {        viewModelScope.launch {            // Exécution en arrière-plan            val data = withContext(Dispatchers.IO) {                // Simulation d'une opération longue                delay(3000)                "Result from Coroutine"            }            // Retour automatique sur le thread principal            _result.value = data        }    }}

Pourquoi c'est génial ? viewModelScope annule automatiquement la coroutine lorsque le ViewModel est détruit. Pas de fuites ! Et withContext(Dispatchers.IO) change le contexte d'exécution. Le code se lit comme synchrone, mais fonctionne de manière asynchrone.

2. RxJava / RxKotlin — Approche réactive

Si vous aimez les flux de données et les opérateurs, RxJava reste un outil puissant. Cependant, pour des tâches simples, il est excessif. Utilisez-le si le projet utilise déjà Rx.

Exemple : Single au lieu d'AsyncTask

// Alternative à AsyncTask avec RxJavaclass DataRepository {    fun fetchData(): Single<String> {        return Single.fromCallable {            // Travail en arrière-plan