Développement Android avec Cursor : Configuration et astuces

Le développement Android a traditionnellement été lié à Android Studio, l'IDE officiel de Google basé sur IntelliJ IDEA. Cursor, étant un fork de VS Code avec des capacités IA, offre une expérience différente -- qui échange certains outils spécifiques à Android pour une assistance IA puissante. Ce guide explique comment configurer Cursor pour le développement Android, quand cela a du sens de l'utiliser, et où Android Studio reste essentiel.

Android Studio vs Cursor : Ce que vous gagnez et perdez

Avant de passer à Cursor pour le travail Android, comprenez les compromis :

Fonctionnalité	Android Studio	Cursor
Éditeur de Layout (XML visuel)	Oui	Non
Intégration de l'émulateur	Intégré	Externe
Sync & build Gradle	Natif	Terminal uniquement
Visionneuse Logcat	Intégré	Non
Analyseur APK	Intégré	Non
Inspecteur de base de données	Intégré	Non
Assistance code IA	Basique (Gemini)	Avancée (Claude, GPT)
Chat en langage naturel	Non	Oui
Modifications multi-fichiers Composer	Non	Oui
Extensions VS Code	Non	Oui
Raccourcis clavier personnalisables	Limité	Complet

La décision n'est pas binaire. De nombreux développeurs utilisent Cursor pour écrire du code et Android Studio pour builder, déboguer et exécuter l'émulateur.

Configurer Cursor pour le développement Android

1. Installer les extensions requises

Cursor supporte les extensions VS Code. Pour le développement Android, installez celles-ci :

1. Ouvrez Cursor
2. Allez dans Extensions (Ctrl+Shift+X / Cmd+Shift+X)
3. Recherchez et installez :
   • Kotlin Language par mathiasfrohlich -- coloration syntaxique et IntelliSense basique
   • Kotlin par fwcd -- support Kotlin avancé (choisissez-en un)
   • Android iOS Emulator par DiemasMichiels -- lanceur d'émulateurs
   • Gradle Language Support -- pour les fichiers build.gradle et settings.gradle
   • XML Tools -- pour le manifeste Android et les fichiers de layout

// Extensions recommandées dans .vscode/extensions.json
{
  "recommendations": [
    "mathiasfrohlich.kotlin",
    "vscjava.vscode-gradle",
    "redhat.vscode-xml",
    "diemasmichiels.emulator"
  ]
}

2. Ouvrir votre projet Android

Vous pouvez ouvrir un projet Android dans Cursor comme n'importe quel autre dossier :

# Naviguez vers votre projet
cd ~/Projects/MyAndroidApp

# Ouvrir dans Cursor
cursor .

Fichiers Gradle

Cursor peut éditer les fichiers .gradle et .kts, mais il ne peut pas synchroniser Gradle ou résoudre les dépendances comme le fait Android Studio. Vous exécuterez les commandes Gradle depuis le terminal.

3. Configurer les tâches de build Gradle

Configurez les tâches VS Code pour les opérations Gradle courantes :

// .vscode/tasks.json
{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Build Debug APK",
      "type": "shell",
      "command": "./gradlew",
      "args": ["assembleDebug"],
      "group": {
        "kind": "build",
        "isDefault": true
      }
    },
    {
      "label": "Run Tests",
      "type": "shell",
      "command": "./gradlew",
      "args": ["test"]
    },
    {
      "label": "Install Debug APK",
      "type": "shell",
      "command": "./gradlew",
      "args": ["installDebug"]
    },
    {
      "label": "Clean Build",
      "type": "shell",
      "command": "./gradlew",
      "args": ["clean"]
    }
  ]
}

Exécutez les tâches avec Ctrl+Shift+B (Cmd+Shift+B sur macOS).

Configuration Gradle dans Cursor

Gradle est l'épine dorsale des builds Android. Dans Android Studio, la sync Gradle se fait automatiquement. Dans Cursor, vous la gérez manuellement.

Commandes Gradle courantes

# Build le projet
./gradlew build

# Build l'APK debug
./gradlew assembleDebug

# Build l'APK release
./gradlew assembleRelease

# Lancer les tests unitaires
./gradlew test

# Lancer les tests instrumentés
./gradlew connectedAndroidTest

# Nettoyer les artifacts de build
./gradlew clean

# Voir toutes les tâches disponibles
./gradlew tasks

Problèmes de Gradle Wrapper

Si le script wrapper n'est pas exécutable :

chmod +x gradlew

Sur Windows, utilisez gradlew.bat au lieu de ./gradlew.

Gestion des dépendances

Lorsque vous ajoutez une dépendance à build.gradle ou build.gradle.kts, Cursor ne sync pas automatiquement. Vous devez exécuter :

./gradlew build

Ou utilisez le daemon Gradle pour des builds subséquents plus rapides :

./gradlew --daemon build

Daemon Gradle

Le daemon Gradle reste résident en mémoire et accélère significativement les builds. Activez-le par défaut en créant un fichier gradle.properties dans ~/.gradle/ avec org.gradle.daemon=true.

Intégration de l'émulateur

Cursor n'a pas d'émulateur intégré comme Android Studio. Vous avez deux options :

Option 1 : Lancer l'émulateur depuis le terminal

# Lister les émulateurs disponibles
emulator -list-avds

# Lancer un émulateur spécifique
emulator -avd Pixel_7_API_34

Ajoutez ceci comme tâche VS Code pour un accès rapide :

{
  "label": "Launch Emulator",
  "type": "shell",
  "command": "emulator",
  "args": ["-avd", "Pixel_7_API_34"]
}

Option 2 : Utiliser l'extension Emulator

L'extension Android iOS Emulator par DiemasMichiels ajoute un lanceur d'émulateur à la barre d'état de Cursor.

1. Installez l'extension
2. Cliquez sur l'icône de l'émulateur dans la barre d'état
3. Sélectionnez votre AVD dans la liste déroulante

Option 3 : Garder Android Studio ouvert

De nombreux développeurs gardent simplement Android Studio ouvert pour l'émulateur et Logcat, tout en éditant le code dans Cursor. C'est l'approche la plus fiable.

Support Kotlin et Java

Cursor gère bien le Kotlin et le Java, mais le support Kotlin est plus fort grâce aux outils communautaires.

Kotlin

• La coloration syntaxique fonctionne avec l'extension Kotlin
• L'autocomplétion Tab de Cursor est efficace pour les idiomes Kotlin
• Le chat IA comprend les coroutines Kotlin, Flow et Compose

Exemple de prompt pour Kotlin :

"Créez un ViewModel en Kotlin qui récupère les données utilisateur en utilisant
Retrofit et les expose en tant que StateFlow. Gérez les états de chargement et d'erreur."

Java

• Le support Java dans Cursor est excellent (VS Code a des extensions Java matures)
• Vous pouvez installer le Extension Pack for Java par Microsoft pour des fonctionnalités IDE complètes
• L'IA de Cursor fonctionne aussi bien avec Java et Kotlin

// Pour un support Java complet
{
  "recommendations": [
    "vscjava.vscode-java-pack"
  ]
}

Android Jetpack Compose

Jetpack Compose est où Cursor brille. Puisque Compose est uniquement en code (pas de layouts XML), l'UI entière peut être écrite et affinée dans Cursor :

@Composable
fun UserProfileCard(user: User) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp),
        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
    ) {
        Column(modifier = Modifier.padding(16.dp)) {
            Text(text = user.name, style = MaterialTheme.typography.headlineSmall)
            Text(text = user.email, style = MaterialTheme.typography.bodyMedium)
        }
    }
}

Cursor peut générer, refactoriser et expliquer le code Compose efficacement car c'est du pur Kotlin.

Le workflow double IDE

Basé sur les retours de la communauté, la configuration la plus productive pour le développement Android est :

Tâche	Outil	Raison
Écrire du code Kotlin/Java	Cursor	Assistance IA, meilleure édition
Éditer les layouts XML	Les deux	Cursor fonctionne ; Android Studio a l'aperçu
Build et déploiement	Android Studio	Sync Gradle fiable et émulateur
Débogage avec points d'arrêt	Android Studio	Débogueur et Logcat supérieurs
Développement UI Compose	Cursor	Uniquement du code, pas d'aperçu nécessaire
Profiling et analyse	Android Studio	Profileurs CPU/mémoire/réseau

Workflow recommandé

1. Ouvrez le projet dans les deux IDE
2. Éditez le code dans Cursor -- utilisez le chat pour les explications, Composer pour les refactors
3. Build dans Android Studio -- cliquez sur le bouton run pour le déploiement sur l'émulateur
4. Déboguez dans Android Studio -- utilisez Logcat et le débogueur
5. Commit depuis l'un ou l'autre -- les deux IDE détectent les changements de fichiers via le système de fichiers

Limitations

Ce que Cursor ne peut pas faire pour Android

Limitation	Impact	Solution alternative
Pas d'éditeur de Layout	Ne peut pas éditer visuellement le XML	Éditez le XML manuellement ou utilisez Android Studio
Pas d'émulateur intégré	Ne peut pas exécuter d'apps directement	Utilisez le terminal ou gardez Android Studio ouvert
Pas de visionneuse Logcat	Ne peut pas voir les logs	Utilisez adb logcat dans le terminal ou Android Studio
Pas d'analyseur APK	Ne peut pas inspecter les APK	Utilisez le Build Analyzer d'Android Studio
Pas d'inspecteur de base de données	Ne peut pas inspecter les bases Room	Utilisez Android Studio ou Stetho
Sync Gradle non automatique	Doit lancer les builds manuellement	Utilisez le terminal ou les raccourcis de tâches

Problèmes connus

Problème : L'extension Kotlin affiche des erreurs pour du code valide

Solution : L'extension Kotlin pour VS Code n'est pas aussi mature que celle d'Android Studio. Certaines erreurs sont des faux positifs. Fiez-vous aux builds Gradle pour le vrai statut de compilation.

Problème : L'aperçu Compose ne fonctionne pas

Solution : L'aperçu Compose d'Android Studio n'est pas disponible dans Cursor. Utilisez l'émulateur ou build l'app pour voir les changements d'UI.

Problème : Les références R.java s'affichent comme non résolues

Solution : Exécutez ./gradlew build une fois pour que le code généré soit créé. L'extension Kotlin peut toujours afficher des avertissements, mais le code compile.

Bonnes pratiques

1. Utilisez Compose quand c'est possible

Jetpack Compose élimine le besoin d'édition de layout XML, rendant Cursor un éditeur primaire beaucoup plus viable pour le travail UI Android.

2. Créez des scripts shell pour les tâches courantes

Automatisez les commandes Gradle répétitives :

#!/bin/bash
# scripts/build.sh
./gradlew clean assembleDebug && adb install app/build/outputs/apk/debug/app-debug.apk

3. Utilisez ADB depuis le terminal

Apprenez les commandes ADB pour des interactions rapides avec l'appareil :

# Installer l'APK
adb install app/build/outputs/apk/debug/app-debug.apk

# Voir les logs pour votre app
adb logcat -s "MyAppTag:D"

# Effacer les données de l'app
adb shell pm clear com.example.myapp

# Capture d'écran
adb shell screencap -p /sdcard/screen.png
adb pull /sdcard/screen.png

4. Exploitez l'IA de Cursor pour le code répétitif

Android implique beaucoup de code répétitif. Utilisez Cursor pour générer :

• Adaptateurs RecyclerView
• Interfaces de service Retrofit
• Entités et DAOs de base de données Room
• Fabriques de ViewModel
• Modules Dagger/Hilt

Prompt Cursor :
"Générez une entité de base de données Room pour un élément Todo avec id, title,
description, dueDate et isCompleted. Incluez le DAO avec les opérations CRUD
et une requête pour obtenir les todos complétés."

Résumé

Cursor est un outil viable pour le développement Android, particulièrement pour les projets Kotlin et Jetpack Compose. Ce n'est pas un remplacement complet d'Android Studio, mais il excelle dans l'écriture de code, le refactoring et le développement assisté par IA.

Points clés :

• Installez les extensions Kotlin et Gradle pour les fonctionnalités IDE de base dans Cursor
• Utilisez les commandes Gradle depuis le terminal -- il n'y a pas de sync automatique
• Lancez l'émulateur depuis le terminal ou utilisez l'extension Emulator
• Le workflow double IDE (Cursor pour le code, Android Studio pour le build/debug) est le plus fiable
• Les projets Jetpack Compose fonctionnent le mieux dans Cursor car ils sont uniquement en code
• Vérifiez toujours les builds dans Android Studio avant de release

Si votre workflow dépend fortement de l'édition visuelle de layout, du débogage approfondi ou du profiling, Android Studio reste essentiel. Pour l'écriture de code pure avec assistance IA, Cursor est une forte alternative.

---

Dernière mise à jour : Juin 2025