Android Emulator — co to jest i jak działa emulacja

Co to jest Android Emulator?

Android Emulator — wirtualne urządzenie Android działające w oparciu o QEMU (Quick EMUlator) i emulujące platformę sprzętową Androida. W przeciwieństwie do iOS Simulator, Android Emulator w pełni transliuje instrukcje ARM, co pozwala uruchamiać kod skompilowany dla architektury mobilnej na hoście x86_64.

Google wydała Android Emulator w 2007 roku wraz z pierwszą wersją Android SDK. Od tego czasu emulator przeszedł ewolucję od wolnego rozwiązania tylko dla ARM do wysokowydajnego systemu z obsługą GPU, akceleracji sprzętowej i emulacji czujników. Według Google (Android Developer Blog, 2025), nowoczesny emulator z HAxM działa 4-5 razy szybciej niż pierwsza generacja.

Emulator obsługuje wszystkie komponenty urządzenia Android: CPU, GPU, RAM, pamięć masową, ekran dotykowy, akcelerometr, żyroskop, GPS, kamerę, baterię, NFC, Bluetooth i Wi-Fi. Programista może symulować połączenia przychodzące, SMS, różne poziomy sygnału sieci i geolokalizację za pomocą Extended Controls.

Obrazy systemowe dla emulatora

Android Emulator wykorzystuje obrazy systemowe (System Images), które są pobierane przez SDK Manager. Każdy obraz systemowy zawiera pełną kopię oprogramowania Android dla wybranego poziomu API i docelowej architektury procesora. Dostępne są obrazy o różnej architekturze: x86_64 (zalecane z HAxM), ARM64 (do testowania zgodności ARM) i Google APIs (z preinstalowanymi Google Play Services). Dla Wear OS, Android TV i Automotive również dostępne są osobne obrazy.

// Sprawdzanie typu emulatora w kodzie
val isEmulator = Build.FINGERPRINT
    .contains("generic") ||
    Build.PRODUCT.contains("sdk")

if (isEmulator) {
    Timber.d("Aplikacja uruchomiona w emulatorze")
}

Konfiguracja AVD w Android Studio

AVD (Android Virtual Device) — konfiguracja wirtualnego urządzenia dla emulatora. AVD Manager w Android Studio umożliwia tworzenie urządzeń z dowolną kombinacją parametrów: model, rozmiar ekranu, gęstość pikseli, ilość RAM, rozmiar pamięci masowej i wersja Androida.

Tworzenie AVD wykonuje się przez Device Manager w Android Studio: wybierz profil sprzętowy (Pixel, Nexus, Galaxy i inne), obraz systemowy i skonfiguruj parametry. Po utworzeniu urządzenie pojawia się na liście Run Configurations do bezpośredniego uruchomienia aplikacji.

Tryb snapshot dla szybkiego startu

Emulator obsługuje Quick Boot — zapisuje stan AVD jako snapshot i przywraca go przy następnym uruchomieniu. Czas ładowania skraca się z 30-60 sekund do 2-5 sekund. Aby zresetować do czystego stanu, użyj Cold Boot Now w AVD Manager.

Translacja ARM i akceleracja sprzętowa

Translacja ARM — kluczowa technologia Android Emulator, konwertująca instrukcje ARM na x86_64 w locie. Bez translacji emulator mógłby uruchamiać tylko obrazy x86_64, co ogranicza testowanie. Google używa libhoudini do translacji ARM→x86 i bibliotek Intel do akceleracji HAXM.

# Sprawdzanie statusu HAxM w Windows
sc query "IntelHaxm"

# Instalacja HAxM przez SDK Manager
sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"

# Uruchamianie emulatora z akceleracją sprzętową
emulator -avd Pixel_9_API_35 -accel on -gpu auto

Intel HAxM (Hardware Accelerated Execution Manager) — sterownik wirtualizacji dla procesorów Intel VT-x, przyspieszający emulator 3-5 razy. W systemie Windows z procesorem AMD używaj Windows Hyper-V Platform i WHPX. Bez akceleracji sprzętowej emulator działa wolno, z opóźnieniami animacji do 1-2 sekund.

Dla macOS na Apple Silicon (seria M) akceleracja sprzętowa działa natywnie przez Hypervisor.framework. Według Google (Android Emulator Release Notes 2025), emulator na M2 Max osiąga 95% wydajności rzeczywistego urządzenia przy podstawowych operacjach.

Emulator a rzeczywiste urządzenie

Wybór między emulatorem a rzeczywistym urządzeniem zależy od etapu rozwoju. Na emulatorze wygodnie się programuje i debuguje: szybki start, natychmiastowy deployment, Extended Controls do symulacji czujników. Na rzeczywistym urządzeniu — końcowe testowanie wydajności, baterii i pracy ze sprzętem.

Wydajność emulatora z akceleracją sprzętową jest często wyższa niż rzeczywistego budżetowego urządzenia. Dlatego końcowe testy przeprowadzaj na rzeczywistych urządzeniach z docelowym poziomem wydajności.

Wykrywanie emulatora w kodzie Kotlin

Określenie środowiska wykonawczego w Kotlin jest przydatne do wyłączania nieprawidłowego kodu lub dodawania informacji debugowania. Android udostępnia Build.FINGERPRINT, Build.PRODUCT i Build.HARDWARE do tego celu.

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

Używanie detektora emulatora pomaga przy debugowaniu: na emulatorze można włączyć rozszerzone logi, wyłączyć animacje lub zastąpić rzeczywiste wywołania API mockami. Unikaj sprawdzania w kompilacjach produkcyjnych, jeśli nie jest to wymagane przez logikę biznesową aplikacji.

Testowanie aplikacji na emulatorze

Android Emulator jest używany do zautomatyzowanego testowania na serwerach CI. Do uruchomienia testów wymagane jest utworzenie AVD, uruchomienie emulatora i oczekiwanie na pełne załadowanie systemu. Gradle Managed Devices upraszczają ten proces: konfiguracja AVD jest opisana w build.gradle.kts.

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

Do ręcznego uruchomienia emulatora używaj wiersza poleceń: emulator -avd Pixel_9_API_35 -no-window -no-audio -gpu swiftshader_indirect. Flaga -no-window wyłącza interfejs graficzny dla środowiska serwerowego, a -gpu swiftshader_indirect zapewnia programowe renderowanie bez GPU hosta.

Emulacja sieci i czujników

Extended Controls w Android Emulator udostępnia potężne narzędzia do symulacji warunków sieciowych: opóźnienie (latency), przepustowość (bandwidth) i typ sieci (GPRS, EDGE, 3G, 4G, 5G). Pozwala to testować zachowanie aplikacji przy wolnym połączeniu bez fizycznej podróży do strefy ze słabym zasięgiem.

Symulacja czujników obejmuje akcelerometr, żyroskop i magnetometr przez wirtualne modele 3D urządzeń. Dla GPS można załadować pliki GPX z trasami — emulator symuluje ruch po współrzędnych, co jest kluczowe do testowania aplikacji nawigacyjnych. Kamera jest emulowana przez kamerę internetową hosta lub ładowanie obrazów.

Multi-display w Android Emulator obsługuje wiele ekranów dla tabletów i urządzeń składanych. Extended Controls umożliwiają zmianę orientacji, rozmiaru ekranu i gęstości pikseli (DPI) bez restartu emulatora. Do testowania urządzeń składanych dostępne są tryby Foldable z przełączaniem między stanem złożonym a rozłożonym.

Android Emulator dla Wear OS i Android TV

Emulator obsługuje nie tylko smartfony, ale także Wear OS i Android TV. Dla Wear OS dostępne są okrągłe i prostokątne konfiguracje AVD, symulacja obracania bezela i gestów przesuwania, a także testowanie interakcji z emulatorem telefonu. Dla Android TV używany jest interfejs z nawigacją D-pad. Obie platformy obsługują akcelerację sprzętową i testowanie z Google Play Services, co jest ważne dla cyklu deweloperskiego smartwatchy i aplikacji telewizyjnych.