Android Emulator — qu'est-ce que c'est et comment fonctionne l'émulation

Qu'est-ce que Android Emulator ?

Android Emulator est un appareil Android virtuel fonctionnant sur QEMU (Quick EMUlator) qui émule la plateforme matérielle Android. Contrairement à iOS Simulator, Android Emulator traduit complètement les instructions ARM, permettant au code compilé pour l'architecture mobile de s'exécuter sur un hôte x86_64.

Google a publié Android Emulator en 2007 avec la première version de l'Android SDK. Depuis, l'émulateur est passé d'une solution lente uniquement ARM à un système haute performance avec prise en charge GPU, accélération matérielle et émulation de capteurs. Selon Google (Android Developer Blog, 2025), l'émulateur moderne avec HAxM fonctionne 4 à 5 fois plus vite que la première génération.

L'émulateur prend en charge tous les composants d'un appareil Android : CPU, GPU, RAM, stockage, écran tactile, accéléromètre, gyroscope, GPS, caméra, batterie, NFC, Bluetooth et Wi-Fi. Le développeur peut simuler des appels entrants, des SMS, différents niveaux de signal réseau et la géolocalisation via Extended Controls.

Images système pour l'émulateur

Android Emulator utilise des images système téléchargées via le SDK Manager. Chaque image système contient une copie complète du firmware Android pour le niveau d'API et l'architecture de processeur cible sélectionnés. Des images sont disponibles avec différentes architectures : x86_64 (recommandée avec HAxM), ARM64 (pour les tests de compatibilité ARM) et Google APIs (avec Google Play Services préinstallés). Des images séparées sont également disponibles pour Wear OS, Android TV et Automotive.

// Vérification du type d'émulateur dans le code
val isEmulator = Build.FINGERPRINT
    .contains("generic") ||
    Build.PRODUCT.contains("sdk")

if (isEmulator) {
    Timber.d("L'application s'exécute dans l'émulateur")
}

Configuration d'AVD dans Android Studio

AVD (Android Virtual Device) est une configuration d'appareil virtuel pour l'émulateur. Le AVD Manager dans Android Studio permet de créer des appareils avec n'importe quelle combinaison de caractéristiques : modèle, taille d'écran, densité de pixels, quantité de RAM, taille de stockage et version d'Android.

Création d'AVD s'effectue via le Device Manager dans Android Studio : sélectionnez un profil matériel (Pixel, Nexus, Galaxy et autres), une image système et configurez les paramètres. Après la création, l'appareil apparaît dans la liste Run Configurations pour un lancement immédiat de l'application.

Mode Snapshot pour un démarrage rapide

L'émulateur prend en charge Quick Boot — il sauvegarde l'état de l'AVD sous forme de snapshot et le restaure au prochain démarrage. Le temps de démarrage passe de 30 à 60 secondes à 2 à 5 secondes. Pour réinitialiser à un état propre, utilisez Cold Boot Now dans AVD Manager.

Traduction ARM et accélération matérielle

Traduction ARM est une technologie clé d'Android Emulator qui convertit les instructions ARM en x86_64 à la volée. Sans traduction, l'émulateur ne pourrait exécuter que des images x86_64, limitant les tests. Google utilise libhoudini pour la traduction ARM→x86 et les bibliothèques Intel pour l'accélération HAXM.

# Vérification du statut HAxM sur Windows
sc query "IntelHaxm"

# Installation de HAxM via le SDK Manager
sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"

# Démarrage de l'émulateur avec accélération matérielle
emulator -avd Pixel_9_API_35 -accel on -gpu auto

Intel HAxM (Hardware Accelerated Execution Manager) est un pilote de virtualisation pour les processeurs Intel VT-x qui accélère l'émulateur de 3 à 5 fois. Sous Windows avec un processeur AMD, utilisez Windows Hyper-V Platform et WHPX. Sans accélération matérielle, l'émulateur fonctionne lentement, avec des retards d'animation allant jusqu'à 1 à 2 secondes.

Sous macOS avec Apple Silicon (série M), l'accélération matérielle fonctionne nativement via Hypervisor.framework. Selon Google (Android Emulator Release Notes 2025), l'émulateur sur M2 Max atteint 95 % des performances d'un appareil réel pour les opérations de base.

Émulateur vs appareil réel

Le choix entre émulateur et appareil réel dépend de l'étape de développement. Sur l'émulateur, il est pratique de développer et déboguer : démarrage rapide, déploiement instantané, Extended Controls pour la simulation de capteurs. Sur un appareil réel — tests finaux de performance, batterie et fonctionnement avec le matériel.

Les performances de l'émulateur avec accélération matérielle sont souvent supérieures à celles d'un appareil réel d'entrée de gamme. Par conséquent, effectuez les tests finaux sur des appareils réels avec le niveau de performance cible.

Vérification de l'émulateur dans le code Kotlin

Détecter l'environnement d'exécution en Kotlin est utile pour désactiver du code incorrect ou ajouter des informations de débogage. Android fournit Build.FINGERPRINT, Build.PRODUCT et Build.HARDWARE à cette fin.

object EmulatorDetector {
    val isEmulator: Boolean
        get() = Build.FINGERPRINT.startsWith("generic")
                || Build.FINGERPRINT.contains("emulator")
                || Build.HARDWARE == "ranchu"
                || Build.HARDWARE == "goldfish"
    
    fun logEnvironment() {
        if (isEmulator) {
            Log.d("EmulatorDetector", "Environnement : émulateur")
        }
    }
}

Utiliser un détecteur d'émulateur aide lors du débogage : sur l'émulateur vous pouvez activer des journaux avancés, désactiver les animations ou remplacer les appels API réels par des mocks. Évitez la vérification dans les versions de production sauf si nécessaire pour la logique métier de l'application.

Test d'applications sur l'émulateur

Android Emulator est utilisé pour les tests automatisés sur les serveurs CI. Pour exécuter des tests, vous devez créer un AVD, démarrer l'émulateur et attendre le chargement complet du système. Gradle Managed Devices simplifie ce processus : la configuration de l'AVD est décrite dans build.gradle.kts.

// build.gradle.kts — Gradle Managed Devices
android {
    testOptions {
        managedDevices {
            devices {
                register<ManagedVirtualDevice>("pixel9Api35") {
                    device = "Pixel 9"
                    apiLevel = 35
                    systemImageSource = "google"
                }
            }
        }
    }
}

Pour démarrer l'émulateur manuellement, utilisez la ligne de commande : emulator -avd Pixel_9_API_35 -no-window -no-audio -gpu swiftshader_indirect. Le flag -no-window désactive l'interface graphique pour les environnements serveur, et -gpu swiftshader_indirect fournit un rendu logiciel sans GPU hôte.

Émulation réseau et de capteurs

Extended Controls dans Android Emulator fournit des outils puissants pour simuler les conditions réseau : latence, bande passante et type de réseau (GPRS, EDGE, 3G, 4G, 5G). Cela permet de tester le comportement de l'application en connexion lente sans se déplacer physiquement dans une zone à faible couverture.

Simulation de capteurs comprend accéléromètre, gyroscope et magnétomètre via des modèles 3D virtuels d'appareils. Pour le GPS, vous pouvez charger des fichiers GPX avec des itinéraires — l'émulateur simule le mouvement le long des coordonnées, ce qui est essentiel pour tester les applications de navigation. La caméra est émulée via la webcam de l'hôte ou le chargement d'images.

Multi-écran dans Android Emulator prend en charge plusieurs écrans pour les tablettes et les appareils pliables. Extended Controls permet de modifier l'orientation, la taille d'écran et la densité de pixels (DPI) sans redémarrer l'émulateur. Pour tester les appareils pliables, des modes Foldable sont disponibles avec commutation entre état plié et déplié.

Android Emulator pour Wear OS et Android TV

L'émulateur prend en charge non seulement les smartphones, mais aussi Wear OS et Android TV. Pour Wear OS, des configurations AVD rondes et rectangulaires sont disponibles, la simulation de rotation de la lunette et les gestes de balayage, ainsi que les tests d'interaction avec un émulateur téléphonique. Pour Android TV, une interface avec navigation D-pad est utilisée. Les deux plateformes prennent en charge l'accélération matérielle et les tests avec Google Play Services, ce qui est important pour le cycle de développement des applications de montres connectées et TV.