Android Emulator — vad är det och hur emulering fungerar

Vad är Android Emulator?

Android Emulator — en virtuell Android-enhet som fungerar baserat på QEMU (Quick EMUlator) och emulerar Android-hårdvaruplattformen. Till skillnad från iOS Simulator översätter Android Emulator helt ARM-instruktioner, vilket gör det möjligt att köra kod som kompilerats för mobil arkitektur på en x86_64-värd.

Google släppte Android Emulator 2007 tillsammans med den första versionen av Android SDK. Sedan dess har emulatorn utvecklats från en långsam ARM-only-lösning till ett högpresterande system med stöd för GPU, hårdvaruacceleration och sensoremulering. Enligt Google (Android Developer Blog, 2025) fungerar den moderna emulatorn med HAxM 4-5 gånger snabbare än första generationen.

Emulatorn stöder alla komponenter i en Android-enhet: CPU, GPU, RAM, lagring, pekskärm, accelerometer, gyroskop, GPS, kamera, batteri, NFC, Bluetooth och Wi-Fi. Utvecklaren kan simulera inkommande samtal, SMS, olika nätverkssignalnivåer och geolokalisering via Extended Controls.

Systemavbildningar för emulatorn

Android Emulator använder systemavbildningar (System Images) som laddas ner via SDK Manager. Varje systemavbildning innehåller en fullständig kopia av Android-firmware för vald API-nivå och målprocessorarkitektur. Avbildningar med olika arkitekturer finns tillgängliga: x86_64 (rekommenderas med HAxM), ARM64 (för testning av ARM-kompatibilitet) och Google APIs (med förinstallerade Google Play Services). För Wear OS, Android TV och Automotive finns också separata avbildningar.

// Kontroll av emulatortyp i kod
val isEmulator = Build.FINGERPRINT
    .contains("generic") ||
    Build.PRODUCT.contains("sdk")

if (isEmulator) {
    Timber.d("Appen körs i emulatorn")
}

Konfigurera AVD i Android Studio

AVD (Android Virtual Device) — konfiguration av den virtuella enheten för emulatorn. AVD Manager i Android Studio gör det möjligt att skapa enheter med valfri kombination av egenskaper: modell, skärmstorlek, pixeltäthet, mängd RAM, lagringsstorlek och Android-version.

Skapa AVD görs via Device Manager i Android Studio: välj en hårdvaruprofil (Pixel, Nexus, Galaxy och andra), systemavbildning och konfigurera parametrarna. Efter skapandet visas enheten i listan Run Configurations för direkt körning av appen.

Snapshot-läge för snabb start

Emulatorn stöder Quick Boot — sparar AVD-tillståndet som en snapshot och återställer det vid nästa start. Laddningstiden minskar från 30-60 sekunder till 2-5 sekunder. För att återställa till rent tillstånd, använd Cold Boot Now i AVD Manager.

ARM-översättning och hårdvaruacceleration

ARM-översättning — nyckelteknologin i Android Emulator, som konverterar ARM-instruktioner till x86_64 i farten. Utan översättning kunde emulatorn bara köra x86_64-avbildningar, vilket begränsar testningen. Google använder libhoudini för ARM→x86-översättning och Intel-bibliotek för HAXM-acceleration.

# Kontroll av HAxM-status på Windows
sc query "IntelHaxm"

# Installera HAxM via SDK Manager
sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"

# Starta emulatorn med hårdvaruacceleration
emulator -avd Pixel_9_API_35 -accel on -gpu auto

Intel HAxM (Hardware Accelerated Execution Manager) — virtualiseringsdrivrutin för Intel VT-x-processorer, accelererar emulatorn 3-5 gånger. På Windows med AMD-processor, använd Windows Hyper-V Platform och WHPX. Utan hårdvaruacceleration fungerar emulatorn långsamt, med animationsfördröjningar upp till 1-2 sekunder.

För macOS på Apple Silicon (M-serien) fungerar hårdvaruacceleration inbyggt via Hypervisor.framework. Enligt Google (Android Emulator Release Notes 2025) når emulatorn på M2 Max 95% av prestandan hos en verklig enhet vid grundläggande operationer.

Emulator mot verklig enhet

Valet mellan emulator och verklig enhet beror på utvecklingsstadiet. På emulatorn är det bekvämt att utveckla och felsöka: snabb start, omedelbar driftsättning, Extended Controls för sensorsimulering. På en verklig enhet — slutlig testning av prestanda, batteri och arbete med hårdvara.

Prestandan hos emulatorn med hårdvaruacceleration är ofta högre än en verklig budgetenhet. Därför bör slutliga tester utföras på verkliga enheter med den avsedda prestandanivån.

Kontroll av emulator i Kotlin-kod

Att bestämma körningsmiljön i Kotlin är användbart för att inaktivera felaktig kod eller lägga till felsökningsinformation. Android tillhandahåller Build.FINGERPRINT, Build.PRODUCT och Build.HARDWARE för detta ändamål.

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

Användning av emulatordetektor hjälper vid felsökning: på emulatorn kan du aktivera utökade loggar, inaktivera animationer eller ersätta verkliga API-anrop med mockar. Undvik kontroll i produktionsbyggen om det inte krävs av appens affärslogik.

Testning av appar på emulatorn

Android Emulator används för automatiserad testning på CI-servrar. För att köra tester krävs att man skapar en AVD, startar emulatorn och väntar på att systemet laddas fullständigt. Gradle Managed Devices förenklar denna process: AVD-konfigurationen beskrivs i build.gradle.kts.

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

För manuell start av emulatorn, använd kommandoraden: emulator -avd Pixel_9_API_35 -no-window -no-audio -gpu swiftshader_indirect. Flaggan -no-window inaktiverar det grafiska gränssnittet för servermiljöer, och -gpu swiftshader_indirect ger programvarurendering utan värdens GPU.

Nätverks- och sensoremulering

Extended Controls i Android Emulator ger kraftfulla verktyg för simulering av nätverksförhållanden: latens (latency), bandbredd (bandwidth) och nätverkstyp (GPRS, EDGE, 3G, 4G, 5G). Detta gör det möjligt att testa appens beteende vid långsam anslutning utan att fysiskt resa till ett område med dålig täckning.

Sensorsimulering omfattar accelerometer, gyroskop och magnetometer via virtuella 3D-modeller av enheter. För GPS kan GPX-filer med rutter laddas — emulatorn simulerar rörelse längs koordinater, vilket är kritiskt för testning av navigationsappar. Kameran emuleras via värdens webbkamera eller bildladdning.

Multi-display i Android Emulator stöder flera skärmar för surfplattor och vikbara enheter. Extended Controls gör det möjligt att ändra orientering, skärmstorlek och pixeltäthet (DPI) utan att starta om emulatorn. För testning av vikbara enheter finns Foldable-lägen med växling mellan ihopvikt och utfällt tillstånd.

Android Emulator för Wear OS och Android TV

Emulatorn stöder inte bara smartphones, utan även Wear OS och Android TV. För Wear OS finns runda och rektangulära AVD-konfigurationer, simulering av bezel-rotation och svepgester, samt testning av interaktion med telefonemulatorn. För Android TV används ett gränssnitt med D-pad-navigering. Båda plattformarna stöder hårdvaruacceleration och testning med Google Play Services, vilket är viktigt för utvecklingscykeln för smartklockor och TV-applikationer.