Por que o emulador do Android é tão lento? Como podemos acelerar o emulador do Android?
Eu tenho um processador Celeron de2.67 GHz e 1.21 GB de RAM em um x86 Windows XP Máquina profissional.
Meu entendimento é que o Android Emulator deve ser iniciado rapidamente em uma máquina desse tipo, mas, para mim, isso não acontece. Eu segui todas as instruções para configurar o IDE, SDKs, JDKs e outros e tive algum sucesso em iniciar o emulador rapidamente, mas isso é muito raro. Como posso, se possível, corrigir esse problema?
Mesmo que comece e carregue a tela inicial, é muito lento. Eu tentei o Eclipse IDE in versão 3.5 (Galileo) e 3.4 (Ganymede).
Atualizar
Agora você pode ativar a opção Inicialização rápida para o emulador Android. Isso salvará o estado do emulador e iniciará o emulador rapidamente na próxima inicialização.
Clique no botão de edição do Emulador e clique em Show Advanced Setting. Em seguida, ative Quick Boot como abaixo da captura de tela.
Android Development Tools (ADT) 9.0. (ou posterior) tem um recurso que permite salvar o estado do AVD (emulador), e você pode iniciar seu emulador instantaneamente. Você tem que habilitar esse recurso enquanto cria um novo AVD ou pode apenas criá-lo mais tarde editando o AVD.
Também eu tenho aumentado o Device RAM Size para 1024 que resulta em um emulador muito rápido.
Consulte as capturas de tela abaixo para mais informações.
Criando um novo AVD com o recurso de salvar instantâneo.
Lançando o emulador a partir do instantâneo.
E para acelerar seu emulador, você pode se referir a Acelerar seu Emulador Android!:
NOTA IMPORTANTE : Por favor primeiro consulte a lista da Intel sobre VT para certificar-se de que sua CPU suporta Intel VT.
HAXM acelera o lento emulador do Android
HAXMsignifica - "Intel Hardware Accelerated Execution Manager"
Atualmente, suporta apenas Intel® VT (Intel Virtualization Technology).
O emulador do Android é baseado em QEMU . A interface entre o QEMU e o driver HAXM no sistema host foi projetada para ser independente de fornecedor.
Etapas para configurar seu ambiente de desenvolvimento Android para o HAXM
Atualize o Eclipse: Certifique-se de que a instalação do Eclipse e o plug-in do ADT estejam totalmente atualizados.
Atualize suas ferramentas do Android: após cada atualização do plug-in do Eclipse, é importante atualizar suas ferramentas do Android SDK. Para isso, inicie o Gerenciador do Android SDK e atualize todos os componentes do Android SDK. Para aproveitar o HAXM, você deve estar no mínimo com a versão 17.
- Faça o download de Imagens do Sistema Atom x86 e o Driver do Intel Hardware Accelerated Execution Manager . Siga a imagem abaixo:
Instale o driver HAXM executando "IntelHaxm.exe". Ele estará localizado em um dos seguintes locais:
C:\Program Files\Android\android-sdk\extras\intel\Hardware_Accelerated_Execution_ManagerC:\Users\<user>\adt-bundle-windows-x86_64\sdk\extras\intel\Hardware_Accelerated_Execution_Manager
Se o instalador falhar com a mensagem de que o Intel VT deve estar ligado, é necessário ativar isso no BIOS . Veja a descrição de como fazer isso em Ativando o Intel VT (Virtualization Technology).
- Crie um novo x86 AVD: Siga a imagem abaixo:
- Ou como para o novo SDK,
![Enter image description here]()
Tente Android x86 . É muito mais rápido que o emulador do Google Android. Siga esses passos:
- Instalar VirtualBox .
- Baixe o arquivo ISO que você precisa.
- Crie uma máquina virtual como Linux 2.6/Other Linux, 512 MB de RAM, HD 2 GB. Rede: PCnet-Fast III, anexado a NAT . Você também pode usar um adaptador em ponte, mas precisa de um servidor DHCP em seu ambiente.
- Instale o Android x86 no emulador, execute-o.
- Pressione Alt+F1, digite
netcfg, lembre-se do endereço IP, pressione Alt+F7. - Execute cmd no seu sistema Windows XP, altere o diretório para o diretório de ferramentas do Android, digite
adb connect <virtual_machine_IP>. - Inicie o Eclipse, abra o plug-in do ADT, encontre o dispositivo e divirta-se!
UPDATE: A última versão do estúdio Android (2.x) fez grandes melhorias no emulador empacotado. É responsivo e tem um monte de recursos.
Para aqueles ainda interessados: tente usar Genymotion . Você pode baixar uma versão para Windows/Mac OS X/Linux após o registro. Um plugin para o Eclipse também está disponível:
A instalação do plug-in pode ser feita iniciando o Eclipse e indo para o menu "Ajuda/Instalar Novo Software" e, em seguida, basta adicionar um novo Site de Atualização com o seguinte URL: http://plugins.genymotion.com/Eclipse . Siga os passos indicados pelo Eclipse.
Este emulador é rápido e responsivo.
GenyMotion permite controlar vários sensores do seu dispositivo, incluindo o nível da bateria, força do sinal e GPS. A versão mais recente agora também contém ferramentas de câmera.
O emulador incluído na sua (antiga) versão do Eclipse é muito lento.
Emuladores recentes são mais rápidos do que costumavam ser em 2010. Atualize seu SDK/IDE.
Pessoalmente, eu uso um telefone real para fazer meus testes. É mais rápido e os testes são mais realistas. Mas se você quiser testar seu aplicativo em várias versões diferentes do Android e não quiser comprar vários telefones, terá que usar o emulador de tempos em tempos.
A inicialização do emulador é muito lenta. O bom é que você só precisa iniciar o emulador uma vez. Se o emulador já estiver em execução e você executar o aplicativo novamente, o emulador reinstalará o aplicativo com relativa rapidez. Claro, se você quiser saber o quão rápido ele será executado em um telefone, é melhor testá-lo em um telefone real.
Intel lançou instruções de instalação recomendadas para o ICS emulador em 15 de maio de 2012. Isso funcionou para mim. O emulador agora é rápido e a interface do usuário é suave.
A primeira metade das instruções é detalhada o suficiente, então vou assumir que você foi capaz de instalar a Imagem do Sistema Intel x86 Atom usando o gerenciador do Android SDK, assim como o Intel HAXM.
Agora, para garantir que tudo esteja configurado para que você possa desfrutar de um emulador de alta performance:
E comece:
Sudo kextload -b com.intel.kext.intelhaxm (mac)
Se o HAXM estiver funcionando corretamente, você poderá ver esta mensagem ao iniciar o emulador:
O HAX está funcionando e o emulador é executado no modo virtual rápido
Caso contrário, você poderá ver este erro:
O HAX não está funcionando e o emulador é executado no emulador do modo de emulação:
Falha ao abrir o módulo hax
Usar emulação de GPU Você não pode usar a opção Instantâneo quando usar a emulação de GPU até o momento desta gravação. Certifique-se de que a emulação da GPU esteja definida como "yes".
Defina a memória do dispositivo para 1024 MB ou mais , mas não mais que a configuração do Intel HAXM. Eu uso 1024 MB por dispositivo e 2048 para o HAXM.
Verifique sempre as configurações depois de salvar! O emulador é muito exigente quanto ao que ele permite definir e reverterá as configurações sem avisar você.
Com essas configurações, o teclado do software não aparece mais, nem as teclas de voltar, menu e recentes na tela. Esta parece ser uma limitação da atual imagem do sistema ICS Intel x86. Você precisará usar os atalhos de teclado .
No Mac OS, você precisará segurar fn + control para o F1 - F12 teclas para trabalhar. Page up/down/left/right pode ser executado usando as teclas control + seta.
Você pode criar emulator.bat com o seguinte comando para iniciar o emulador. Vai começar mais rápido.
emulator.exe -cpu-delay 0 -no-boot-anim @<avd name>
Ou no Unix (sabores do Mac ou Linux):
emulator -cpu-delay 0 -no-boot-anim @<avd name>
Eu notei que o emulador começa muito mais rápido se não houver um Dalvik Debug Monitor Server (DDMS) conectado. Portanto, se você iniciar o emulador a partir do Gerenciador de Dispositivos Virtual "SDK Setup.exe" e o Eclipse não for iniciado, o emulador funcionará mais rápido.
Se você iniciar o emulador a partir do Eclipse: DDMS estará lá, então, às vezes, o emulador é extremamente lento, mas às vezes é mais rápido.
Emuladores são lentos. Não há realmente nada que você possa fazer sobre isso, mas há alternativas para o emulador.
Para tornar seu emulador mais rápido, você pode hospedar uma GPU e usar uma versão mais leve do Android ( Android 2.3 (Gingerbread)). Desenvolver em um Mac seria melhor. Por que usar um emulador BTW? Usando um telefone real faz mais sentido.
A partir da Revisão 17 do Android SDK Tools, o emulador pode usar aceleração gráfica e extensões fornecidas pela CPU para melhor eficiência. Os pré-requisitos e a configuração completa e as notas do usuário estão em:
http://developer.Android.com/guide/developing/devices/emulator.html#acceleration
Para habilitar GPU aceleration, execute o emulador a partir da linha de comando ou adicione "-gpu on" às opções adicionais da linha de comando do emulador na configuração do AVD.
emulator -avd <avd_name> -gpu on
Para usar as extensões da máquina da CPU, é necessário instalar o driver (cuidado, pois pode entrar em conflito com os drivers existentes VirtualBox ou VMware ). Uma vez instalado, ele será usado automaticamente sempre que você usar um AVD baseado em x86.
Tente desativar seu antivírus. Talvez isso torne o emulador um pouco mais rápido.
Android SDK rev. 17 suporta aceleração de máquina virtual usando tecnologias de virtualização AMD e Intel.
Esse recurso pode melhorar muito o desempenho do emulador!
Consulte a seção a seguir na documentação do emulador do Android para obter mais detalhes: Configurando a aceleração de máquina virtual
Não esqueça de instalar o driver apropriado para o seu sistema operacional:
- Configurando VM Acceleration no Windows
- Configurando VM Acceleration no Mac
- Configurando VM Acceleration no Linux
Depois de ter instalado os drivers e baixado uma imagem do sistema Android X86 (como descrito na documentação), você deve ser capaz de criar um novo AVD usando a imagem x86:
Por exemplo:
- Destino: Imagem do Sistema Intel Atom x86 - Nível 10 da API
- CPU/ABI: Intel Atom (x86)
A opção -cpu-delay <delay> descrita emEmulator Startup Optionspode ajudar.
O emulador parece se desacelerar quando ocioso. Isso fica claro ao passar rapidamente as teclas ao lado e observar as respostas de iluminação. Como solução alternativa, passo -icount auto para QEMU ao iniciar o emulador. Você pode fazer um arquivo de lote chamado my_avd.bat para fazer isso por você:
emulador @my_avd -no-boot-anim -qemu -icount auto
@my_avd- inicia um dispositivo virtual chamado 'my_avd'-no-boot-anim- desativa a animação para inicialização mais rápida-qemu args...- passa argumentos para qemu-icount [N|auto]- habilita o contador de instruções virtuais com 2 ^ N pulsos de clock por instrução
Isso fez animações amanteigadas suavizar e acelerar adb install dez vezes.
Você pode analisar os problemas do emulador no Google I/O 2011: Ferramentas de desenvolvimento para Android talk, iniciando uma 0:40:20.
O emulador é executado lentamente porque o ambiente Android completo está sendo executado em hardware emulado e as instruções são executadas em um processador ARM emulado também.
O principal ponto de asfixia é a renderização, uma vez que não está sendo executado em nenhum hardware dedicado, mas na verdade está sendo executado através da renderização de software. Diminuir o tamanho da tela melhorará drasticamente o desempenho do emulador. Obter mais memória/mais rápida não vai ajudar.
Eles mencionaram, na época, que estão desenvolvendo uma interface que permitiria ao emulador canalizar certas instruções através do hardware do Host, assim, eventualmente, você será capaz de alavancar o desempenho do emulador com a força bruta do hardware de desktop.
O emulador Android versão 9 possui um novo recurso de "instantâneo". Você pode salvar o estado do emulador (criar uma imagem do emulador) e evitar a inicialização quando iniciar o emulador.
A versão atual (maio de 2011) do emulador é lenta particularmente com Android 3.0 (Honeycomb) principalmente porque o emulador não suporta hardware GL - isso significa que o GL código é traduzido em software (software ARM, na verdade) que depois é emulado em software em QEMU . Isso é loucamente lento. Eles estão trabalhando nesse problema e resolvem parcialmente, mas não com qualquer tipo de qualidade de lançamento.
Confira o vídeoGoogle I/O 2011: Ferramentas de desenvolvimento Androidpara vê-lo em ação - salte para cerca de 44 minutos.
Use o acelerador de emulador Intel x86
Primeiro, instale o Intel x86 Emulator Accelerator (HAXM). Isso pode ser baixado diretamente da Intel ou usando o Android SDK Manager. No SDK Manager, está localizado em Extras.
Na versão do Android Studio que usei (0.8.9), o Android SDK Manager baixa o HAXM, mas na verdade não executa o instalador (suponho que isso será corrigido em versões posteriores). Para executar o instalador eu tive que ir para C:\Arquivos de Programas (x86)\Android\android-studio\sdk\extras\intel\Hardware_Accelerated_Execution_Manager e manualmente iniciar intelhaxm.exe.
O HAXM trabalha com dispositivos Intel, então criou um novo Emulador com CPU Intel.
Crie um novo AVD usando o Intel Atom x86
Isso melhorou consideravelmente as coisas, mas o emulador ainda estava um pouco lento. A etapa final foi selecionar Use Host GPU no Android Virtual Device Manager (AVD).
Após essas alterações, o Android Emulator foi lançado em 5 a 10 segundos e executado sem nenhum atraso perceptível. Esteja ciente de que esses recursos dependem do hardware (CPU/GPU) e podem não funcionar em alguns sistemas.
Uma nova opção é o Visual Studio Emulator para Android - é rápido, Hyper-V , x86 e livre para download, mesmo sem VS .
Experimente Genymotion para o Android Studio. Ardente rápido! Só precisa de uma instalação de tempo. Não há mais dor AVD.
Para adicionar mais informações para isso.
Eu recentemente atualizei minha instalação do Ubuntu para Ubuntu 10.04 LTS (Lucid Lynx) que, por sua vez, atualizou minha versão de Java para:
Java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02)
Java HotSpot(TM) 64-Bit Server VM (build 16.3-b01, mixed mode)
E agora o emulador (embora demore um pouco para começar) parece estar funcionando mais rápido do que antes.
Pode valer a pena as pessoas atualizarem sua JVM.
Aqui está o que eu notei que ninguém mencionou nada.
Atribuir todos os processadores disponíveis para o emulador
Veja o que você pode tentar. Isso acelera o emulador para mim, especialmente durante o tempo de carregamento. Eu notei que o emulador está usando apenas um único núcleo da CPU disponível. Eu configurei para usar todos os processadores disponíveis.
Estou usando o Windows 7.
Quando o emulador do Android estiver iniciando, abra o Gerenciador de Tarefas, procure na guia Processo, procure "emulator-arm.exe" ou "emulator-arm.exe * 32" ... Clique com o botão direito do mouse sobre ele, selecione Afinidade com o Processador e atribua o máximo de processador que desejar ao emulador.
O emulador do Android é muito lento. Demora 800MB de memória durante a execução. Se você estiver no Windows, você pode usar o Microsoft Android Emulator. É excelente, oferece funcionalidades mais do que o Android Studio Emulator. E o mais importante é rápido (consome apenas 13MB). Ele vem com o Visual Studio 2015 Technical Preview. Eu estou usando e feliz com isso. Eu baixei e instalei todo o pacote VS, eu preciso olhar como podemos instalar apenas o VS Emulator.
Visual Studio Emulator para Android
EDIT: Experimente https://www.visualstudio.com/vs/msft-Android-emulator/
Após o desenvolvimento por um tempo, meu emulador ficou brutalmente lento. Eu escolhi limpar os dados do usuário , e foi muito melhor. Eu estou supondo que leva tempo para carregar cada arquivo APK que você tenha implementado.
Bem, já que alguém sugeriu o Android x86 como um emulador de testes alternativo, também apresentarei o meu favorito. Isso pode não ser uma alternativa para todos, mas para mim é perfeito!
Use o Bluestacks Player . Ele roda o Android 2.3.4 e é muito fluido e rápido. Às vezes, é ainda mais rápido que um dispositivo normal. A única desvantagem é que você pode testar aplicativos apenas no nível 10 da API e em apenas um tamanho de tela, mas é perfeito apenas para testar se está funcionando ou não. Basta conectar o Player com a adb executando
adb connect 127.0.0.1
Depois de compilar, ele é instalado instantaneamente. É muito impressionante, considerando que eu tenho um hardware de computador médio (dual core com 4 GB de RAM).
Eu tinha tempos de carregamento do emulador lento intermitente (SDK v8.0), até três minutos na CPU Intel Core i7 920 de 2,67 GHz rodando no Xubuntu 10.04 VirtualBox 3.2.12 guest com o Eclipse (3.6.1) carregado. Mudei a memória do convidado do VirtualBox de 1024 MB para 2048 MB e, a partir daí, nunca mais experimentei a lentidão (tempos de carregamento consistentes em 33 segundos, carga da CPU consistente em 20%). Tanto o Eclipse quanto o emulador são porcos de memória.
Eu notei que o meu emulador ( Eclipse plugin) foi significativamente retardado por minhas configurações de anti-aliasing de Nvidia placa gráfica. Remover 2x anti-aliasing do menu gráfico e alterá-lo para o aplicativo controlado tornou-o mais responsivo. Ainda é lento, mas melhor do que costumava ser.
Para reduzir o tempo de inicialização do emulador, é necessário marcar a opção "Desativar animação de inicialização" antes de iniciar o emulador. Consulte a documentação do Android .
Se você não souber, não precisará fechar o emulador toda vez que executar/depurar seu aplicativo. Se você clicar em executar/depurar quando já estiver aberto, o arquivo do APK será carregado no emulador e iniciado praticamente imediatamente. Emulador demora muito tempo apenas quando começou pela primeira vez.
Aqui estão algumas dicas para acelerar o emulador do Android:Como acelerar o emulador do Android em até 400%.
Uma boa maneira de acelerar o Android Emulator e o teste de aplicativos é Instalar ou Atualizar seu Android Studio para Android Studio 2.0 version e depois ir para o aplicativo abrir Configurações/Preferências, ir para Criar, Execução, Implantação → Execução Instantânea. Clique em Ativar Execução Instantânea. E depois disso Isso garantirá que você tenha o plug-in gradle correto para o seu projeto funcionar com o Instant Run. 
E a execução instantânea será parecida com esta 
No entanto, o Android Studio está agora na pré-visualização, você pode experimentá-lo agora.
As versões mais antigas do Android são muito mais rápidas. Quando estou no meu netbook, eu uso o Android 1.5 (nível de API 3). Há algumas desvantagens, no entanto - seus aplicativos precisam suportar as plataformas mais antigas (obviamente), e o ndk-gdb requer a execução do Android 2.2 (API nível 8) ou superior. No entanto, testar aplicativos regularmente em plataformas mais antigas é uma boa ideia.
Solução simples e fácil para iniciantes. Eu tentei de várias maneiras e parou com Genymotion em combinação com o Eclipse. O Genymotion simplesmente adiciona um dispositivo virtual ao Eclipse.
Passo a passo:
- Faça o download do Genymotion com o VirtualBox incluído em aqui .
- Instale este pacote incluso no VirtualBox.
- Instale o plug-in no Eclipse a partir de here .
- Inicie o GenyMotion, crie um dispositivo virtual que você deseja usar e inicie-o.
- No Eclipse, vá para Window -> Preferences -> GenyMobile -> GenyMotion , e defina o caminho para GenyMotion (no meu caso , C:/ProgramFiles/GenyMobile/Genymotion).
- Clique no nome de um projeto no Eclipse que você deseja iniciar. Inicie o aplicativo usando "Executar como". Na lista de dispositivos, você deve ver o dispositivo emulado.
- Você cam emular o que você quer.
No meu caso, esta solução é a única solução rápida. Nenhum emulador no Eclipse nunca funcionou tão rápido, e todas as configurações foram muito lentas. Só esta solução funciona quase em tempo real. Eu posso recomendar (notebook i3, 2,6 GHz).
Em um quad core de 3,4 GHz, 6 GB de RAM, o Windows 7, o emulador ficou inutilmente lento! Eu baixei Launcher-Pro.apk através do emulador, instalei-o e configurei-o como o inicializador padrão. Ele dobrou minha velocidade de emulação! As telas carregam muito mais suave e mais rápido. Não parece baixar em 2.1 ou 2.2, somente em 2.0.
Se você tiver uma CPU Intel, instale Intel Hardware Accelerated Execution Manager .
Em seguida, atribua-o como a CPU do emulador em Configurações do emulador . Quando fiz isso no meu Core i7 CPU, estava demorando cerca de 10 minutos. Agora está abrindo em 15 segundos.
Algumas coisas que definitivamente aceleraram as coisas para mim com isso foram
1. delegando o processo de renderização para a GPU, marcando a caixa de seleção " Use Host GPU " na janela de edição do AVD.
2. baixando o Intel Atom (x86) image ou se você é um windows / mac usuário baixando o Intel x86 Emulator Accelerator HAXM
Infelizmente, o que acontece com as imagens Intel x86 é que você não recebe o Google Apps, elas só vêm com imagens ARM.
que é onde Genymotion vem a calhar
- Baixe e instale VirtualBox . Para usuários do Windows, não é necessário instalar o VirtualBox separadamente, porque ele está disponível no site Genymotion, junto com o emulador Genymotion.
- Vá para site da Genymotion e inscreva-se. Você receberá um email de validação, portanto basta clicar no link de validação para continuar.
- Baixe e instale o emulador Genymotion.
- Inicie o Genymotion. Talvez seja necessário configurar o caminho para o local do Android SDK nas configurações do Genymotion (provavelmente, se você instalou o SDK em um local não padrão). Como esta é uma primeira partida, não há dispositivos. Clique em "Adicionar" e baixe o novo dispositivo. Para ver os dispositivos disponíveis, escreva suas credenciais na caixa de diálogo pop-up e clique em "Conectar".
- Selecione o dispositivo e clique em "Iniciar".
Eu me pergunto por que ninguém mencionou o Visual Studio Emulator como uma alternativa. É muito mais rápido que o Android Studio Emulator nativo.
Aqui está um link para comparação de desempenho: https://medium.com/Android-news/how-visual-studio-emulator-for-Android-can-improve-your-Android-development-9e17a6213839#.hlh7ba6ut
O que é ainda melhor é que os arquivos apk e até mesmo gapps (ou qualquer outro Zip flashable) podem ser instalados apenas por arrastar e soltar. No entanto, a desvantagem é que ele requer o Hyper-V, que está disponível apenas no Windows (também no Windows 8). Outras limitações (junto com a descrição acima) e outros detalhes podem ser encontradas aqui: https://blogs.msdn.Microsoft.com/visualstudioalm/2014/11/12/introducing-visual-studios-emulator- para Android/
Para uma melhor experiência, eu recomendaria o genymotion licenciado do shop.genymotion.com. Se você quiser testá-lo, primeiro você pode obter genymotion aqui
Eu tentei inicializar o emulador do Eclipse (Indigo e Android 1.5, sem instantâneo) e depois de 45 minutos eu parei, porque nada tinha acontecido.
Estatísticas: Phenom Quad a 2,6 MHz com 4 GB DDR2 Corsair Dominator a 800 MHz. O AVD está em uma unidade SSD e o emulador em um HDD de 7200 RPM.
Eu iniciei o emulador manualmente com a opção -no-boot-anim e ele carregou em 30 segundos. :)
No CMD, navegue até a pasta onde está o arquivo emulator.exe e digite
emulator.exe @<YourAVDFromEclipse> -no-boot-anim
O arquivo emulator.exe está localizado na pasta Android SDK, em Ferramentas.
No Windows, você pode encontrar o dispositivo virtual Android (AVD) em C:\Users\<NAME>\.Android\avd.
Os projetos executados dentro do Eclipse, direcionados ao AVD que você inicializou, aparecem bem: D
Você pode experimentar nossa nova máquina virtual Android, Leapdroid, que é totalmente compatível com o emulador Android original. Como ele usa tecnologia de virtualização, em vez de emulação, ele fornece praticamente a velocidade nativa. Além disso, usamos uma nova tecnologia OpenGL chamada LeapGL, que executa gráficos OpenGL em velocidade nativa. Nosso vm tem o melhor desempenho comparado aos outros.
Código fonte: https://github.com/leapdroid
O Leapdroid é totalmente compatível com o Eclipse e o Android Studio, pois usa as mesmas portas adb.
Minha solução é Vysor . Eu pego os dois melhores mundos. Eu não coloco muita carga na minha máquina, mas eu também posso ver meu verdadeiro dispositivo Android na tela, então eu não tenho que pegá-lo, tirar minhas mãos do teclado, etc. Além disso, há sempre alguns recursos que não funciona melhor em um emulador.
Há uma versão gratuita com anúncios e um pago que, em comparação com outras soluções, não vai quebrar o banco.
O Android ADT 18 agora inclui uma opção (beta) habilitada para GPU (basta ativar a aceleração de GPU a partir de suas propriedades AVD). Faz uma enorme diferença e até mesmo ICS se sente relativamente confortável agora.
Você pode experimentar o Genymotion em vez do emulador do Android. É mais rápido e melhor que o emulador do Android.
Gostaria de insistir para que você instale o BlueStacks agora, pois ele funciona da mesma forma que o emulador com muitas outras funcionalidades (por exemplo, ele dá acesso ao Android Market). Além disso, você pode executar aplicativos diretamente do Eclipse para o BlueStack Device/Emulator com uma excelente velocidade de desempenho. Leva apenas uma fração de segundo para executar seu aplicativo do Eclipse para o emulador BlueStack.
Agora, em vez de usar o emulador, podemos testar aplicativos Android usando o aplicativo ARC Welder no Chrome, Tempo de Execução do Aplicativo para Chrome
Eu só notei algo que não posso explicar, mas hey, para mim funciona!
Eu estava compilando Android a partir de fontes de qualquer maneira e o emulador embutido começou em poucos segundos (minha máquina é dual core AMD 2.7 GHz) e em um minuto, talvez dois na primeira execução, o sistema estava funcionando. O uso do pacote configurável Eclipse ADT, por outro lado, resultou em meia hora de inicialização do emulador. Inaceitável.
A solução que funciona aqui (não tenho como testá-lo em outras máquinas, então se você se sentir inclinado, testar e verificar):
- Faça o download e crie o Android SDK em sua máquina. Pode levar algum tempo (você sabe, a compilação de todo o sistema é cansativa). Instruções podem ser encontradas aqui:
- Inicializando
- Fazendo download
- Construção (eu mudei comandos para 'lunch sdk-eng' e 'make sdk -j4'; além disso, dicas de construção são úteis, especialmente em relação a opções ccache e -jN)
- Quando terminar, execute "Android" e o gerenciador do SDK deve aparecer. Baixe ferramentas e pacotes de plataforma desejados. Se os comandos não forem encontrados, tente executar novamente '. Comandos build/envsetup.sh 'e' lunch sdk-eng 'para configurar os pathes; eles são perdidos depois de sair de uma sessão de terminal.
- Execute o 'emulador' para verificar o quão rápido ele é iniciado. Para mim, é MUITO mais rápido que o pacote do Eclipse.
- Se isso funcionar, aponte o Eclipse para o SDK que você acabou de compilar. Preferências de janelas-Android no painel esquerdo -> escolha o local do SDK. Deve ser dir com subdiretório 'tools' e algo no subdiretório 'platform'. Para mim é
<source base dir>/out/Host/linux-x86 - Aplicar/OK, reinicie o Eclipse, se necessário. Se não reclamar nada, execute o seu aplicativo Android. No meu caso, o emulador começa em poucos segundos e termina a inicialização em menos de um minuto. Ainda há um pouco de atraso, mas é totalmente aceitável para mim.
Além disso, concordo com a execução de instantâneo e salvar estado em instantâneo. Meu conselho diz respeito apenas ao tempo de inicialização do emulador. Eu ainda não tenho idéia porque é tão longo por padrão. De qualquer forma, se isso funciona para você, aproveite :)
Os emuladores mais rápidos no momento de escrever isso são os emuladores x86 embutidos que vêm com o Android SDK. Você pode encontrá-los no gerenciador de AVD, onde você cria máquinas virtuais. Basta escolher qualquer um deles e depois escolher o tipo de CPU (escolha x86 para obter o melhor desempenho). Será tão rápido quanto sua máquina.
A mais recente dessas máquinas para Android 4.0 e 4.0.3 pode ser encontrada emDando ao seu emulador Android um impulso: Construindo o Android ICS com o Goldfish & x86 KVM suporte no EC2 - TestObject.
Nota: Isso é apenas para fins de desenvolvimento. Para testar o desempenho, você ainda deve usar um dispositivo real ou testar o emulador com ARM CPU.
Você precisa de mais memória.
Aqui está o porquê eu digo isso:
Estou usando o VirtualBox no Windows para executar o Ubuntu 10.10 como convidado. Eu instalei o Eclipse e o Android SDK na VM. Minha caixa física tem 4 GB de memória, mas quando eu configurei pela primeira vez a máquina virtual Ubuntu, eu só dei 1 GB. O emulador levou cerca de 15 minutos para ser lançado. Então, mudei minha configuração para dar o VM 2 GB e o emulador estava rodando em menos de um minuto.
Você pode baixar o emulador de genymotion de aqui . Isso é rápido e eficiente.
Eu tenho problemas semelhantes em um Mac. O que eu fiz;
- 1) no emulador, configurações de exibição -> desativar a orientação da tela
- 2) no Eclipse, opções de inicialização do emulador -> -cpu-delay 100
Isso teve algum efeito na redução do uso da CPU (não em torno de 40-60%), e não na solução final. Mas, novamente, o uso da CPU não é> 100% mais!
Eu notei que um emulador fica lento durante um período de tempo. Assim, pode-se excluir o emulador que fica muito lento e criar um novo com a ajuda do gerenciador do AVD. Eu tentei algumas vezes e funciona bem.
Eu sugiro que você use o telefone Android para desenvolvimento por depuração USB. Ele oferece uma melhor experiência no teste dos aplicativos e uma melhor saída em comparação aos dispositivos virtuais. Ou você também pode usar as opções mencionadas no resto das respostas e pode ir com o Bluestacks App Player, também é uma boa opção em caso de indisponibilidade de dispositivos Android.
Foram-se aqueles dias em que costumávamos executar projetos em Emuladores Android lentos. Hoje, os emuladores do Android estão em esteróides .. Sim, você me ouviu. Nenhum outro emulador é tão rápido quanto os emuladores do Android. Você pode ir ao meu blog para mais detalhes:
http://androidveteran.blogspot.in/2016/01/Android-emulator-multi-touch.html
Eu expliquei em detalhes sobre novos Emuladores do Android. Confira.
Acredite, eles são tão rápidos quanto o seu dispositivo real funciona.
Isso é o que funcionou para mim:
- Definindo AVD RAM para 512 MB
- Definir a memória do cartão SD para 10 MB
- Definir um tamanho grande de memória no cartão SD é uma das maiores causas de um AVD lento.
Eu sugeriria brincar com as configurações do OpenGL. Eu tenho um i3-2350M dual-core (quad-thread) rodando em sua GPU interna, e eu fico com um péssimo desempenho se eu uso SwiftShaders, mas mudá-lo para "Desktop Native OpenGL" (Extended Controls > Settings > OpenGL ES Renderer) faz com que ele corra bem.
Se o dispositivo não inicializar, execute a configuração OpenGL ES API Level e a configuração de emulação da GPU na configuração do dispositivo.
Eu não sei porque, mas no meu processador Intel 2011, faz um mundo de diferença.
Remova a ativação indesejada de alguns dos plug-ins na inicialização acessando windows -> preference -> General -> Startup e shutdown. Além disso, certifique-se de não usar esses plug-ins em nenhuma das suas visualizações
O Eclipse não é um processador de texto. Melhor desativar a verificação ortográfica. Desativar a verificação ortográfica reduzirá a carga do Eclipse acessando Windows -> Preferência -> Geral -> Editores -> Editores de Texto -> Ortografia
Quando o Eclipse constrói o projeto, ele irá excluir todas as pastas de saída e reconstruir as classes construídas por outros compiladores. Podemos desativar esses recursos, pois a exclusão das pastas de saída e a reconstrução levarão algum tempo. Ir para o Windows -> Preferência -> Java -> Compiler -> Building
Desabilitar as decorações das etiquetas, que são de menor uso para você, também ajudará você a ganhar algum desempenho. Vá para o Windows -> Preferência -> Geral -> Aparência -> Decorações de etiquetas
Feche projetos indesejados e use a opção de conjunto de trabalho para passar de um grupo de projeto para outro sem problemas.
Você também pode desativar a construção automática do Eclipse, se ela não for necessária para você. Goto Project -> Construir Automaticamente (desmarque-o)
Não mantenha muitas guias abertas no editor. Melhor ter cerca de 20 abas. Feche regularmente as guias não usadas. Para abrir o recurso, podemos sempre usar ctrl + shift + R e ctrl + shift + T (recurso Java) em vez de abrir muitas guias
Desativar plugins indesejados. A versão completa do J2EE Eclipse possui uma opção para desativar/desinstalar plug-ins. Vá para Ajuda -> Atualizações de Software -> Gerenciar Configuração. Clique com o botão direito em qualquer plug-in instalado para obter a opção de desativação. Se essa opção não estiver disponível, ative a Atualização Clássica acessando Windows -> Preferência -> Capabilty e verifique a atualização clássica. Agora, a opção de configuração gerenciar deve estar disponível no menu de ajuda
Tente reduzir o tamanho da tela do emulador ao criar um novo dispositivo Android virtual.
Eu vi que isso vai lançar o emulador muito rápido em comparação com as opções padrão fornecidas no gerenciador de AVD.
Usando o utilitário ADB, descobri mais algumas informações importantes.
O emulador está realmente em execução, mas parece que a interface gráfica pode ser o problema.
Quando a tela inicial do Android está ativa e você está sempre esperando, parece o seguinte: 
O emulador está realmente em execução porque você pode executar a seguinte ferramenta de linha de comando e ver os processos listados:
adb -s emulator-5554 Shell ps
Isso fornecerá uma lista de processos que estão sendo executados no dispositivo, o que parece estar parado.
Eu canalizei a saída para um arquivo e aqui está uma lista de todos os processos em execução:
USER PID PPID VSIZE RSS WCHAN PC NAME
root 1 0 696 500 c02ae25a 0805a406 S /init
root 2 0 0 0 c02315a2 00000000 S kthreadd
root 3 2 0 0 c021f9dc 00000000 S ksoftirqd/0
root 5 2 0 0 c022e8d7 00000000 S kworker/u:0
root 6 2 0 0 c022e085 00000000 S khelper
root 7 2 0 0 c022e8d7 00000000 S kworker/u:1
root 255 2 0 0 c02886de 00000000 S sync_supers
root 257 2 0 0 c028935e 00000000 S bdi-default
root 259 2 0 0 c022e085 00000000 S kblockd
root 267 2 0 0 c022e085 00000000 S ata_sff
root 278 2 0 0 c04f610f 00000000 S khubd
root 283 2 0 0 c022e085 00000000 S md
root 297 2 0 0 c022e085 00000000 S cfg80211
root 298 2 0 0 c022e8d7 00000000 S kworker/0:1
root 413 2 0 0 c0283057 00000000 S kswapd0
root 481 2 0 0 c02cd713 00000000 S fsnotify_mark
root 501 2 0 0 c022e085 00000000 S crypto
root 590 2 0 0 c022e085 00000000 S iscsi_eh
root 611 2 0 0 c048aa21 00000000 S mtdblock0
root 619 2 0 0 c048aa21 00000000 S mtdblock1
root 627 2 0 0 c048aa21 00000000 S mtdblock2
root 666 2 0 0 c022e8d7 00000000 S kworker/0:2
root 700 2 0 0 c022e085 00000000 S binder
root 724 2 0 0 c022e085 00000000 S deferwq
root 725 1 624 348 c02ae25a 0805a406 S /sbin/ueventd
root 932 2 0 0 c055236e 00000000 S mmcqd/0
root 939 2 0 0 c0340f30 00000000 S yaffs-bg-1
root 941 2 0 0 c0340f30 00000000 S yaffs-bg-1
root 942 2 0 0 c0340f30 00000000 S yaffs-bg-1
system 943 1 1340 400 c056a35d b76a1eb6 S /system/bin/servicemanager
root 944 1 5540 924 ffffffff b7646c11 S /system/bin/vold
root 947 1 1548 504 c05785ce b766c163 S /system/bin/debuggerd
radio 948 1 6420 1016 ffffffff b76d3c11 S /system/bin/rild
system 949 1 20088 2876 ffffffff b7655eb6 S /system/bin/surfaceflinger
drm 951 1 10480 2920 ffffffff b7585eb6 S /system/bin/drmserver
keystore 954 1 5036 1416 c056a35d b765deb6 S /system/bin/keystore
root 955 1 1324 440 c02d0083 b76b28ab S /system/bin/qemud
Shell 958 1 1428 668 c03e9ad9 b767fa76 S /system/bin/sh
root 959 1 4680 304 ffffffff 08063530 S /sbin/adbd
graphics 1012 1 17980 4276 ffffffff b7652eb6 S /system/bin/bootanimation
media 4743 1 25288 6232 ffffffff b75beeb6 S /system/bin/mediaserver
root 4744 1 3944 1164 00000000 b7628976 R /system/bin/netd
root 4770 4744 0 0 c021de78 00000000 Z iptables
root 4771 959 1768 540 00000000 b766fa76 R ps
Por diversão eu então corri o seguinte comando e matei a animação "Android":
adb -s emulator-5554 Shell kill 1012
A tela inicial ficou em branco, então algo está realmente acontecendo.
Eu tentei e consegui matar alguns outros processos e isso me fez sentir bem, mas o emulador ainda não parecia começar. Ah bem. Estou executando um QuadCore i7 com 8GB de RAM. Também executando o haxm com as configurações descritas em outras postagens desta questão.
Nota : Estou atualizando isso em 19/09/2014 - Aprendi que esse comportamento estranho onde o emulador tentaria iniciar a instância, mas nunca estaria relacionado aos direitos de arquivo nos arquivos do emulador. Eles foram configurados para somente leitura devido à maneira como foram copiados, portanto, o emulador tenta instalar e gravar em seu "disco virtual", mas é "disco virtual", na verdade, um arquivo ou conjunto de arquivos que meu sistema operacional configurou para ler -apenas e assim falha. Essas falhas fazem com que o emulador nunca seja iniciado. Eu defino os arquivos para acesso total e o emulador é iniciado em tempo recorde.
Tente reduzir o tamanho da tela, e talvez você deva considerar o uso do Ubuntu . Eu tive o mesmo problema e, de alguma forma, meu emulador no mesmo PC funciona cinco vezes mais rápido ao usar o Linux.
Eu apenas peguei o padrão 3.1 do Android, e foi muito lento, mas desde que eu percebi que meu código era compatível com o Android 2.3.3 eu mudei para isso. É cerca de 50% mais rápido e também o emulador se parece mais com meu telefone e tem um teclado permanentemente exibido para que seja mais fácil de usar.
Adicione um pouco mais RAM e use a unidade SSD. O Android Studio é melhor executado em 8 a 12 GB de RAM usando unidades SSD com base na minha experiência.
Em AVD Manager selecione o VD e clique em edit, defina a resolução para pouco, pois você pode ler o texto em VD.
Eu uso 800x600 pixels, RAM definido como 512 MB, e funciona como um charme sem o uso excessivo do tempo da CPU.
O uso do Android x86 oferece melhor produtividade que o emulador do Android.
Ao trabalhar com o Android x86 4.2, ele fornece depuração extremamente rápida em comparação ao emulador Android. É muitas vezes mais rápido para configuração
Ele está trabalhando com o mais recente Android X86 4.2 (Jelly Bean) e VirtualBox .
Eu encontrei diferentes maneiras de se conectar com a Internet e ADB .
Passo: 1 Seleção de Adaptadores
CASO 1: Apenas Internet {Adaptador NAT}
A solução mais fácil é apenas usar um adaptador NAT que irá conectá-lo diretamente à Internet se o host estiver conectado à Internet, mas você não obterá a conexão ADB com essa configuração.
Aqui você obterá um endereço IP público, portanto, não poderá se conectar ao computador Host.
Caso 2: somente ADB (adaptador somente host)
A solução mais fácil é apenas usar o adaptador somente host.
Observação: O adaptador somente host padrão pode não funcionar devido a DHCP configurações do servidor. Crie um novo HostOnlyAdapter ou execute DHCP server para um adaptador existente.
Caso 3: para ADB e Internet (adaptador de ponte)
Você terá que tomar cuidado neste caso.
Se você estiver usando a LAN para a conexão com a Internet, você deverá usar o adaptador de ponte com sua placa Ethernet. Ele fornecerá um endereço IP local e a máquina virtual se conectará à Internet usando a máquina host.
Alternativamente, se você estiver com Wi-Fi, basta fazer o mesmo, selecionando o adaptador Wi-Fi.
Para outros tipos de conexão, você deve seguir o mesmo caminho.
Etapa: 2 Conexão com o ADB
Para verificar o endereço IP, basta pressionar Alt+F1 (para uma janela do console). (Para voltar para a visualização de gráficos, pressione Alt+F7.)
Você verá a janela do console. Digite netcfg .
Ele mostrará o endereço IP.
Agora, vá para o seu Host, execute o comando Prompt e mova para o diretório adb.
type adb connect <your IP address>
Exemplo
adb conectar 192.168.1.51
Nota: Se o ADB não estiver em execução ou respondendo, você poderá fazer o seguinte.
adb kill-server
adb start-server
Você pode verificar os dispositivos conectados ao ADB:
adb devices
Para a pergunta original, clique aqui .
Agora, no ADT 21, ele fornece mais opções para um emulador rápido ... Você deve usar 512 MB de RAM, menor tempo de CPU, seleção de dispositivo e VM Tamanho de heap alto. Para melhores resultados, você deve usar Intel Atom em CPU/ABI ... Usando Snapshot e CPU Host não pode aumentar sua velocidade do emulador, mas existem os úteis para outros fins.
Resposta curta: por causa das traduções das instruções ARM -> x86. O emulador funciona de forma semelhante a uma máquina virtual que é encarregada de inicializar um sistema operacional completo e executar o aplicativo de teste posteriormente. As traduções do ARM -> x86 podem ser muito demoradas, menos para o seu aplicativo, mas mais para quando o sistema operacional está inicializando (é proporcional à complexidade e ao número de instruções envolvidas).
Alguns sugeriram executar o código em emuladores x86. O que isto significa é que ao invés de carregar um sistema operacional baseado em ARM, você carrega uma variante x86 que rodará mais rápido em sua máquina x86, já que nenhuma tradução ARM-> x86 é necessária. Ainda assim, esta não é uma solução perfeita:
Os aplicativos Android que usam o NDK e vêm compactados com libs nativas (* .so) compilados para o ARM, não funcionarão em emuladores x86, portanto, esses programas não serão executados. Mas se você chegar a esse ponto e conseguir lidar com o código JNI nativo/NDK, provavelmente já sabe o suficiente sobre emuladores.
Eu comecei ontem no Windows 7 e estava enfrentando o mesmo problema. A solução mais fácil, eu encontrei e está trabalhando para mim é usar o dispositivo de baixa configuração no emulador. Usei o Nexus One em vez do Nexus 7 e selecione o instantâneo para o dispositivo no Android Virtual Device.
E, também importante é deixar em aberto o emulador. Funciona tanto no Eclipse quanto no Android Studio.
Em uma janela, o snapshot geralmente não funciona quando RAM é maior que ~ 700. Portanto, selecionar um configurado mais baixo ajuda facilmente a testar o Hello World e depois desenvolver seu aplicativo. Mais tarde, podemos testar em um dispositivo de última geração.
Para mim, o suporte à virtualização não funciona, pois meu hardware não suporta isso.
Para testes rápidos (<1 segundo) use buildroid com a primeira placa de rede do VirtualBox definida como “Host only network” e depois execute
C:\Program Files (x86)\Android\android-sdk\platform-tools>adb connect *.*.*.*:5555
connected to *.*.*.*:5555
(^) DOS/bash (v)
# adb connect *.*.*.*:5555
connected to *.*.*.*:5555
onde *. * *. * é o endereço IP do buildroid obtido clicando no aplicativo buildroid na tela principal do buildroid.
Atualize seu atual Android Studio para Android Studio 2.0 E também atualize as imagens do sistema.
O emulador do Android Studio 2.0 é executado três vezes mais rápido que o emulador anterior do Android. Agora, com os aprimoramentos do ADB, você pode enviar aplicativos e dados 10 vezes mais rápido ao emulador do que a um dispositivo físico. Como um dispositivo físico, o emulador oficial do Android também inclui Google Play Services built-in, para que você possa testar mais funcionalidades da API. Finalmente, o novo emulador tem novos recursos para gerenciar chamadas, bateria, rede, GPS e muito mais.
Tente reduzir o emulador, ele fica um pouco mais rápido, mesmo que não pareça mais rápido.
Se você puder, mude para usar o desenvolvimento do Ubuntu para Android. Eu mudei para o Ubuntu 14.04 LTS para desenvolvimento Android, e estou feliz que eu dei o salto. Todas as etapas mencionadas fizeram pouca ou nenhuma diferença no atraso no Windows. O Linux é a resposta correta para todos os problemas que você está enfrentando
Android studio 2.02 foi lançado, tem emuladores mais rápidos, se você quiser ir com terceiros, use emuladores Genymotion, eles são muito rápidos
Tente usar o Intel X86 Atom Storage Image para uma inicialização relativamente mais rápida do que usando imagens baseadas em ARM ao emular o dispositivo.
Outra coisa a ser levada em consideração é que, de acordo com a configuração do seu sistema, rodar um emulador Android com 1,21 GB RAM pode ser uma experiência lenta, porque o emulador requer até certa porcentagem de RAM que é usado para emular o dispositivo, sem esquecer o RAM usado pelo ADT.
Tente uma imagem do sistema de 2.1 - 2.3.3 para pelo menos uma experiência executável. Além disso, não se esqueça de Save to Snapshot para carregamento mais rápido. Embora a primeira carga possa levar tempo. Mas salvar para um instantâneo definitivamente economiza algum tempo.
Ativar o instantâneo pode não torná-lo mais rápido na primeira execução; não vá para grande tamanho SD. Ajuste o tamanho do cartão SD para 100 MB na primeira execução.
Em primeiro lugar, você precisa atualizar seu RAM para pelo menos 8GB.
Se você não pode atualizar sua memória RAM, tente executar o aplicativo em seu telefone Android conectando-o via cabo de dados e depuração USB definido como ON.
Além disso, você pode usar alguns outros emuladores como GenyMotion ou Nox .
No entanto, com a quantidade de RAM que você parece estar tendo, até mesmo outros emuladores tendem a ser lentos.
HAXM é uma maneira de tornar os emuladores rápidos para processadores intel HAXM é a parte do driver do kernel, e a parte do emulador de espaço do usuário é baseada em QEMU - o que significa existe uma ramificação de QEMU que usa HAXM (Este QEMU branch é muito específico para emulador Android (e também parece ser baseado em uma versão mais antiga de QEMU ).
Mas ainda quando eu usei com meu intel core i3 processador com 4 GigaBytes RAM não afeta mais a velocidade. Então isso não foi uma solução para mim.
Como eu estou usando 4GB RAM CPU Emulator torna RAM comedor, mas para torná-lo mais conveniente, existem algumas maneiras que eu prefiro Android * 86 support based emulador. E como estúdio Android agora introduzir Instant-Run So Após a primeira instalação do aplicativo de lançamento tornou-se mais rápido, mas eu sempre enfrentou problema e parece que não é maneira de sair dessa.
Eu também usei Droid4x e ele é preety conveniente para mim, mas eu não consigo encontrar uma maneira de instalar diferentes versões de API, eu usei com KitKat e foi mais rápido que o emulador Android e é também Suporte a VT ativado , Então eu encontrei uma outra maneira e uma boa solução que éVisual Studio EmulatorVocê pode ler mais sobre isso aqui , O mais recente i usado é LeapDroid é realmente um poderoso Veja as comparações aqui
Eu prefiro usar o dispositivo real, em seguida, emuladores em PCs de 4 GB.
Eu tive o mesmo problema, mas consertei excluindo a pasta .Android de C:\Users\User\.
Agora toda vez que eu inicio o Eclipse ou o AVD, eu apago essa pasta. Depois disso, meu AVD inicializa em 20 a 30 segundos e o emulador funciona suavemente com um atraso insignificante.
OPCIONAL: Se o problema persistir, tente clonar o NEXUS S AVD.