Installer Android Studio Otter 3 et configurer Kotlin pas à pas

Installer une chaîne d’outils Android moderne en 2026 demande un peu plus que cliquer sur « Next, Next, Finish ». Entre Android Studio Otter 3 Feature Drop, le JDK 17 embarqué, le choix du SDK Android, l’activation de KSP, la configuration mémoire de l’IDE et le branchement d’un device, chaque réglage compte sur le confort et la vitesse de développement. Ce tutoriel reprend l’installation pas à pas, du téléchargement initial jusqu’au premier Hello Compose qui tourne sur émulateur ou téléphone physique, en s’attardant sur les choix qui économiseront des heures plus tard. Une fois cette mise en place validée, les tutoriels suivants peuvent enchaîner les écrans Compose, le ViewModel, les appels réseau et la persistance sans se heurter à des problèmes d’environnement.

Prérequis

• OS : Windows 10/11 (64 bits), macOS 13 Ventura ou plus récent, ou Linux Ubuntu 22.04+ / Fedora 39+
• RAM : 16 Go recommandé (8 Go jouable sans émulateur)
• Disque : 30 Go libres sur SSD (SDK + Gradle + projets)
• Compte Google pour Play Console (création gratuite, frais d’inscription développeur de 25 USD en une seule fois quand vous publierez)
• Niveau : débutant en Android, à l’aise avec la ligne de commande
• Temps estimé : 60 à 90 minutes incluant les téléchargements

Étape 1 — Télécharger Android Studio Otter 3 Feature Drop

Android Studio est l’IDE officiel de Google pour le développement Android, basé sur IntelliJ IDEA. La version stable au 17 mai 2026 est Otter 3 Feature Drop, version 2025.2.3, sortie le 15 janvier 2026. Évitez les builds Canary ou Beta pour un environnement de travail : ils contiennent des nouveautés intéressantes mais aussi des bugs qui peuvent vous faire perdre une demi-journée. Le canal Stable suffit largement pour apprendre et produire des applications.

Rendez-vous sur developer.android.com/studio et téléchargez l’installateur correspondant à votre OS. Le fichier pèse environ 1,3 Go pour Windows, 1,1 Go pour macOS et 1,2 Go pour Linux. Le téléchargement inclut l’IDE mais pas le SDK Android, qui sera installé au premier lancement (compter 5 à 7 Go supplémentaires selon les composants choisis).

# Sur macOS, on peut aussi passer par Homebrew
brew install --cask android-studio

# Sur Linux Ubuntu, l'installation manuelle reste recommandée
# (Snap fonctionne mais les versions sont parfois en retard)
wget https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2025.2.3.X/android-studio-2025.2.3.X-linux.tar.gz
tar -xzf android-studio-2025.2.3.X-linux.tar.gz -C ~/
~/android-studio/bin/studio.sh

Vérifiez que le checksum SHA-256 affiché sur la page de téléchargement correspond bien au fichier reçu (shasum -a 256 fichier.dmg sur macOS ou certutil -hashfile fichier.exe SHA256 sur Windows). Cette vérification confirme que le binaire n’a pas été altéré pendant le transfert, surtout si vous téléchargez via une connexion partagée ou un proxy.

Étape 2 — Premier lancement et installation du SDK

Au premier lancement, Android Studio propose un assistant de configuration. Acceptez les options par défaut (installation standard) sauf sur deux écrans. Premièrement, le choix du SDK Android : cochez au minimum l’API 36 (Android 16, la cible 2026) et conservez l’API 24 (Android 7.0) comme minSdk pour couvrir 98 % des appareils en circulation. Deuxièmement, l’émulateur : laissez la case cochée si vous avez 16 Go de RAM, décochez si votre machine est plus modeste. Vous pourrez toujours l’installer après.

L’IDE télécharge ensuite les composants choisis. Sur une connexion 50 Mbps, comptez 15 à 20 minutes ; sur une 4G partagée à 5 Mbps, plutôt 90 minutes. Une fois l’installation terminée, Android Studio s’ouvre sur l’écran d’accueil avec trois options : New Project, Open, Get from VCS. Le SDK est désormais installé dans ~/Library/Android/sdk (macOS), %LOCALAPPDATA%\Android\Sdk (Windows) ou ~/Android/Sdk (Linux).

Pour vérifier l’installation depuis la ligne de commande, ajoutez le SDK à votre PATH puis appelez sdkmanager --list_installed. Vous devriez voir au minimum platform-tools, platforms;android-36, et build-tools;36.0.0. Si sdkmanager renvoie une erreur, vérifiez la variable d’environnement ANDROID_HOME qui doit pointer vers le dossier sdk.

Étape 3 — Créer un projet Compose

Cliquez sur New Project. Dans la liste des templates, choisissez Empty Activity sous l’onglet Phone and Tablet. Ce template configure automatiquement un projet Jetpack Compose minimal avec Material 3, le BOM Compose, et un point d’entrée MainActivity contenant un setContent { ... }. Pour démarrer un projet Compose en 2026, c’est le bon choix par défaut.

Remplissez les champs : Name (par exemple « HelloKotlin »), Package name (par exemple io.itskillscenter.hellokotlin, qui sert d’identifiant unique pour le Play Store), Save location, Language Kotlin, Build configuration language Kotlin DSL (build.gradle.kts, désormais standard et bien plus lisible que Groovy), Minimum SDK API 24. Cliquez sur Finish.

Android Studio synchronise alors Gradle, télécharge les dépendances déclarées (Compose, Material 3, AndroidX), et indexe le projet. Cette première synchronisation peut durer 5 à 10 minutes selon votre connexion. Surveillez la barre d’état en bas : tant qu’elle affiche « Indexing » ou « Sync in progress », attendez. Une fois terminé, la structure du projet s’affiche dans le panneau gauche : app/src/main/java contient le code Kotlin, app/src/main/res les ressources, et app/build.gradle.kts la configuration de build.

Étape 4 — Vérifier les versions Kotlin, AGP et Compose BOM

Ouvrez libs.versions.toml dans le dossier gradle/. Ce fichier centralise les versions des bibliothèques et plugins, et c’est le seul endroit à modifier pour aligner toute la stack. Vérifiez que les versions sont à jour au 17 mai 2026 :

[versions]
agp = "9.1.1"
kotlin = "2.3.21"
ksp = "2.3.8"
composeBom = "2026.05.00"
coreKtx = "1.17.0"
lifecycleRuntimeKtx = "2.10.0"
activityCompose = "1.13.0"
navigationCompose = "2.9.7"

Ces versions sont l’état stable du printemps 2026. AGP 9.1.1 fonctionne avec Gradle 9.1 et JDK 17. Kotlin 2.3.21 est nécessaire pour bénéficier de K2 stabilisé et de la compatibilité KSP2. Le Compose BOM 2026.05.00 aligne automatiquement compose-ui, compose-material3, compose-foundation sur la version 1.11.1 stable.

Si le projet généré par Android Studio utilise des versions plus anciennes, mettez à jour le fichier libs.versions.toml, puis cliquez sur Sync Now dans le bandeau qui apparaît en haut de l’éditeur. Une seconde synchronisation Gradle va se lancer. À l’issue de la synchronisation, l’arborescence External Libraries doit lister androidx.compose.ui:ui:1.11.1, signe que le BOM a bien aligné les versions.

Étape 5 — Activer KSP pour Room et Hilt

KSP (Kotlin Symbol Processing) est le successeur officiel de KAPT pour la génération de code à la compilation. Room 3.0 ne supporte plus que KSP, et Hilt s’est aligné. Comme votre projet va probablement utiliser Room et Hilt à terme, autant configurer KSP dès maintenant.

Dans libs.versions.toml, vérifiez la présence de la ligne ksp = "2.3.8" (KSP2 ne reprend plus la version Kotlin en suffixe comme KSP1 le faisait). Puis dans build.gradle.kts au niveau racine, déclarez le plugin KSP :

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.ksp) apply false
}

Dans le module app/build.gradle.kts, ajoutez id("com.google.devtools.ksp") au bloc plugins. Synchronisez de nouveau. La présence de KSP est confirmée par l’apparition d’une tâche kspDebugKotlin dans le panneau Gradle (côté droit). Vous n’aurez à utiliser concrètement KSP que quand vous ajouterez Room ou Hilt aux dépendances, mais la plomberie est en place.

Étape 6 — Configurer un émulateur ou un device physique

Pour tester votre application, deux options. L’émulateur d’Android Studio (Android Virtual Device, AVD) émule un téléphone complet et fonctionne bien sur Mac M1+, sur PC avec processeur récent et virtualisation activée dans le BIOS. Le device physique se branche en USB ou via Wi-Fi (debugging sans fil), et offre des performances réelles plus représentatives.

Pour créer un AVD : Tools → Device Manager → Create Virtual Device. Choisissez un Pixel 8 (modèle de référence), puis l’image système Android 16 (API 36) — Google APIs. Téléchargez l’image (1,5 Go environ), cliquez sur Finish. L’émulateur démarre en 30 à 60 secondes selon la machine. Une fois lancé, il consomme entre 2 et 4 Go de RAM, et entre 30 et 60 % d’un cœur CPU.

Pour un device physique, activez d’abord les options développeur sur le téléphone : Paramètres → À propos du téléphone → tapoter 7 fois sur le numéro de build. Puis dans Options développeur, activez Débogage USB. Branchez le téléphone, acceptez l’invite de confiance, et lancez adb devices dans un terminal pour confirmer la connexion. Votre téléphone apparaît dans Android Studio à côté de la liste d’émulateurs.

Étape 7 — Lancer le projet pour la première fois

Avec l’émulateur démarré ou le téléphone branché, cliquez sur le bouton vert Run (raccourci Maj+F10 sur Windows/Linux, Ctrl+R sur macOS). Gradle lance un build complet : compilation Kotlin, génération de l’APK debug, installation sur le device cible, lancement de l’activité principale. Le premier build est lent (2 à 5 minutes), les suivants prennent 10 à 30 secondes grâce à la compilation incrémentale.

Si tout fonctionne, l’application s’ouvre sur le device avec un écran « Hello Android! ». Vous venez de valider toute la chaîne : compilateur Kotlin, plugin Gradle, Compose, runtime Android. La barre d’outils en haut d’Android Studio affiche désormais le bouton Live Edit qui permet d’appliquer instantanément les changements d’UI sans relancer un build complet — un confort déterminant quand on itère sur des écrans Compose.

Pour confirmer que Compose est bien actif, ouvrez MainActivity.kt. Au-dessus de la fonction Greeting(...), vous voyez l’annotation @Preview. Cliquez sur l’icône d’œil dans la gouttière à gauche de la fonction : Android Studio affiche une preview interactive du composable dans un panneau dédié. Cette preview se met à jour à chaque sauvegarde et permet d’itérer sans relancer l’application.

Erreurs fréquentes au setup

Adapter la configuration à sa machine

Android Studio est gourmand. Sur 8 Go de RAM, désactivez l’émulateur et utilisez un téléphone physique. Augmentez la heap de l’IDE dans Help → Edit Custom VM Options : remplacez -Xmx2048m par -Xmx3072m si vous avez 16 Go, -Xmx4096m si vous avez 32 Go. La compilation Gradle se configure via gradle.properties avec org.gradle.jvmargs=-Xmx4g -XX:MaxMetaspaceSize=1g. Sur Mac M1/M2/M3, n’utilisez que des images émulateur ARM64 (les images x86_64 fonctionnent via Rosetta mais à vitesse réduite).

Pour les connexions limitées, configurez Gradle pour utiliser le cache local : ajoutez org.gradle.caching=true et org.gradle.parallel=true à gradle.properties. Une fois que vos dépendances sont en cache, les builds suivants ne téléchargent rien, ce qui économise la bande passante et accélère le développement. Le dossier de cache se trouve dans ~/.gradle/caches et fait typiquement 2 à 5 Go.

Foire aux questions

Faut-il IntelliJ IDEA Ultimate ?
Non. Android Studio est gratuit et basé sur IntelliJ IDEA Community + plugin Android officiel. Il offre tout ce qui est nécessaire pour le développement Android. IntelliJ Ultimate apporte des outils pour le développement web/serveur côté backend, mais n’est pas requis pour Android.

Quelle version de JDK utiliser ?
JDK 17 est embarqué dans Android Studio Otter 3 et est la version recommandée. AGP 9.1+ nécessite au minimum JDK 17. JDK 21 fonctionne aussi mais n’apporte rien de plus dans le contexte Android.

Faut-il Git installé séparément ?
Oui pour la majorité des cas. Android Studio peut interagir avec Git mais ne l’embarque pas. Installez Git depuis git-scm.com avant de cloner ou de versionner un projet.

Combien d’espace disque prévoir au total ?
L’installation initiale (Android Studio + SDK + un AVD + Gradle) occupe 12 à 15 Go. Chaque projet ajoute 1 à 3 Go (caches Gradle inclus). Prévoir 30 à 50 Go libres sur le disque pour travailler confortablement sur plusieurs projets.

Doit-on utiliser KMP dès le départ ?
Non. Kotlin Multiplatform ajoute de la complexité au setup et au build. Pour un premier projet Android, partir mono-plateforme est plus serein. KMP s’introduit ensuite quand le besoin de partager du code avec iOS apparaît concrètement.

Pourquoi mon build prend 5 minutes ?
Premier build : normal, Gradle télécharge et compile tout. Build suivant : si toujours 5 minutes, vérifier gradle.properties (parallèle, caching, daemon) et la RAM allouée. Sur 8 Go de RAM, le build sera toujours plus lent.

Pour aller plus loin

Maintenant que l’environnement est en place, l’étape suivante consiste à construire ses premiers écrans Compose avec gestion d’état, listes, navigation et thème Material 3. Le tutoriel Premiers écrans Compose reprend cette construction pas à pas. Pour une vue d’ensemble de l’écosystème Android natif en 2026 (Kotlin 2.3, architecture moderne, Jetpack), consultez le guide principal Kotlin et Jetpack Compose.

Ressources et références

• Télécharger Android Studio (officiel)
• Notes de version Android Studio
• Documentation KSP — JetBrains
• Android Gradle Plugin release notes
• Configurer l’émulateur Android