AVD Android: ce este, Android Virtual Device și cum se configurează emulatorul

Ce este AVD

AVD (Android Virtual Device) — este o configurație software care descrie un dispozitiv virtual Android. Spre deosebire de un telefon fizic, AVD nu necesită hardware — rulează pe computer prin emulatorul Android bazat pe QEMU. Dezvoltatorul creează câte AVD-uri sunt necesare pentru testare: pentru diferite versiuni Android, dimensiuni de ecran, cantități de memorie și densități de pixeli.

Fiecare AVD este legat de o anumită SDK Platform. Aceasta înseamnă că pentru a crea un AVD cu Android 14 (API Level 34) trebuie mai întâi să instalați System Image a acestei versiuni prin SDK Manager. System Image este o imagine a sistemului de operare care include toate aplicațiile de sistem, serviciile Google (dacă a fost selectată imaginea Google APIs) și componentele runtime. Google recomandă utilizarea imaginilor Google APIs cu servicii Google Play pentru compatibilitate maximă cu dispozitivele reale.

AVD este indispensabil în dezvoltare din mai multe motive. În primul rând, permite testarea aplicației pe diferite versiuni Android fără a cumpăra zeci de dispozitive. În al doilea rând, AVD suportă Snapshots — salvarea stării sistemului, ceea ce accelerează pornirea. În al treilea rând, emulatorul este integrat cu Android Studio: instalarea APK, depanarea și logarea funcționează la fel ca pe un dispozitiv fizic.

Tipuri de dispozitive virtuale

AVD suportă diferite tipuri de dispozitive: telefoane (Phone), tablete (Tablet), ceasuri (Wear OS), televizoare (Android TV) și sisteme auto (Android Automotive). Pentru fiecare tip, AVD Manager oferă profiluri gata făcute de la Google: Pixel 8, Pixel 9 Pro, Nexus 7, Samsung Galaxy Tab și altele. Profilul dispozitivului stabilește dimensiunea ecranului, rezoluția, densitatea pixelilor (dpi) și navigația (gesturi sau butoane).

Din ce este format AVD

Fiecare AVD este un set de fișiere de configurare și imagini. Fișierul principal de configurare — config.ini, care stochează parametrii dispozitivului virtual: nume, tip, API Level, dimensiune ecran, cantitate RAM și VM heap. Fișierul se află în directorul $HOME/.android/avd/NumeAVD.avd/ și poate fi modificat manual, deși de obicei se editează prin AVD Manager.

Pe lângă config.ini, în directorul AVD se stochează: userdata.img (imaginea datelor utilizatorului — aplicații, setări, fișiere), system.img (referință la System Image a SDK Platform instalate), cache.img (cache) și sdcard.img (imaginea cardului SD). La executarea Wipe Data, userdata.img este șters și se creează o imagine nouă goală. Snapshots se salvează într-un folder separat snapshots/ în interiorul directorului AVD.

System Image se descarcă separat de AVD — o imagine poate fi utilizată de mai multe dispozitive virtuale. Imaginile de sistem sunt stocate în directorul Android SDK: $ANDROID_SDK/system-images/android-{API}/{type}/{arch}/. Tipuri de imagini: google_apis (cu servicii Google), google_apis_playstore (cu Google Play Store) și default (AOSP pur fără servicii Google).

Tipuri de System Images

Crearea AVD prin AVD Manager

AVD Manager — este un instrument grafic în Android Studio pentru crearea și gestionarea dispozitivelor virtuale. Se poate deschide prin meniul Tools → Device Manager sau prin pictograma din bara de instrumente. AVD Manager afișează lista dispozitivelor create, starea lor (pornit/oprit), versiunea Android și acțiunile disponibile (pornire, oprire, wipe data, editare).

Pentru a crea un nou AVD, faceți clic pe butonul Create device. Selectați un profil de dispozitiv din lista gata făcută — Google oferă profiluri pentru toate dispozitivele populare. După selectarea profilului, indicați System Image: versiunea Android și tipul imaginii. Pentru proiecte noi, alegeți cea mai recentă versiune stabilă cu imaginea Google APIs. Apoi configurați numele AVD, orientarea ecranului, cantitatea de RAM și VM heap. După creare, AVD este gata de pornire.

Crearea pas cu pas a AVD din linia de comandă

# Lista System Images disponibile
sdkmanager --list | grep system-images

# Instalarea System Image pentru API 35 cu Google APIs
sdkmanager "system-images;android-35;google_apis;x86_64"

# Crearea AVD cu numele pixel8_api35
avdmanager create avd -n pixel8_api35 \
    -k "system-images;android-35;google_apis;x86_64" \
    -d pixel_8

# Pornirea AVD-ului creat
emulator -avd pixel8_api35 -gpu host -memory 2048

# Lista tuturor AVD-urilor
avdmanager list avd

Configurarea caracteristicilor hardware AVD

AVD Manager permite configurarea detaliată a caracteristicilor hardware ale dispozitivului virtual. Principalii parametri: RAM (memorie operativă, valoare recomandată 2048–4096 MB), VM heap (dimensiunea heap-ului mașinii virtuale, 256–512 MB), Internal Storage (memorie internă, 2–8 GB) și SD Card (card SD virtual). Acești parametri influențează performanța aplicației și comportamentul acesteia la lipsa de memorie.

Setări suplimentare includ: cameră (emulată sau conectarea camerei web a gazdei), senzori (accelerometru, giroscop), NFC, Bluetooth și baterie. De exemplu, pentru testarea aplicațiilor cu detectarea poziției, se poate emula rotirea dispozitivului prin butoanele de control ale emulatorului sau prin ADB. Emularea senzorilor permite testarea scenariilor dificil de reprodus pe un dispozitiv fizic.

Parametrii cheie ai config.ini

Optimizarea performanței emulatorului

Viteza de funcționare a AVD depinde direct de virtualizarea hardware. Pe Windows se utilizează Windows Hypervisor Platform (WHPX), pe macOS — Hypervisor.Framework, pe Linux — KVM. Dacă virtualizarea este dezactivată, AVD funcționează în modul de emulare pur software, care este de 10–20 de ori mai lent. Pentru a verifica dacă virtualizarea este activată, rulați emulatorul cu flagul -accel-check.

Al doilea factor cheie este alegerea arhitecturii System Image. Imaginile x86_64 funcționează semnificativ mai rapid decât arm64-v8a pe computere cu procesoare Intel și AMD, deoarece nu necesită traducerea dinamică a instrucțiunilor ARM. Utilizați întotdeauna imagini x86_64 pentru dezvoltare pe Windows și macOS cu procesoare Intel. Pe procesoarele ARM Mac (Apple Silicon) utilizați imagini native arm64-v8a.

Flaguri din linia de comandă pentru accelerare

# Pornirea cu virtualizare hardware și accelerare GPU
emulator -avd pixel8_api35 -gpu host -memory 4096 -cores 4

# Verificarea suportului de virtualizare
emulator -accel-check

# Pornirea fără interfață grafică (pentru CI)
emulator -avd pixel8_api35 -no-window -no-audio -gpu off

# Utilizarea snapshot-urilor pentru pornire rapidă
emulator -avd pixel8_api35 -snapshot mysnapshot -no-snapshot-save

Sfaturi de performanță pentru emulator

Pentru performanță maximă AVD: alocați emulatorului cel puțin 2–4 GB RAM, activați GPU Host (folosește placa video a computerului pentru randare), dezactivați sunetul (flag -no-audio), dacă nu este necesar, și utilizați Snapshots pentru revenirea rapidă la o stare curată. Snapshots salvează starea completă a sistemului — pornirea dintr-un instantaneu durează 2–5 secunde în loc de 30–60 de secunde pentru încărcarea completă.

De asemenea, se recomandă stocarea AVD pe un SSD — operațiile de intrare-ieșire la încărcarea sistemului și instalarea APK se accelerează semnificativ. Pentru lucrul cu mai multe AVD simultan, măriți cantitatea totală de RAM pe computer și utilizați flagul -read-only pentru emulatoarele imuabile.

Gestionarea AVD din linia de comandă

Controlul complet asupra AVD este posibil din linia de comandă fără Android Studio. Instrumentele avdmanager și emulator fac parte din Android SDK și execută toate operațiile: crearea, ștergerea, pornirea și configurarea AVD. Linia de comandă este utilă în special în pipeline-urile CI/CD, unde nu există interfață grafică, și pentru automatizarea testării.

Comenzi principale de gestionare AVD

# Creează AVD cu parametri personalizați
avdmanager create avd -n test_device \
    -k "system-images;android-34;google_apis;x86_64" \
    --device "pixel_8" \
    --force

# Șterge AVD
avdmanager delete avd -n test_device

# Clonează AVD (prin copierea fișierelor)
cp -r ~/.android/avd/pixel8_api35.avd ~/.android/avd/pixel8_clone.avd

# Resetează datele AVD
emulator -avd test_device -wipe-data

# Instalează APK pe AVD-ul pornit
adb -s emulator-5554 install app-release.apk

ADB și AVD: comenzi cheie

După pornirea AVD, se poate lucra cu el prin ADB (Android Debug Bridge) ca și cu un dispozitiv fizic. ADB permite instalarea aplicațiilor, rularea intent-urilor, emularea evenimentelor (apeluri, SMS, GPS), realizarea de capturi de ecran și înregistrarea video a ecranului. Acest lucru face din AVD un mediu complet pentru testare automatizată.

# Lista dispozitivelor conectate (inclusiv AVD)
adb devices

# Emularea unui apel primit
adb emu gsm call +15551234567

# Emularea coordonatelor GPS
adb emu geo fix -122.084 37.422

# Fă o captură de ecran
adb exec-out screencap -p > screenshot.png

# Trimite SMS
adb emu sms send +15551234567 "Hello from AVD"

Verificarea emulatorului în codul aplicației

Uneori, dezvoltatorul trebuie să determine în cod dacă aplicația rulează pe un emulator sau pe un dispozitiv fizic. Acest lucru poate fi necesar pentru dezactivarea analiticii (pentru a nu polua datele de producție), activarea logării extinse sau dezactivarea funcțiilor dependente de hardware care nu funcționează pe emulator. Google oferă metode standard de verificare prin clasa Build și proprietățile sistemului.

Metoda de verificare prin proprietatea Build

object EmulatorDetector {
    fun isEmulator(): Boolean {
        return (Build.BRAND.startsWith("generic") &&
                Build.DEVICE.startsWith("generic")) ||
                Build.FINGERPRINT.startsWith("generic") ||
                Build.FINGERPRINT.startsWith("unknown") ||
                Build.HARDWARE.contains("goldfish") ||
                Build.HARDWARE.contains("ranchu") ||
                Build.MODEL.contains("google_sdk") ||
                Build.MODEL.contains("Emulator") ||
                Build.MODEL.contains("Android SDK")
    }
}

// Utilizare
if (EmulatorDetector.isEmulator()) {
    Log.d("App", "Running on emulator — enable debug mode")
}

Verificarea prin proprietățile sistemului

Metoda suplimentară — citirea proprietăților sistemului prin Build.getRadioVersion() și verificarea ro.kernel.qemu. Pe emulator, radio version returnează null, iar proprietatea qemu este setată la 1. Această metodă este mai fiabilă pe versiunile vechi de Android, unde Build.FINGERPRINT poate fi modificat de producătorul dispozitivului.

fun isRunningOnEmulator(): Boolean {
    // Verificarea prin radio version — pe emulator întotdeauna null
    val radioVersion = try {
        Build.getRadioVersion()
    } catch (e: Exception) {
        null
    }
    if (radioVersion.isNullOrBlank()) return true

    // Verificarea prin proprietățile sistemului
    return try {
        val props = ProcessBuilder()
            .command("getprop", "ro.kernel.qemu")
            .start()
            .inputStream.bufferedReader().readText().trim()
        props == "1"
    } catch (e: Exception) {
        false
    }
}