Estou no Mac, trabalhando no desenvolvimento do Android a partir do terminal. Criei com sucesso o projeto HelloWorld e agora estou tentando executá-lo na linha de comando no emulador do Android. Qual comando executa o emulador para o meu projeto HelloWorld?

Já tenho as ferramentas e ferramentas de plataforma Android no meu PATH.

Editar:

Como eu digo ao emulador para executar meu projeto HelloWorld a partir da linha de comando? Eu já construí o projeto com formiga.

Presumo que você criou seu projeto e só precisa iniciá-lo, mas você não possui nenhum AVDs criado e precisa usar a linha de comando para todas as ações. Você precisa fazer o seguinte.

1. Crie um novo dispositivo virtual (AVD) para a plataforma que você precisa. Se você precisar usar a linha de comando para criar seu AVD, poderá chamar android create avd -n <name> -t <targetID>onde targetID é o nível da API necessário. Se você pode usar a GUI, basta digitar android avde ele iniciará o gerenciador, onde você poderá fazer o mesmo. Você pode ler mais sobre o gerenciamento do AVD através da GUI e da linha de comando .
2. Execute o AVD usando o comando emulator -avd <name>ou através da GUI iniciada anteriormente. Aguarde até o emulador carregar completamente, isso leva algum tempo. Você pode ler sobre opções adicionais aqui .
3. Agora você precisa instalar o aplicativo no seu AVD. Normalmente, durante o desenvolvimento, você apenas usa o mesmo script Ant usado para criar o projeto, basta selecionar o installdestino. No entanto, você pode instalar o aplicativo manualmente usando comandos adb install <path-to-your-APK>.
4. Agora mude para o emulador e inicie seu aplicativo como em qualquer dispositivo normal, através do iniciador. Ou, como alternativa, você pode usar o seguinte comando: adb shell am start -a android.intent.action.MAIN -n <package>/<activity class>. Por exemplo: adb shell am start -a android.intent.action.MAIN -n org.sample.helloworld/org.sample.helloworld.HelloWorld. Como sugeriu um comentarista, você também pode substituir org.sample.helloworld.HelloWorldna linha acima por just .HelloWorld, e funcionará também.

Liste todos os seus emuladores:

emulator -list-avds

Execute um dos emuladores listados com o -avdsinalizador:

emulator -avd @name-of-your-emulator

em que emulatorestá abaixo:

${ANDROID_SDK}/tools/emulator

Eu acho que a melhor maneira de alcançá-lo via terminal é:

cd ~/Library/Android/sdk/tools

Para executar um certo AVD diretamente:

./emulator -avd {AVD_NAME}

Para listar seus AVDs, use:

./emulator -list-avds

Apenas para adicionar aqui, sempre que você receber "error: device offline" significa que a conexão com o emulador e a ponte adb foi interrompida devido ao tempo gasto na inicialização do emulador.

Em vez de reiniciar o emulador neste momento, tente abaixo de dois comandos que param e iniciam o adb bridge novamente.

adb kill-server

adb start-server

Aqui você pode verificar as opções para executar este comando via linha de comando:

emulator -avd avd_name [-option [value]] ... [-qemu args]

Por exemplo, eu uso-o assim abaixo:

emulator -avd ICS_ARM -wipe-data -no-boot-anim -cpu-delay 0

CMD aberto

1. Prompt de Comando Aberto
2. digite o caminho do emulador no meu caso

C: \ adt-pacote-windows-x86_64-20140702 \ sdk \ tools

3. escreva "emulator -avd emulatorname" no meu caso

emulador -avd AdilVD

Se você está tentando executar estritamente o emulador na linha de comando, tente isso no OSX.

"/Applications/Android Studio.app/sdk/tools/emulator" -avd <NAMEOFDEVICE> -netspeed full -netdelay none

Você pode simplificá-lo adicionando um alias ao .bash_profile e enviando-o para um trabalho em segundo plano.

alias android='/Applications/Android\ Studio.app/sdk/tools/emulator <NAMEOFDEVICE> -netspeed full -netdelay none &'

Informe o Bash sobre as alterações.

source ~/.bash_profile

Abra o prompt de comando e vá para <android-Home>\sdk\tools>emulator -avd <AVD_NAME>

Aqui "emulator"está o comando usado para abrir o seu dispositivo virtual Android .

Se você possui o Git Bash, pode abrir seu emulador com um clique duplo, com algumas configurações iniciais (testadas apenas no Windows 10) :

1. Abra o Git Bash.
2. Corre cd ~/AppData/Local/Android/sdk/emulator
3. Execute ./emulator -list-avdse anote o nome do emulador. MY_EMULATORpor exemplo.

4. Abra o Bloco de notas e adicione estas duas linhas (insira o nome do seu emulador em vez de MY_EMULATOR):

   cd ~/AppData/Local/Android/sdk/emulator; ./emulator -avd MY_EMULATOR

5. Salve o arquivo em algum lugar conveniente como myfile. sh . Você pode alterar "myfile" como melhor lhe convier, mas a extensão .sh é necessária.

6. Abra o Git Bash no diretório em que você armazenou myfile.sh e execute chmod +x myfile.sh. Lembre-se de colocar o nome do seu arquivo em vez de meu arquivo .

E é isso! A partir de agora, sempre que você precisar iniciar o emulador, localize o myfile.sh e clique duas vezes nele e aguarde o lançamento do emulador do Android!

(Linux) No seu terminal Copy & Paste e alterando os três campos em azul

/home/YouUser/Folder/adt-bundle-linux-x86_64-20140702/sdk/tools/emulator64-x86 -avd Android5.1.1

YouUser = user of session in linux
Folder = path of folfer
Android5.1.1 = You version of android in the emulator,for example (Android4.4.2)

você pode visualizar os emuladores na pasta home cd /home/Youuser/.android/avd/

O android create avdcomando está obsoleto. Agora, é recomendado usar avdmanagerpara iniciar emuladores a partir da linha de comando.

Primeiro, crie um novo emulador se ele ainda não existir:

avdmanager create avd --name "MyEmulator" -k "system-images;android-
26;google_apis;x86"

Isso pressupõe que você já tem uma imagem do sistema X86 instalada que corresponde à API 26 e possui as APIs do Google instaladas.

Você pode iniciar o emulador com emulator @MyEmulator.

Hoje em dia, supondo que você tenha o Android Studio instalado (2.2) no meu caso e apenas um emulador, você pode usar este liner

export ANDROID_SDK_ROOT=~/Library/Android/sdk/ && emulator '@'`emulator -list-avds`

Se você fizer isso com frequência, facilite:

$ echo 'export ANDROID_SDK_ROOT=~/Library/Android/sdk/' >> ~/.profile

Adicione um alias para ~.aliases

alias androidup="emulator '@'`emulator -list-avds`" 

Lembre-se de source ~/.profile ~/.aliasesantes de testá-lo

Da próxima vez apenas $ androidup

lista de nome avd disponível em

.android / avd

/ SDK_PATH / tools / emulator -netdelay none -netspeed full -avd "AVD_NAME"

No Windows, eu uso esse script do PowerShell para iniciá-lo.

$em = $env:USERPROFILE+"\AppData\Local\Android\sdk\tools\emulator.exe"; 
Start-Process $em " -avd Nexus_5X_API_24" -WindowStyle Hidden;

1. CMD aberto
2. Para obter toda a lista de emuladores (C: \ Usuários \ DJango \ AppData \ Local \ Android \ sdk \ emulador> emulador -list-avds)
3. Escolha qualquer emulador (C: \ Usuários \ DJango \ AppData \ Local \ Android \ sdk \ emulador> emulador -avd Pixel_2_API_28)

No Mac (e no Linux, eu acho), depois de criar seu AVD, você pode criar um alias: alias run-android='~/Library/Android/sdk/tools/emulator -avd ${YOUR_AVD_NAME} &'

Nota : a execução do alias não bloqueará o seu terminal; se você desejar, basta remover o último '&' .

Se rodar emulatorsozinho, você receberá um erro porque ele espera que, na sua posição atual, você tenha: /emulator/qemu/${YOUR_PATFORM}/qemu-system-x86_64'para iniciar o emulador.

Eu escrevi esse script de shell simples usando o Zenity que permite escolher qual avd você deseja executar. Se você não tiver ANDROID_HOME definido, basta substituí-lo pelo caminho completo para o emulador. Isso seria fácil de fazer com o select, em vez do Zenity, mas optei pelo Zenity, já que estou executando no menu do aplicativo xfce (embora seja um arquivo .desktop).

#!/bin/sh

opt=$(zenity --title="Choose AVD" --text="Choose which emulator to start" --list \
                   --column="Devices" --separator="\n" `$ANDROID_HOME/emulator/emulator -list-avds`);

$ANDROID_HOME/emulator/emulator -avd $opt

Execute o primeiro emulador disponível:

~/Library/Android/sdk/tools/emulator -avd `~/Library/Android/sdk/tools/emulator -list-avds | awk '{print $1}'`

Estou atrasado, aqui, mas quero compartilhar, pode ser que ajude alguém e eu também quando for necessário mais tarde :), Então abaixo está o caminho para abrir o emulador da linha de comando com um comando usando o script bash. Estou usando o MX Linux, mas o processo é o mesmo em todos os sistemas operacionais

1- Primeiro verifique os emuladores instalados

emulator -list-avds

resultará como abaixo

emulator -list-avds
Nexus_4_API_28
Pixel_2_API_28

2- abra qualquer editor de texto ou código simples, crie um novo arquivo e escreva como abaixo

#!/bin/sh
emulator -avd Nexus_4_API_28

Nexus_4_API_28 é o emulador que eu quero abrir, escreva o seu que você obteve desde o primeiro passo

salve este arquivo com extensão .sh

3- Em seguida, altere as permissões no arquivo para torná-lo executável:

chmod u+x emu.sh

4- Agora abra o emulador apenas executando este arquivo de script bash com o seguinte comando

./emu.sh

Iniciando o emulador a partir da linha de comando com a ajuda do dns

Local do programa emulador: / Usuários / {{UserName}} / Biblioteca / Android / sdk / tools

1. Verifique o avd existente: - emulator -list-avds

2. Inicie o emulador com o conjunto de DNS / Users / {{UserName}} / Library / Android / sdk / tools / emulator -avd Pixel_API_26 -dns-server 8.8.8.8

Veja abaixo as instruções para o Ubuntu Linux com zsh :

1. Abrir janela do terminal ( CTRL+ ALT+ T)
2. Executar comando nano ~/.zshrcpara editar seu perfil
3. Adicione as seguintes linhas no arquivo aberto:

export ANDROID_SDK_HOME="~/Android/Sdk"
alias emulator="$ANDROID_SDK_HOME/emulator/emulator"

4. Salve o arquivo ( CTRL+ O, CTRL+ X)
5. Crie o perfil executando o comando source ~/.zshrc ou simplesmente faça logoff e logon novamente
6. Teste executando o comando emulator -helpno terminal

NOTA : Deve ser o mesmo para bashsubstituir .zshrcpor.bashrc