Sono su Mac, sto lavorando allo sviluppo Android dal terminale. Ho creato con successo il progetto HelloWorld e ora sto provando a eseguirlo dalla riga di comando nell'emulatore Android. Quale comando esegue l'emulatore per il mio progetto HelloWorld?

Ho già gli strumenti Android e gli strumenti della piattaforma nel mio PERCORSO.

Modificare:

Come faccio a dire all'emulatore di eseguire il mio progetto HelloWorld dalla riga di comando? Ho già costruito il progetto con la formica.

Presumo che tu abbia costruito il tuo progetto e che tu debba solo avviarlo, ma non hai creato alcun AVD e devi usare la riga di comando per tutte le azioni. Devi fare quanto segue.

1. Crea un nuovo dispositivo virtuale (AVD) per la piattaforma di cui hai bisogno. Se devi utilizzare la riga di comando per creare il tuo AVD, puoi chiamare android create avd -n <name> -t <targetID>dove targetID è il livello API di cui hai bisogno. Se puoi usare la GUI, basta digitare android avde avvierà il gestore, dove puoi fare lo stesso. Puoi leggere ulteriori informazioni sulla gestione di AVD tramite la GUI e la riga di comando .
2. Eseguire l'AVD utilizzando il comando emulator -avd <name>o tramite la GUI precedentemente lanciata. Attendere che l'emulatore si carichi completamente, ci vuole del tempo. Puoi leggere ulteriori opzioni qui .
3. Ora devi installare l'applicazione sul tuo AVD. Di solito durante lo sviluppo usi semplicemente lo stesso script Ant che hai usato per costruire il progetto, basta selezionare installtarget. Tuttavia, è possibile installare l'applicazione manualmente usando il comando adb install <path-to-your-APK>.
4. Ora passa all'emulatore e avvia l'applicazione come su qualsiasi dispositivo normale, tramite il programma di avvio. Oppure, in alternativa, è possibile utilizzare il seguente comando: adb shell am start -a android.intent.action.MAIN -n <package>/<activity class>. Ad esempio: adb shell am start -a android.intent.action.MAIN -n org.sample.helloworld/org.sample.helloworld.HelloWorld. Come ha suggerito un commentatore, puoi anche sostituire org.sample.helloworld.HelloWorldla riga sopra con just .HelloWorlde funzionerà anche.

Elenca tutti i tuoi emulatori:

emulator -list-avds

Esegui uno degli emulatori elencati con -avdflag:

emulator -avd @name-of-your-emulator

dove emulatorè sotto:

${ANDROID_SDK}/tools/emulator

Penso che il modo migliore per raggiungerlo tramite il terminale sia:

cd ~/Library/Android/sdk/tools

Per eseguire direttamente un determinato AVD:

./emulator -avd {AVD_NAME}

Per elencare i tuoi AVD usa:

./emulator -list-avds

Solo per aggiungere qui, ogni volta che si ottiene "errore: dispositivo offline" significa che la connessione con l'emulatore e il ponte adb è stata interrotta a causa del tempo impiegato all'avvio dell'emulatore.

Invece di riavviare l'emulatore a questo punto, prova di seguito due comandi che si arrestano e riavvia il bridge adb.

kill-server adb

adb start-server

Qui puoi controllare le opzioni per eseguire questo comando dalla riga di comando:

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

Ad esempio, lo uso in questo modo di seguito:

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

aprire CMD

1. Apri il prompt dei comandi
2. digitare il percorso dell'emulatore nel mio caso

C: \ ADT-fascio-windows-x86_64-20140702 \ SDK \ tools

3. scrivere "emulatore -avd emulatorname" nel mio caso

emulatore -avd AdilVD

Se si sta provando rigorosamente a eseguire l'emulatore dalla riga di comando, provare questo in OSX.

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

È possibile semplificarlo aggiungendo un alias al .bash_profile e inviandolo a un processo in background.

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

Fai sapere a Bash le modifiche.

source ~/.bash_profile

Apri il prompt dei comandi e vai a <android-Home>\sdk\tools>emulator -avd <AVD_NAME>

Ecco "emulator"il comando utilizzato per aprire il tuo dispositivo virtuale Android .

Se hai Git Bash puoi aprire l'emulatore con un doppio clic, con alcune impostazioni iniziali (testato solo su Windows 10) :

1. Apri Git Bash.
2. Correre cd ~/AppData/Local/Android/sdk/emulator
3. Esegui ./emulator -list-avdse prendi nota del nome dell'emulatore. MY_EMULATORper esempio.

4. Apri Blocco note e aggiungi queste due righe (inserisci il nome dell'emulatore anziché MY_EMULATOR):

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

5. Salvare il file da qualche parte come myfile. sh . Puoi cambiare "myfile" come preferisci, ma è necessaria l'estensione .sh .

6. Apri Git Bash nella directory in cui hai archiviato myfile.sh ed eseguilochmod +x myfile.sh . Ricorda di inserire il nome del file anziché myfile .

E questo è tutto! Da ora in poi, ogni volta che devi avviare quell'emulatore , individua myfile.sh e fai doppio clic su di esso e attendi l'avvio dell'emulatore Android!

(Linux) Nel terminale Copia e incolla e modificando i tre campi in blu

/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)

puoi visualizzare gli emulatori nella cartella home cd /home/Youuser/.android/avd/

Il android create avdcomando è obsoleto. Si consiglia ora di utilizzare avdmanagerinvece per avviare gli emulatori dalla riga di comando.

Innanzitutto, crea un nuovo emulatore se non ne esiste già uno:

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

Ciò presuppone che tu abbia già installato un'immagine di sistema X86 che corrisponde all'API 26 e che abbia installato le API di Google.

È quindi possibile avviare l'emulatore con emulator @MyEmulator.

Oggi supponendo che nel mio caso sia installato Android Studio (2.2) e solo 1 emulatore, potresti usare questo solo rivestimento

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

Se lo fai spesso, rendi più semplice:

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

Aggiungi un alias a ~.aliases

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

Richiama source ~/.profile ~/.aliasesprima di testarlo

La prossima volta solo $ androidup

elenco di nome avd disponibile su

.android / AVD

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

In Windows, utilizzo questo script di PowerShell per avviarlo.

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

1. Apri CMD
2. Per ottenere tutto l'elenco dell'emulatore (C: \ Users \ DJango \ AppData \ Local \ Android \ sdk \ emulator> emulator -list-avds)
3. Scegli qualsiasi emulatore (C: \ Users \ DJango \ AppData \ Local \ Android \ sdk \ emulator> emulator -avd Pixel_2_API_28)

Su Mac (e Linux credo), dopo aver creato il tuo AVD, puoi creare un alias: alias run-android='~/Library/Android/sdk/tools/emulator -avd ${YOUR_AVD_NAME} &'

Nota : l'esecuzione dell'alias non bloccherà il tuo terminale, se lo desideri, rimuovi solo l'ultimo '&' .

Esegui da emulatorsolo ti darà un errore perché si aspetta che, nella tua posizione attuale, tu abbia: /emulator/qemu/${YOUR_PATFORM}/qemu-system-x86_64'avviare l'emulatore.

Ho scritto questo semplice script di shell usando Zenity che ti consente di scegliere quale avd vuoi eseguire. Se non hai definito ANDROID_HOME, puoi semplicemente sostituirlo con il percorso completo dell'emulatore. Questo sarebbe facile da fare anche con select anziché Zenity, ma ho optato per Zenity poiché lo sto eseguendo dal menu dell'applicazione xfce (anche se un file .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

Esegui il primo emulatore disponibile:

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

Sono in ritardo, qui, ma voglio condividere così potrebbe essere d'aiuto a qualcuno e anche a me quando mai necessario in seguito :), Quindi di seguito è il modo di aprire l'emulatore dalla riga di comando con un comando usando bash script. Sto usando MX Linux ma il processo è lo stesso su tutti i sistemi operativi

1- Prima controlla gli emulatori installati

emulator -list-avds

risulterà come di seguito

emulator -list-avds
Nexus_4_API_28
Pixel_2_API_28

2- apri qualsiasi editor di testo o codice e crea un nuovo file e scrivi come di seguito

#!/bin/sh
emulator -avd Nexus_4_API_28

Nexus_4_API_28 è l'emulatore che voglio aprire scrivendo il tuo che hai ottenuto dal primo passo

salva questo file con estensione .sh

3- Quindi, modificare le autorizzazioni sul file per renderlo eseguibile:

chmod u+x emu.sh

4- Ora apri l'emulatore eseguendo questo file di script bash con il seguente comando

./emu.sh

Avvio dell'emulatore dalla riga di comando con l'aiuto di dns

Posizione del programma dell'emulatore: / Users / {{UserName}} / Library / Android / sdk / tools

1. Controlla avd esistente: - emulator -list-avds

2. Avvia emulatore con dns set / Users / {{UserName}} / Library / Android / sdk / tools / emulator -avd Pixel_API_26 -dns-server 8.8.8.8

Vedi sotto le istruzioni per Ubuntu Linux con zsh :

1. Apri finestra terminale ( CTRL+ ALT+ T)
2. Esegui il comando nano ~/.zshrcper modificare il tuo profilo
3. Aggiungi le seguenti righe nel file aperto:

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

4. Salva il file ( CTRL+ O, CTRL+ X)
5. Sorgere il profilo eseguendo il comando source ~/.zshrc o semplicemente disconnettersi e riconnettersi
6. Test eseguendo il comando emulator -helpnel terminale

NOTA : dovrebbe essere lo stesso bashsostituendolo .zshrccon.bashrc