Android Emulator — ce este și cum funcționează emularea

Ce este Android Emulator?

Android Emulator — un dispozitiv virtual Android care rulează pe baza QEMU (Quick EMUlator) și emulează platforma hardware Android. Spre deosebire de iOS Simulator, Android Emulator translatează complet instrucțiunile ARM, permițând rularea codului compilat pentru arhitectura mobilă pe un gazdă x86_64.

Google a lansat Android Emulator în 2007 împreună cu prima versiune a Android SDK. De atunci, emulatorul a evoluat de la o soluție lentă doar pentru ARM la un sistem de înaltă performanță cu suport pentru GPU, accelerare hardware și emulare a senzorilor. Potrivit Google (Android Developer Blog, 2025), emulatorul modern cu HAxM funcționează de 4-5 ori mai rapid decât prima generație.

Emulatorul suportă toate componentele unui dispozitiv Android: CPU, GPU, RAM, stocare, ecran tactil, accelerometru, giroscop, GPS, cameră, baterie, NFC, Bluetooth și Wi-Fi. Dezvoltatorul poate simula apeluri primite, SMS-uri, diferite niveluri ale semnalului de rețea și geolocație prin Extended Controls.

Imagini de sistem pentru emulator

Android Emulator utilizează imagini de sistem (System Images) care se descarcă prin SDK Manager. Fiecare imagine de sistem conține o copie completă a firmware-ului Android pentru nivelul API selectat și arhitectura procesorului țintă. Sunt disponibile imagini cu arhitecturi diferite: x86_64 (recomandat cu HAxM), ARM64 (pentru testarea compatibilității ARM) și Google APIs (cu Google Play Services preinstalate). Pentru Wear OS, Android TV și Automotive există, de asemenea, imagini separate.

// Verificarea tipului de emulator în cod
val isEmulator = Build.FINGERPRINT
    .contains("generic") ||
    Build.PRODUCT.contains("sdk")

if (isEmulator) {
    Timber.d("Aplicația rulează în emulator")
}

Configurarea AVD în Android Studio

AVD (Android Virtual Device) — configurația dispozitivului virtual pentru emulator. AVD Manager din Android Studio permite crearea de dispozitive cu orice combinație de caracteristici: model, dimensiunea ecranului, densitatea pixelilor, cantitatea de RAM, dimensiunea stocării și versiunea Android.

Crearea AVD se realizează prin Device Manager în Android Studio: selectați profilul hardware (Pixel, Nexus, Galaxy și altele), imaginea de sistem și configurați parametrii. După creare, dispozitivul apare în lista Run Configurations pentru rularea directă a aplicației.

Modul Snapshot pentru pornire rapidă

Emulatorul suportă Quick Boot — salvează starea AVD ca snapshot și o restabilește la următoarea pornire. Timpul de încărcare se reduce de la 30-60 de secunde la 2-5 secunde. Pentru resetarea la starea curată, utilizați Cold Boot Now în AVD Manager.

Translația ARM și accelerarea hardware

Translația ARM — tehnologia cheie a Android Emulator, care convertește instrucțiunile ARM în x86_64 din mers. Fără translare, emulatorul ar putea rula doar imagini x86_64, ceea ce limitează testarea. Google folosește libhoudini pentru translarea ARM→x86 și bibliotecile Intel pentru accelerarea HAXM.

# Verificarea stării HAxM pe Windows
sc query "IntelHaxm"

# Instalarea HAxM prin SDK Manager
sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"

# Pornirea emulatorului cu accelerare hardware
emulator -avd Pixel_9_API_35 -accel on -gpu auto

Intel HAxM (Hardware Accelerated Execution Manager) — driver de virtualizare pentru procesoarele Intel VT-x, care accelerează emulatorul de 3-5 ori. Pe Windows cu procesor AMD, utilizați Windows Hyper-V Platform și WHPX. Fără accelerare hardware, emulatorul funcționează lent, cu întârzieri ale animațiilor de până la 1-2 secunde.

Pentru macOS pe Apple Silicon (seria M), accelerarea hardware funcționează nativ prin Hypervisor.framework. Potrivit Google (Android Emulator Release Notes 2025), emulatorul pe M2 Max atinge 95% din performanța unui dispozitiv real pentru operațiile de bază.

Emulator vs dispozitiv real

Alegerea între emulator și dispozitiv real depinde de etapa de dezvoltare. Pe emulator este convenabil să dezvoltați și să depanați: pornire rapidă, deploy instantaneu, Extended Controls pentru simularea senzorilor. Pe dispozitivul real — testarea finală a performanței, bateriei și a funcționării cu hardware-ul.

Performanța emulatorului cu accelerare hardware este adesea mai mare decât cea a unui dispozitiv real bugetar. De aceea, testele finale se efectuează pe dispozitive reale cu nivelul de performanță țintă.

Detectarea emulatorului în cod Kotlin

Determinarea mediului de execuție în Kotlin este utilă pentru dezactivarea codului incorect sau adăugarea de informații de depanare. Android oferă Build.FINGERPRINT, Build.PRODUCT și Build.HARDWARE în acest scop.

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", "Mediu: emulator")
        }
    }
}

Utilizarea detectorului de emulator ajută la depanare: pe emulator puteți activa loguri extinse, dezactiva animațiile sau înlocui apelurile API reale cu mock-uri. Evitați verificarea în versiunile de producție, dacă aceasta nu este necesară pentru logica de business a aplicației.

Testarea aplicațiilor pe emulator

Android Emulator este utilizat pentru testarea automatizată pe servere CI. Pentru a rula testele, este necesar să creați un AVD, să porniți emulatorul și să așteptați încărcarea completă a sistemului. Gradle Managed Devices simplifică acest proces: configurația AVD este descrisă în build.gradle.kts.

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

Pentru pornirea manuală a emulatorului, utilizați linia de comandă: emulator -avd Pixel_9_API_35 -no-window -no-audio -gpu swiftshader_indirect. Flag-ul -no-window dezactivează interfața grafică pentru mediul server, iar -gpu swiftshader_indirect asigură randarea software fără GPU-ul gazdei.

Emularea rețelei și a senzorilor

Extended Controls în Android Emulator oferă instrumente puternice pentru simularea condițiilor de rețea: întârziere (latency), lățime de bandă (bandwidth) și tip de rețea (GPRS, EDGE, 3G, 4G, 5G). Acest lucru permite testarea comportamentului aplicației la conexiune lentă fără a călători fizic într-o zonă cu acoperire slabă.

Simularea senzorilor include accelerometru, giroscop și magnetometru prin modele 3D virtuale ale dispozitivelor. Pentru GPS, puteți încărca fișiere GPX cu rute — emulatorul simulează mișcarea pe coordonate, ceea ce este esențial pentru testarea aplicațiilor de navigație. Camera este emulată prin webcam-ul gazdei sau încărcarea de imagini.

Multi-display în Android Emulator suportă mai multe ecrane pentru tablete și dispozitive pliabile. Extended Controls permit schimbarea orientării, dimensiunii ecranului și densității pixelilor (DPI) fără repornirea emulatorului. Pentru testarea dispozitivelor pliabile, sunt disponibile moduri Foldable cu comutare între starea pliată și desfășurată.

Android Emulator pentru Wear OS și Android TV

Emulatorul suportă nu numai smartphone-uri, ci și Wear OS și Android TV. Pentru Wear OS sunt disponibile configurații AVD rotunde și dreptunghiulare, simularea rotirii bezel-ului și gesturilor de swipe, precum și testarea interacțiunii cu emulatorul de telefon. Pentru Android TV se utilizează o interfață cu navigare D-pad. Ambele platforme suportă accelerarea hardware și testarea cu Google Play Services, ceea ce este important pentru ciclul de dezvoltare al ceasurilor inteligente și aplicațiilor TV.