Android Emulator — o que é e como funciona a emulação

O que é Android Emulator?

Android Emulator é um dispositivo Android virtual que executa sobre QEMU (Quick EMUlator) e emula a plataforma de hardware Android. Ao contrário do iOS Simulator, o Android Emulator traduz completamente as instruções ARM, permitindo que o código compilado para arquitetura móvel seja executado em um host x86_64.

O Google lançou o Android Emulator em 2007 junto com a primeira versão do Android SDK. Desde então, o emulador evoluiu de uma solução lenta apenas ARM para um sistema de alto desempenho com suporte a GPU, aceleração por hardware e emulação de sensores. De acordo com o Google (Android Developer Blog, 2025), o emulador moderno com HAxM funciona 4-5 vezes mais rápido que a primeira geração.

O emulador suporta todos os componentes de um dispositivo Android: CPU, GPU, RAM, armazenamento, tela sensível ao toque, acelerômetro, giroscópio, GPS, câmera, bateria, NFC, Bluetooth e Wi-Fi. O desenvolvedor pode simular chamadas recebidas, SMS, vários níveis de sinal de rede e geolocalização através do Extended Controls.

Imagens de sistema para o emulador

Android Emulator usa imagens de sistema (System Images) baixadas através do SDK Manager. Cada imagem de sistema contém uma cópia completa do firmware Android para o nível de API selecionado e arquitetura de processador alvo. Imagens estão disponíveis com diferentes arquiteturas: x86_64 (recomendada com HAxM), ARM64 (para teste de compatibilidade ARM) e Google APIs (com Google Play Services pré-instalados). Imagens separadas também estão disponíveis para Wear OS, Android TV e Automotive.

// Verificação do tipo de emulador no código
val isEmulator = Build.FINGERPRINT
    .contains("generic") ||
    Build.PRODUCT.contains("sdk")

if (isEmulator) {
    Timber.d("Aplicativo está rodando no emulador")
}

Configuração de AVD no Android Studio

AVD (Android Virtual Device) é uma configuração de dispositivo virtual para o emulador. O AVD Manager no Android Studio permite criar dispositivos com qualquer combinação de características: modelo, tamanho de tela, densidade de pixels, quantidade de RAM, tamanho de armazenamento e versão do Android.

Criação de AVD é feita através do Device Manager no Android Studio: selecione um perfil de hardware (Pixel, Nexus, Galaxy e outros), imagem de sistema e configure os parâmetros. Após a criação, o dispositivo aparece na lista Run Configurations para execução imediata do aplicativo.

Modo Snapshot para início rápido

O emulador suporta Quick Boot — salva o estado do AVD como um snapshot e o restaura na próxima inicialização. O tempo de inicialização reduz de 30-60 segundos para 2-5 segundos. Para redefinir para um estado limpo, use Cold Boot Now no AVD Manager.

Tradução ARM e aceleração por hardware

Tradução ARM é uma tecnologia chave do Android Emulator que converte instruções ARM para x86_64 em tempo real. Sem tradução, o emulador só poderia executar imagens x86_64, limitando os testes. O Google usa libhoudini para tradução ARM→x86 e bibliotecas Intel para aceleração HAXM.

# Verificação do status HAxM no Windows
sc query "IntelHaxm"

# Instalação do HAxM via SDK Manager
sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"

# Iniciar emulador com aceleração por hardware
emulator -avd Pixel_9_API_35 -accel on -gpu auto

Intel HAxM (Hardware Accelerated Execution Manager) é um driver de virtualização para processadores Intel VT-x que acelera o emulador em 3-5 vezes. No Windows com processador AMD, use Windows Hyper-V Platform e WHPX. Sem aceleração por hardware, o emulador funciona lentamente, com atrasos de animação de até 1-2 segundos.

No macOS com Apple Silicon (série M), a aceleração por hardware funciona nativamente através do Hypervisor.framework. De acordo com o Google (Android Emulator Release Notes 2025), o emulador no M2 Max atinge 95% do desempenho de um dispositivo real em operações básicas.

Emulador vs dispositivo real

A escolha entre emulador e dispositivo real depende do estágio de desenvolvimento. No emulador é conveniente desenvolver e depurar: inicialização rápida, implantação instantânea, Extended Controls para simulação de sensores. Em um dispositivo real — teste final de desempenho, bateria e funcionamento com hardware.

O desempenho do emulador com aceleração por hardware é frequentemente superior ao de um dispositivo real de baixo custo. Portanto, realize os testes finais em dispositivos reais com o nível de desempenho alvo.

Verificação do emulador em código Kotlin

Detectar o ambiente de execução em Kotlin é útil para desabilitar código incorreto ou adicionar informações de depuração. O Android fornece Build.FINGERPRINT, Build.PRODUCT e Build.HARDWARE para este propósito.

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", "Ambiente: emulador")
        }
    }
}

Usar um detector de emulador ajuda durante a depuração: no emulador você pode ativar logs avançados, desativar animações ou substituir chamadas de API reais por mocks. Evite a verificação em builds de produção, a menos que seja necessário para a lógica de negócios do aplicativo.

Teste de aplicativos no emulador

Android Emulator é usado para testes automatizados em servidores CI. Para executar testes, é necessário criar um AVD, iniciar o emulador e aguardar o carregamento completo do sistema. O Gradle Managed Devices simplifica este processo: a configuração do AVD é descrita no build.gradle.kts.

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

Para iniciar o emulador manualmente use a linha de comando: emulator -avd Pixel_9_API_35 -no-window -no-audio -gpu swiftshader_indirect. A flag -no-window desativa a interface gráfica para ambientes de servidor, e -gpu swiftshader_indirect fornece renderização por software sem GPU do host.

Emulação de rede e sensores

O Extended Controls no Android Emulator fornece ferramentas poderosas para simular condições de rede: latência, largura de banda e tipo de rede (GPRS, EDGE, 3G, 4G, 5G). Isso permite testar o comportamento do aplicativo em conexões lentas sem viajar fisicamente para uma área com cobertura deficiente.

Simulação de sensores inclui acelerômetro, giroscópio e magnetômetro através de modelos 3D virtuais de dispositivos. Para GPS, você pode carregar arquivos GPX com rotas — o emulador simula movimento ao longo de coordenadas, o que é crítico para testar aplicativos de navegação. A câmera é emulada através da webcam do host ou carregamento de imagens.

Multi-display no Android Emulator suporta múltiplas telas para tablets e dispositivos dobráveis. O Extended Controls permite alterar orientação, tamanho de tela e densidade de pixels (DPI) sem reiniciar o emulador. Para testar dispositivos dobráveis, modos Foldable estão disponíveis com alternância entre estado dobrado e aberto.

Android Emulator para Wear OS e Android TV

O emulador suporta não apenas smartphones, mas também Wear OS e Android TV. Para Wear OS, configurações AVD redondas e retangulares estão disponíveis, simulação de rotação de bisel e gestos de deslize, bem como teste de interação com um emulador de telefone. Para Android TV, é usada uma interface com navegação por D-pad. Ambas as plataformas suportam aceleração por hardware e teste com Google Play Services, o que é importante para o ciclo de desenvolvimento de aplicativos de smartwatch e TV.