AVD Android: mi ez, Android Virtual Device és hogyan kell beállítani az emulátort

Mi az AVD

AVD (Android Virtual Device) — egy szoftverkonfiguráció, amely egy virtuális Android-eszközt ír le. A fizikai telefontól eltérően az AVD nem igényel hardvert — a számítógépen fut a QEMU-alapú Android-emulátoron keresztül. A fejlesztő annyi AVD-t hoz létre, amennyi a teszteléshez szükséges: különböző Android-verziókhoz, képernyőméretekhez, memóriaméretekhez és pixelsűrűségekhez.

Minden AVD egy adott SDK Platform-hoz van kötve. Ez azt jelenti, hogy egy Android 14 (API Level 34) rendszerű AVD létrehozásához először telepíteni kell a verzió System Image-jét az SDK Manager segítségével. A System Image az operációs rendszer képe, amely tartalmazza az összes rendszeralkalmazást, Google-szolgáltatásokat (ha a Google APIs kép van kiválasztva) és futásidejű komponenseket. A Google javasolja a Google APIs képek használatát Google Play szolgáltatásokkal a valós eszközökkel való maximális kompatibilitás érdekében.

Az AVD több okból is nélkülözhetetlen a fejlesztésben. Először is, lehetővé teszi az alkalmazás tesztelését különböző Android-verziókon anélkül, hogy több tucat eszközt vásárolnánk. Másodszor, az AVD támogatja a Snapshots-ot — a rendszerállapot mentését, ami felgyorsítja az indítást. Harmadszor, az emulátor integrálva van az Android Studio-val: az APK telepítése, hibakeresés és naplózás ugyanúgy működik, mint egy fizikai eszközön.

A virtuális eszközök típusai

Az AVD különböző eszköztípusokat támogat: telefonok (Phone), tabletek (Tablet), órák (Wear OS), televíziók (Android TV) és autórendszerek (Android Automotive). Minden típushoz az AVD Manager kész profilokat kínál a Google-tól: Pixel 8, Pixel 9 Pro, Nexus 7, Samsung Galaxy Tab és mások. Az eszközprofil meghatározza a képernyő méretét, felbontását, pixelsűrűségét (dpi) és a navigációt (gesztusok vagy gombok).

Miből áll az AVD

Minden AVD konfigurációs fájlok és képek halmaza. A fő konfigurációs fájl — config.ini, amely tárolja a virtuális eszköz paramétereit: név, típus, API Level, képernyőméret, RAM és VM heap mennyisége. A fájl a $HOME/.android/avd/AVDNév.avd/ könyvtárban található, és manuálisan módosítható, bár általában az AVD Manager-en keresztül szerkesztik.

A config.ini mellett az AVD könyvtárban tárolódik: userdata.img (a felhasználói adatok képe — alkalmazások, beállítások, fájlok), system.img (hivatkozás a telepített SDK Platform System Image-jére), cache.img (gyorsítótár) és sdcard.img (SD-kártya kép). A Wipe Data végrehajtásakor a userdata.img törlődik és egy új üres kép jön létre. A Snapshots egy külön snapshots/ mappában tárolódnak az AVD könyvtáron belül.

A System Image az AVD-től külön töltődik le — egy képet több virtuális eszköz is használhat. A rendszerképek az Android SDK könyvtárban tárolódnak: $ANDROID_SDK/system-images/android-{API}/{type}/{arch}/. Képtípusok: google_apis (Google-szolgáltatásokkal), google_apis_playstore (Google Play Store-ral) és default (tiszta AOSP Google-szolgáltatások nélkül).

System Images típusai

AVD létrehozása az AVD Manager segítségével

AVD Manager — egy grafikus eszköz az Android Studio-ban virtuális eszközök létrehozására és kezelésére. Megnyitható a Tools → Device Manager menün keresztül vagy az eszköztár ikonján keresztül. Az AVD Manager megjeleníti a létrehozott eszközök listáját, azok állapotát (fut/leállítva), az Android verzióját és az elérhető műveleteket (indítás, leállítás, wipe data, szerkesztés).

Új AVD létrehozásához kattintson a Create device gombra. Válasszon egy eszközprofilt a kész profilok listájából — a Google profilokat biztosít az összes népszerű eszközhöz. A profil kiválasztása után adja meg a System Image-t: az Android verzióját és a kép típusát. Új projektekhez válassza a legújabb stabil verziót Google APIs képpel. Ezután konfigurálja az AVD nevét, a képernyő tájolását, a RAM és a VM heap mennyiségét. A létrehozás után az AVD készen áll az indításra.

AVD létrehozása lépésről lépésre parancssorból

# Elérhető System Images listája
sdkmanager --list | grep system-images

# System Image telepítése API 35-höz Google APIs-val
sdkmanager "system-images;android-35;google_apis;x86_64"

# AVD létrehozása pixel8_api35 néven
avdmanager create avd -n pixel8_api35 \
    -k "system-images;android-35;google_apis;x86_64" \
    -d pixel_8

# Létrehozott AVD elindítása
emulator -avd pixel8_api35 -gpu host -memory 2048

# Az összes AVD listája
avdmanager list avd

Az AVD hardverjellemzőinek konfigurálása

Az AVD Manager lehetővé teszi a virtuális eszköz hardverjellemzőinek részletes konfigurálását. Fő paraméterek: RAM (operatív memória, ajánlott érték 2048–4096 MB), VM heap (a virtuális gép heap mérete, 256–512 MB), Internal Storage (belső tárhely, 2–8 GB) és SD Card (virtuális SD-kártya). Ezek a paraméterek befolyásolják az alkalmazás teljesítményét és viselkedését memóriahiány esetén.

További beállítások közé tartozik: kamera (emulált vagy hoszt webkamera csatlakoztatása), érzékelők (gyorsulásmérő, giroszkóp), NFC, Bluetooth és akkumulátor. Például a helymeghatározó alkalmazások teszteléséhez az eszköz elforgatása emulálható az emulátor vezérlőgombjain vagy ADB-n keresztül. Az érzékelők emulációja lehetővé teszi olyan forgatókönyvek tesztelését, amelyeket nehéz reprodukálni egy fizikai eszközön.

A config.ini legfontosabb paraméterei

Az emulátor teljesítményének optimalizálása

Az AVD sebessége közvetlenül függ a hardvervirtualizációtól. Windows rendszeren Windows Hypervisor Platform (WHPX), macOS-en Hypervisor.Framework, Linuxon KVM használatos. Ha a virtualizáció ki van kapcsolva, az AVD tiszta szoftveres emulációs módban működik, ami 10–20-szor lassabb. A virtualizáció bekapcsolt állapotának ellenőrzéséhez indítsa el az emulátort az -accel-check zászlóval.

A második kulcsfontosságú tényező a System Image architektúrájának kiválasztása. Az x86_64 képek jelentősen gyorsabban működnek, mint az arm64-v8a az Intel és AMD processzorokkal rendelkező számítógépeken, mivel nem igénylik az ARM utasítások dinamikus fordítását. Mindig x86_64 képeket használjon a Windows és macOS rendszeren történő fejlesztéshez Intel processzorokkal. Az ARM processzoros Mac (Apple Silicon) gépeken natív arm64-v8a képeket használjon.

Parancssori zászlók a gyorsításhoz

# Indítás hardvervirtualizációval és GPU-gyorsítással
emulator -avd pixel8_api35 -gpu host -memory 4096 -cores 4

# Virtualizációs támogatás ellenőrzése
emulator -accel-check

# Indítás grafikus felület nélkül (CI-hez)
emulator -avd pixel8_api35 -no-window -no-audio -gpu off

# Snapshotok használata gyors indításhoz
emulator -avd pixel8_api35 -snapshot mysnapshot -no-snapshot-save

Az emulátor teljesítményére vonatkozó tippek

Maximális AVD-teljesítmény érdekében: biztosítson az emulátornak legalább 2–4 GB RAM-ot, kapcsolja be a GPU Host-ot (a számítógép videokártyáját használja a megjelenítéshez), kapcsolja ki a hangot (-no-audio zászló), ha nem szükséges, és használjon Snapshots-ot a gyors visszatéréshez tiszta állapotba. A Snapshots elmenti a rendszer teljes állapotát — a pillanatképből történő indítás 2–5 másodpercet vesz igénybe a 30–60 másodperces teljes betöltés helyett.

Javasoljuk továbbá az AVD SSD-meghajtón történő tárolását — az I/O-műveletek a rendszer betöltésekor és az APK telepítésekor jelentősen felgyorsulnak. Több AVD egyidejű használatához növelje a számítógép teljes RAM-mennyiségét, és használja a -read-only zászlót a nem módosítható emulátorokhoz.

AVD kezelése parancssorból

Teljes kontroll az AVD felett parancssorból lehetséges Android Studio nélkül. Az avdmanager és emulator eszközök az Android SDK részét képezik, és minden műveletet elvégeznek: AVD létrehozása, törlése, indítása és konfigurálása. A parancssor különösen hasznos a CI/CD pipeline-okban, ahol nincs grafikus felület, valamint a tesztelés automatizálásához.

Az AVD kezelésének alapvető parancsai

# AVD létrehozása egyedi paraméterekkel
avdmanager create avd -n test_device \
    -k "system-images;android-34;google_apis;x86_64" \
    --device "pixel_8" \
    --force

# AVD törlése
avdmanager delete avd -n test_device

# AVD klónozása (fájlok másolásával)
cp -r ~/.android/avd/pixel8_api35.avd ~/.android/avd/pixel8_clone.avd

# AVD adatainak visszaállítása
emulator -avd test_device -wipe-data

# APK telepítése futó AVD-re
adb -s emulator-5554 install app-release.apk

ADB és AVD: kulcsfontosságú parancsok

Az AVD elindítása után az ADB (Android Debug Bridge) segítségével úgy dolgozhat vele, mint egy fizikai eszközzel. Az ADB lehetővé teszi alkalmazások telepítését, intentek futtatását, események emulálását (hívások, SMS, GPS), képernyőképek készítését és képernyővideó rögzítését. Ez teszi az AVD-t teljes környezetté az automatizált teszteléshez.

# Csatlakoztatott eszközök listája (AVD-t is beleértve)
adb devices

# Bejövő hívás emulálása
adb emu gsm call +15551234567

# GPS-koordináták emulálása
adb emu geo fix -122.084 37.422

# Képernyőkép készítése
adb exec-out screencap -p > screenshot.png

# SMS küldése
adb emu sms send +15551234567 "Hello from AVD"

Emulátor ellenőrzése az alkalmazás kódjában

Néha a fejlesztőnek meg kell határoznia a kódban, hogy az alkalmazás emulátoron vagy fizikai eszközön fut. Erre szükség lehet az analitika kikapcsolásához (hogy ne szennyezze a termelési adatokat), a kibővített naplózás bekapcsolásához, vagy a hardverfüggő funkciók kikapcsolásához, amelyek nem működnek az emulátoron. A Google szabványos ellenőrzési módszereket biztosít a Build osztályon és a rendszertulajdonságokon keresztül.

Ellenőrzési módszer a Build tulajdonságon keresztül

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")
    }
}

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

Ellenőrzés rendszertulajdonságokon keresztül

Kiegészítő módszer — rendszertulajdonságok olvasása a Build.getRadioVersion() segítségével és a ro.kernel.qemu ellenőrzése. Az emulátoron a radio version null értéket ad vissza, a qemu tulajdonság pedig 1-re van állítva. Ez a módszer megbízhatóbb régebbi Android-verziókon, ahol a Build.FINGERPRINT-t az eszköz gyártója módosíthatja.

fun isRunningOnEmulator(): Boolean {
    // Ellenőrzés radio version segítségével — emulátoron mindig null
    val radioVersion = try {
        Build.getRadioVersion()
    } catch (e: Exception) {
        null
    }
    if (radioVersion.isNullOrBlank()) return true

    // Ellenőrzés rendszertulajdonságok segítségével
    return try {
        val props = ProcessBuilder()
            .command("getprop", "ro.kernel.qemu")
            .start()
            .inputStream.bufferedReader().readText().trim()
        props == "1"
    } catch (e: Exception) {
        false
    }
}