L'SDK Android include un emulatore di dispositivi Android, ovvero un dispositivo virtuale in esecuzione sul tuo computer. Android Emulator consente di sviluppare e testare app Android senza usare un dispositivo fisico.
In questa pagina vengono descritte le funzionalità a riga di comando che puoi utilizzare con Android Emulator. Per informazioni sull'utilizzo dell'interfaccia utente di Android Emulator, vedi Eseguire app sull'emulatore Android.
Avvia l'emulatore
Utilizza il comando emulator
per avviare l'emulatore, come alternativa all'esecuzione del progetto o all'avvio tramite Gestione AVD.
Di seguito è riportata la sintassi di base della riga di comando per avviare un dispositivo virtuale da un prompt del terminale:
emulator -avd avd_name [ {-option [value]} … ]
Oppure:
emulator @avd_name [ {-option [value]} … ]
Ad esempio, se avvii l'emulatore da Android Studio su un Mac, la riga di comando predefinita sarà simile alla seguente:
/Users/janedoe/Library/Android/sdk/emulator/emulator -avd Pixel8_API_34 -netdelay none -netspeed full -qt-hide-window -grpc-use-token -idle-grpc-timeout
Tieni presente che gli argomenti -qt-hide-window -grpc-use-token -idle-grpc-timeout
vengono utilizzati solo per eseguire la finestra dell'emulatore in Android Studio. Se vuoi eseguire l'emulatore in una finestra separata, non utilizzare questi parametri aggiuntivi.
Puoi specificare le opzioni di avvio all'avvio dell'emulatore, ma non dopo l'avvio.
Per un elenco di nomi di durata di visualizzazione media, inserisci il seguente comando:
emulator -list-avds
Utilizza questa opzione per visualizzare un elenco di nomi di durata di visualizzazione media dalla home directory di Android.
Puoi eseguire l'override della home directory predefinita impostando la variabile di ambiente ANDROID_SDK_HOME
che specifica la radice della directory specifica dell'utente in cui sono archiviati tutti i contenuti della configurazione e dei file di visualizzazione media.
Puoi impostare la variabile di ambiente nella finestra del terminale prima di avviare un dispositivo virtuale o tramite le impostazioni utente nel sistema operativo. Ad esempio, nel tuo file .bashrc
su Linux.
Per arrestare l'emulatore Android, chiudi la finestra dell'emulatore.
Installare un'app
Oltre a installare un'app tramite Android Studio o l'interfaccia utente
dell'emulatore, puoi installarla su un dispositivo virtuale utilizzando l'utilità adb
.
Per utilizzare adb
per installare, eseguire e testare la tua app,
segui questi passaggi generali:
- Crea e pacchettizza la tua app in un APK, come descritto in Creare ed eseguire l'app.
- Avvia l'emulatore dalla riga di comando, come descritto nella sezione precedente, utilizzando le eventuali opzioni di avvio necessarie.
- Installa l'app utilizzando
adb
. - Esegui e testa la tua app sull'emulatore.
Mentre l'emulatore è in esecuzione, puoi utilizzare la console emulatore per emettere comandi secondo necessità.
Per disinstallare un'app, procedi come faresti su un dispositivo Android.
Il dispositivo virtuale conserva l'app e i relativi dati sullo stato durante i riavvii
in una partizione del disco dati utente (userdata-qemu.img
). Per cancellare questi
dati, avvia l'emulatore con l'opzione -wipe-data
o cancella i
dati in Gestione AVD. Per ulteriori informazioni sulla partizione dei dati utente
e su altri tipi di archiviazione, consulta la sezione seguente.
Nota: l'utilità adb
considera il dispositivo virtuale come un vero e proprio dispositivo fisico. Per questo motivo, potresti dover utilizzare il flag -d
con alcuni comandi adb
comuni, come install
. Il flag -d
consente di specificare quale tra vari dispositivi connessi utilizzare come destinazione di un comando. Se non specifichi
-d
, l'emulatore sceglie come target il primo dispositivo dell'elenco.
Informazioni sulle directory e sui file predefiniti
L'emulatore utilizza file associati, di cui il sistema AVD e le directory dei dati sono i più importanti. È utile comprendere la struttura e i file della directory dell'emulatore quando specifichi le opzioni della riga di comando, anche se in genere non è necessario modificare le directory o i file predefiniti.
L'emulatore Android utilizza l'hypervisor (QEMU).
Directory di sistema della durata di visualizzazione media
La directory di sistema contiene le immagini di sistema Android che l'emulatore utilizza per simulare il sistema operativo. Questa directory contiene file di sola lettura specifici della piattaforma condivisi da tutti gli AVD dello stesso tipo, inclusi livello API, architettura della CPU e variante Android. Le località predefinite sono le seguenti:
- macOS e Linux -
~/Library/Android/sdk/system-images/android-apiLevel/variant/arch/
- Windows -
C:\Users\user\Library\Android\sdk\system-images\android-apiLevel\variant\arch\
Dove:
apiLevel
è un livello API numerico o una lettera per le release di anteprima. Ad esempio,android-V
indica l'anteprima di Android VanillaIceCream. Al momento del rilascio, è diventato il livello API 35, designato daandroid-35
.variant
è un nome corrispondente a funzionalità specifiche implementate dall'immagine di sistema. Ad esempio,google_apis
oandroid-wear
.arch
è l'architettura della CPU di destinazione. Ad esempio,x86
.
Utilizza l'opzione -sysdir
per specificare una directory di sistema diversa per la durata di visualizzazione media.
L'emulatore legge i seguenti file dalla directory di sistema:
File | Descrizione | Opzione per specificare un file diverso |
---|---|---|
kernel-qemu o kernel-ranchu
|
L'immagine del kernel binario per la durata di visualizzazione media. kernel-ranchu si basa sull'emulatore
QEMU.
|
-kernel
|
ramdisk.img
|
L'immagine della partizione di avvio. Questo è un sottoinsieme di system.img
caricato dal kernel inizialmente prima del montaggio dell'immagine di sistema. In genere contiene solo alcuni programmi binari e script di inizializzazione.
|
-ramdisk
|
system.img
|
La versione iniziale di sola lettura dell'immagine di sistema. Nello specifico, la partizione contenente le librerie di sistema e i dati corrispondenti al livello API e alla variante. | -system
|
userdata.img
|
La versione iniziale della partizione dati, che viene visualizzata come data/ nel sistema emulato e contiene tutti i dati scrivibili per la durata di visualizzazione media. L'emulatore utilizza questo file quando crei una nuova durata di visualizzazione media o usi l'opzione ‑wipe-data . Per maggiori informazioni, consulta la
descrizione del file userdata-qemu.img nella sezione seguente.
|
-initdata
-init-data
|
Directory dei dati della durata di visualizzazione media
La directory dei dati della durata di visualizzazione media, chiamata anche directory dei contenuti, è specifica di una singola istanza e contiene tutti i dati modificabili per la durata di visualizzazione media.
La posizione predefinita è la seguente, dove name
è il nome della durata di visualizzazione media:
- macOS e Linux -
~/.android/avd/name.avd/
- Windows 10 e versioni successive -
C:\Users\user\.android\name.avd\
Utilizza l'opzione -datadir
per specificare una directory di dati AVD diversa.
La tabella seguente elenca i file più importanti contenuti in questa directory:
File | Descrizione | Opzione per specificare un file diverso |
---|---|---|
userdata-qemu.img
|
Il contenuto della partizione dati, che viene visualizzato come
Ogni istanza di dispositivo virtuale utilizza un'immagine dei dati utente accessibile in scrittura per archiviare i dati specifici dell'utente e della sessione. Ad esempio, utilizza l'immagine per archiviare dati, impostazioni, database e file dell'app installati da un utente unico. Ogni utente ha una
directory |
-data
|
cache.img
|
L'immagine della partizione cache, che viene visualizzata come cache/ nel
sistema emulato. È vuoto quando crei una durata di visualizzazione media o utilizzi
l'opzione -wipe-data . Archivia i file di download temporanei e viene
compilato da Gestione dei download e talvolta dal sistema. Ad esempio, il browser lo utilizza per memorizzare nella cache le pagine web e le immagini scaricate mentre l'emulatore è in esecuzione. Quando spegni il dispositivo virtuale, il file viene eliminato. Puoi mantenere il file in modo permanente utilizzando l'opzione -cache .
|
-cache
|
sdcard.img
|
(Facoltativo) Un'immagine di partizione della scheda SD che consente di simulare una scheda SD su un dispositivo virtuale. Puoi creare un file immagine della scheda SD in Gestione AVD o utilizzando lo strumento
Durante la definizione di una durata di visualizzazione media in Gestione AVD, puoi scegliere di utilizzare un file di scheda SD gestito automaticamente o un file creato con lo strumento
Puoi sfogliare, inviare e copiare e rimuovere file da una scheda SD simulata utilizzando l'interfaccia utente dell'emulatore o l'utilità
Per copiare i file sul file della scheda SD prima di caricarlo, monta il file immagine
come dispositivo loop e copia i file. In alternativa, utilizza un'utilità, come il pacchetto L'emulatore considera il file come un pool di byte, quindi il formato della scheda SD non è importante.
L'opzione |
-sdcard
|
Elenca le directory e i file utilizzati dall'emulatore
Puoi scoprire la posizione dei file in due modi:
- Utilizza l'opzione
-verbose
o-debug init
quando avvii l'emulatore dalla riga di comando. Guarda l'output. - Usa il comando
emulator
-help-option
per elencare una directory predefinita. Ad esempio:emulator -help-datadir
Use '-datadir <dir>' to specify a directory where writable image files will be searched. On this system, the default directory is: /Users/me/.android See '-help-disk-images' for more information about disk image files.
Opzioni di avvio dalla riga di comando
Questa sezione elenca le opzioni che puoi fornire nella riga di comando all'avvio dell'emulatore.
Nota:l'emulatore Android è costantemente in fase di sviluppo per renderlo più affidabile. Per conoscere lo stato dei problemi segnalati rispetto alle varie opzioni della riga di comando e per segnalare i bug, consulta lo strumento Android Issue Tracker.
Opzioni più utilizzate
La seguente tabella elenca le opzioni di avvio dalla riga di comando che potresti utilizzare più spesso:
Opzione della riga di comando | Descrizione |
---|---|
Avvio rapido | |
-no-snapshot-load
|
Esegue un avvio a freddo e salva lo stato dell'emulatore all'uscita. |
-no-snapshot-save
|
Se possibile esegue un avvio rapido, ma non salva lo stato dell'emulatore all'uscita. |
-no-snapshot
|
Disattiva completamente la funzionalità Avvio rapido e non carica o salva lo stato dell'emulatore. |
Hardware del dispositivo | |
-camera-back mode -camera-front mode
|
Consente di impostare la modalità di emulazione per una fotocamera posteriore o anteriore. Questa operazione sostituisce qualsiasi impostazione della videocamera nella durata di visualizzazione media.
Ad esempio: emulator @Pixel8_API_34 -camera-back webcam0 |
-webcam-list
|
Elenca le webcam sul tuo computer di sviluppo che sono disponibili per l'emulazione. Ad
esempio:emulator @Pixel8_API_34 -webcam-list List of web cameras connected to the computer: Camera 'webcam0' is connected to device 'webcam0' on channel 0 using pixel format 'UYVY' Nell'esempio, il primo A partire da SDK Tools 25.2.4, il nome della durata di visualizzazione media è obbligatorio. |
Immagini del disco e memoria | |
-memory size
|
Specifica la dimensione della RAM fisica, da 1536 a 8192 MB. Ecco alcuni esempi: emulator @Pixel8_API_34 -memory 2048 Questo valore sostituisce l'impostazione della durata di visualizzazione media. |
-sdcard filepath
|
Specifica il nome file e il percorso di un file dell'immagine di partizione della scheda SD. Ad
esempio:
emulator @Pixel8_API_34 -sdcard C:/sd/sdcard.img Se il file non viene trovato, viene avviato comunque l'emulatore, ma senza scheda SD. Il comando restituisce un avviso Nessuna immagine scheda SD.
Se non specifichi questa opzione, il valore predefinito è |
-wipe-data
|
Elimina i dati utente e copia i dati dal file di dati iniziale. Questa opzione cancella i dati per il dispositivo virtuale e li restituisce allo stesso stato della prima definizione. Vengono rimosse tutte le app e le impostazioni installate. Ecco alcuni esempi:
emulator @Pixel8_API_34 -wipe-data
Per impostazione predefinita, il file di dati utente è |
Debug | |
-debug tags
|
Attiva o disattiva la visualizzazione dei messaggi di debug per uno o più tag.
Separa più tag con uno spazio, una virgola o una colonna. Ecco alcuni esempi:
$ emulator @Pixel8_API_34 -debug init,metrics Per disattivare un tag, inserisci un trattino (-) davanti al tag. Ad esempio, la seguente opzione mostra tutti i messaggi di debug, ad eccezione di quelli relativi a socket di rete e metriche:
Per un elenco di tag e descrizioni, utilizza l'opzione
emulator -help-debug-tags
Puoi definire i tag di debug predefiniti nella variabile di ambiente
ANDROID_VERBOSE=socket,gles Equivale a utilizzare:
oppure
|
-debug-tag -debug-no-tag
|
Consente di attivare un tipo di messaggio di debug specifico. Utilizza il modulo no per disabilitare un tipo di messaggio di debug. Ecco alcuni esempi:
emulator @Pixel8_API_34 -debug-all -debug-no-metrics
Per un elenco dei tag, usa il comando |
-logcat logtags
|
Abilita la visualizzazione dei messaggi Logcat per uno o più tag e li scrive nella finestra del terminale. Ad esempio, il seguente comando abilita i messaggi di errore di tutti i componenti:
emulator @Pixel8_API_34 -logcat *:e
L'esempio seguente mostra i messaggi del componente GSM a livello di log informativo:
emulator @Pixel8_API_34 -logcat '*:s GSM:i'
Se non fornisci l'opzione Per ulteriori informazioni su Logcat e |
-show-kernel
|
Visualizza i messaggi di debug del kernel nella finestra del terminale. Ecco alcuni esempi:
emulator @Pixel8_API_34 -show-kernel Questa opzione viene utilizzata per verificare che il processo di avvio funzioni correttamente. |
-verbose
|
Stampa i messaggi di inizializzazione dell'emulatore nella finestra del terminale. Ad
esempio:
emulator @Pixel8_API_34 -verbose
Visualizza i file e le impostazioni effettivamente selezionati all'avvio di un dispositivo virtuale definito in una durata di visualizzazione media. Questa opzione equivale a specificare |
Rete | |
-dns-server servers
|
Utilizza i server DNS specificati. servers è un
elenco separato da virgole di massimo quattro nomi di server DNS o indirizzi IP. Ad
esempio:
emulator @Pixel8_API_34 -dns-server 192.0.2.0,
Per impostazione predefinita, l'emulatore tenta di rilevare i server DNS in uso e configura alias speciali nella rete firewall emulata per consentire al sistema Android di connettersi direttamente ai server. Utilizza l'opzione |
-http-proxy proxy
|
Effettua tutte le connessioni TCP attraverso un proxy HTTP/HTTPS specificato. Se l'emulatore deve accedere a internet tramite un server proxy, puoi utilizzare questa opzione o la variabile di ambiente http_proxy per configurare il reindirizzamento appropriato. Ecco alcuni esempi:
emulator @Pixel8_API_34 -http-proxy myserver:1981
Il
prefisso
Se questa opzione non è fornita, l'emulatore cerca la variabile di ambiente |
-netdelay delay
|
Imposta l'emulazione della latenza di rete su uno dei seguenti
valori
Ad esempio: emulator @Pixel8_API_34 -netdelay gsm
L'emulatore supporta la limitazione della rete e latenze di connessione più elevate.
Puoi definirlo tramite la configurazione dell'interfaccia o con le opzioni |
-netfast
|
Disattiva la limitazione della rete. Ecco alcuni esempi:
emulator @Pixel8_API_34 -netfast
Questa opzione equivale a specificare |
-netspeed speed
|
Imposta l'emulazione della velocità di rete. Specifica le velocità massime di caricamento e download della rete con uno dei seguenti valori
Ad esempio: emulator @Pixel8_API_34 -netspeed edge
L'emulatore supporta la limitazione della rete e latenze di connessione più elevate.
Puoi definirlo tramite la configurazione dell'interfaccia o con le opzioni |
-port port
|
Imposta il numero di porta TCP utilizzato per la console e adb . Ecco alcuni esempi:
emulator @Pixel8_API_34 -port 5556
Il valore predefinito è 5554 per la prima istanza di dispositivo virtuale in esecuzione sulla tua macchina. Di solito un dispositivo virtuale occupa una coppia di porte adiacenti: una porta della console e una porta
Le assegnazioni delle porte equivalgono spesso a specificare L'opzione
Tieni presente che se il valore |
-ports
|
Imposta le porte TCP utilizzate per la console e adb . Ecco alcuni esempi:
emulator @Pixel8_API_34 -ports 5556,5559
L'intervallo di porte valide è compreso tra 5554 e 5682, consentendo l'inserimento di 64 dispositivi virtuali in contemporanea. L'opzione
Ti consigliamo di utilizzare l'opzione
Per maggiori informazioni sulla configurazione delle porte della console e |
-tcpdump filepath
|
Acquisisce i pacchetti di rete e li archivia in un file. Ecco alcuni esempi:
emulator @Pixel8_API_34 -tcpdump /path/dumpfile.cap Utilizza questa opzione per iniziare ad acquisire tutti i pacchetti di rete inviati tramite la LAN Ethernet virtuale dell'emulatore. In seguito, potrai utilizzare uno strumento come Wireshark per analizzare il traffico. Tieni presente che questa opzione acquisisce tutti i pacchetti Ethernet e non è limitata alle connessioni TCP. |
Sistema | |
-accel mode
|
Configura l'accelerazione della VM dell'emulatore. Ecco alcuni esempi:
emulator @Pixel8_API_34 -accel auto L'emulazione accelerata funziona solo per le immagini di sistema x86 e x86_64. Su Linux, si basa su KVM. Su Windows e Mac, si basa su una CPU Intel e un driver Intel HAXM. Questa opzione viene ignorata se non devi emulare un dispositivo x86 o x86_64.
I valori validi per
Per maggiori informazioni, vedi Configurare l'accelerazione hardware per l'emulatore Android. |
-accel-check
|
Controlla se è installato un hypervisor richiesto per l'accelerazione VM dell'emulatore (HAXM o KVM). Ecco alcuni esempi:
emulator -accel-check Per ulteriori informazioni, vedi Controllare se è installato un hypervisor. |
-engine engine
|
Specifica il motore dell'emulatore:
Ecco alcuni esempi:
emulator @Pixel8_API_34 -engine auto
Il rilevamento automatico deve scegliere il valore che offre le migliori prestazioni durante l'emulazione di una determinata durata di visualizzazione media. Utilizza l'opzione |
-gpu mode
|
Seleziona la modalità di emulazione GPU. Ecco alcuni esempi:
emulator @Pixel8_API_34 -gpu swiftshader_indirect Per ulteriori informazioni, vedi Configurare l'accelerazione grafica. |
-no-accel
|
Disabilita l'accelerazione della VM dell'emulatore quando viene utilizzata un'immagine di sistema x86 o x86_64. È utile solo per il debug ed equivale a specificare -accel
off . Ecco alcuni esempi:
emulator @Pixel8_API_34 -no-accel Per maggiori informazioni, vedi Configurare l'accelerazione hardware per l'emulatore Android. |
-nojni
-no-jni
|
Disattiva i controlli JNI (Java Native Interface) estesi nel runtime Android Dalvik
o ART. Ecco alcuni esempi:
emulator @Pixel8_API_34 -nojni Quando avvii un dispositivo virtuale, i controlli JNI estesi sono abilitati per impostazione predefinita. Per ulteriori informazioni, vedi i suggerimenti di JNI. |
-selinux {disabled|permissive}
|
Imposta il modulo di sicurezza Security-Enhanced Linux (SELinux)
sulla modalità disabled o permissive su un sistema operativo
Linux. Ecco alcuni esempi:
me-linux$ emulator @Pixel8_API_34 -selinux permissive
Per impostazione predefinita, SELinux è in modalità |
-timezone timezone
|
Imposta il fuso orario del dispositivo virtuale su emulator @Pixel8_API_34 -timezone Europe/Paris
Per impostazione predefinita, l'emulatore utilizza il fuso orario del tuo computer di sviluppo. Utilizza questa opzione per specificare un fuso orario diverso o se il rilevamento automatico non funziona correttamente. Il valore
Il fuso orario specificato deve trovarsi nel databasezoneinfo. |
-version
|
Mostra il numero di versione dell'emulatore. Ecco alcuni esempi:
emulator @Pixel8_API_34 -version Oppure:
emulator -version |
Interfaccia utente | |
-no-boot-anim
|
Disattiva l'animazione all'avvio durante l'avvio dell'emulatore per un avvio più rapido.
Ecco alcuni esempi:
emulator @Pixel8_API_34 -no-boot-anim Sui computer più lenti, questa opzione può accelerare notevolmente la sequenza di avvio. |
-screen mode
|
Consente di impostare la modalità touchscreen emulato. Ecco alcuni esempi:
emulator @Pixel8_API_34 -screen no-touch
|
Opzioni avanzate
Le opzioni di avvio dalla riga di comando nella seguente tabella sono disponibili, ma non sono comunemente utilizzate dallo sviluppatore di app medio.
Nelle descrizioni, la directory di lavoro è la directory attuale nel terminale in cui inserisci i comandi. Per informazioni sulla directory di sistema e sulla directory dei dati AVD, nonché sui file archiviati al loro interno, consulta la sezione relativa a directory e file predefiniti.
Alcune di queste opzioni sono appropriate per sviluppatori di app esterni e altre vengono utilizzate principalmente da sviluppatori di piattaforme. Gli sviluppatori di app creano app Android e le eseguono su durata di visualizzazione media specifica. Gli sviluppatori di piattaforme lavorano sul sistema Android e lo eseguono all'interno dell'emulatore senza durata di visualizzazione media creata in precedenza.
Opzione avanzata | Breve descrizione |
---|---|
-bootchart timeout
|
Abilita il bootcharting con un timeout in secondi. Alcune immagini di sistema Android hanno un sistema di inizializzazione modificato che integra una funzionalità di bootcharting. Puoi passare al sistema un periodo di timeout di bootcharting con questa opzione. Se nel sistema di inizializzazione non è attivato bootcharting, l'opzione non ha effetto. Questa opzione è utile principalmente per gli sviluppatori di piattaforme, non per gli sviluppatori di app esterni. Ecco alcuni esempi: emulator @Pixel8_API_34 -bootchart 120 |
-cache filepath
|
Specifica un file immagine della partizione della cache. Fornisce un nome file e un percorso assoluto o un percorso relativo alla directory dei dati per configurare un file della cache permanente. Se il file non esiste, l'emulatore lo crea come file vuoto. Ecco alcuni esempi: emulator @Pixel8_API_34 -cache ~/.android/avd/Pixel8_API_34.avd/cache_persistent.img Se non utilizzi questa opzione, il valore predefinito è un file temporaneo denominato
|
-cache-size size
|
Imposta la dimensione della partizione cache in MB. Ecco alcuni esempi: emulator @Pixel8_API_34 -cache-size 1000 Se non specifichi questa opzione, il valore predefinito è 66 MB. Normalmente, la maggior parte degli sviluppatori di app non ha bisogno di questa opzione, a meno che non sia necessario scaricare file molto grandi che superano la cache predefinita. Per ulteriori informazioni sul file della cache, vedi Directory dei dati AVD. |
-data filepath
|
Imposta il file immagine della partizione dei dati utente. Fornisce un nome file e un percorso assoluto o un percorso relativo alla directory di lavoro per configurare un file di dati utente permanente. Se il file non esiste, l'emulatore crea un'immagine dal file Ecco alcuni esempi: emulator @Pixel8_API_34 -data ~/.android/avd/Pixel8_API_34.avd/userdata-test.img Se non utilizzi questa opzione, il valore predefinito è un file denominato |
-datadir dir
|
Specifica una directory di dati utilizzando un percorso assoluto. Per maggiori informazioni, consulta la directory dei dati relativi alla durata di visualizzazione media. Ecco alcuni esempi: emulator @Pixel8_API_34 -datadir ~/.android/avd/Pixel8_API_34.avd/mytest |
-force-32bit
|
Utilizza l'emulatore a 32 bit su piattaforme a 64 bit. A volte, questa opzione è utile per i test o il debug. Ad esempio, c'è stato un problema per cui l'emulatore a volte non funzionava su Windows a 64 bit, ma a 32 bit. Questa opzione è stata utile per eseguire confronti al fine di eseguire il debug del problema. Ecco un esempio: emulator @Pixel8_API_34 -force-32bit |
-help-disk-images
|
Ricevi assistenza per le immagini disco. Questa opzione fornisce informazioni pertinenti per gli sviluppatori di app e piattaforme. Ecco alcuni esempi: emulator -help-disk-images |
-help-char-devices
|
Riceve assistenza sulle specifiche del carattere emulator -help-char-devices |
-help-sdk-images
|
Ricevi assistenza sulle immagini disco pertinenti per gli sviluppatori di app. Questa opzione ottiene informazioni sulla posizione dei file immagine per una durata di visualizzazione media creata con gli strumenti SDK. Ecco alcuni esempi: emulator -help-sdk-images |
-help-build-images
|
Ricevi assistenza sulle immagini disco pertinenti per gli sviluppatori della piattaforma. Ecco alcuni esempi: emulator -help-build-images |
-initdata filepath -init-data
filepath
|
Specifica la versione iniziale della partizione dati. Dopo aver cancellato
i dati utente, l'emulatore copia i contenuti del file specificato nei dati
utente (per impostazione predefinita, il file Ecco alcuni esempi: emulator @Pixel8_API_34 -initdata ~/Library/Android/sdk/system-images/android-34/ google_apis/x86_64/userdata-test.img Se non specifichi un percorso, il file viene inserito nella directory di sistema. Per ulteriori informazioni, consulta la directory di sistema della durata di visualizzazione media. |
-kernel filepath
|
Utilizza un kernel emulato specifico. Se non specifichi un percorso, l'emulatore viene visualizzato nella directory di sistema. Utilizza l'opzione‑show‑kernel per visualizzare i messaggi di debug del kernel.
Ecco alcuni esempi: emulator @Pixel8_API_34 -kernel ~/Library/Android/sdk/system-images/android-34/ google_apis/x86_64/kernel-test.img -show-kernel Se non specifichi questa opzione, il valore predefinito è |
-noaudio
-no-audio
|
Disattiva il supporto audio per questo dispositivo virtuale. Alcuni computer Linux e Windows hanno driver audio difettosi che causano diversi sintomi, ad esempio impediscono l'avvio dell'emulatore. In questo caso, utilizza questa opzione
per risolvere il problema. In alternativa, puoi utilizzare la variabile di ambiente Ecco alcuni esempi: emulator @Pixel8_API_34 -noaudio |
-nocache
-no-cache
|
Avvia l'emulatore senza una partizione cache. Se non utilizzi questa opzione, il valore predefinito è un file temporaneo denominato Ecco alcuni esempi: emulator @Pixel8_API_34 -nocache |
-no-snapshot
|
Inibisce sia le operazioni di caricamento automatico che di salvataggio, facendo sì che l'emulatore esegua una sequenza di avvio completa e perda lo stato alla chiusura. Sostituisce
l'opzione Ecco alcuni esempi: emulator @Pixel8_API_34 -no-snapshot |
-no-snapshot-load
|
Impedisce all'emulatore di caricare lo stato della durata di visualizzazione media dall'archiviazione degli snapshot. Esegue un avvio completo. Ecco alcuni esempi: emulator @Pixel8_API_34 -no-snapshot-load |
-no-snapshot-save
|
Impedisce all'emulatore di salvare lo stato della durata di visualizzazione media nello spazio di archiviazione degli snapshot all'uscita. In questo modo, tutte le modifiche andranno perse. Ecco alcuni esempi: emulator @Pixel8_API_34 -no-snapshot-save |
-no-snapshot-update-time
|
Non tenta di correggere subito l'ora di tempo di visualizzazione media al ripristino dello snapshot. Questa opzione può essere utile durante il test, in quanto evita un salto temporale improvviso. Gli aggiornamenti temporali vengono comunque inviati alla durata di visualizzazione media ogni 15 secondi circa. Ecco alcuni esempi: emulator @Pixel8_API_34 -no-snapshot-update-time |
-no-snapstorage
|
Avvia l'emulatore senza montare un file per archiviare o caricare snapshot dello stato, forzando un avvio completo e disattivando la funzionalità di snapshot dello stato. Questa opzione sostituisce le opzioni Ecco alcuni esempi: emulator @Pixel8_API_34 -no-snapstorage |
-no-window
|
Disattiva la visualizzazione della finestra grafica sull'emulatore. Questa opzione è utile quando viene eseguito l'emulatore su server senza display. Puoi accedere all'emulatore tramite emulator @Pixel8_API_34 -no-window |
-partition-size size
|
Specifica la dimensione della partizione dei dati di sistema in MB. Ecco alcuni esempi: emulator @Pixel8_API_34 -partition-size 1024 |
-prop name=value
|
Imposta una proprietà di sistema Android nell'emulatore all'avvio.
emulator @Pixel8_API_34 -prop qemu.name=value -prop qemu.abc=xyz |
-qemu args
|
Passa argomenti al software dell'emulatore QEMU. Quando utilizzi questa opzione, assicurati che sia l'ultima specificata, poiché tutte le opzioni successive sono interpretate come opzioni specifiche della QEMU. Questa opzione è piuttosto avanzata e dovrebbe essere utilizzata solo da sviluppatori che hanno molto familiarità con QEMU e con l'emulazione Android. |
-qemu -h
|
Mostra la guida di emulator -qemu -h |
-ramdisk filepath
|
Specifica un'immagine di avvio ramdisk. Specifica il nome file e un percorso assoluto o un percorso relativo alla directory di lavoro. Ecco alcuni esempi: emulator @Pixel8_API_34 -ramdisk ~/Library/Android/sdk/system-images/android-34/ google_apis/x86_64/ramdisk-test.img Se non utilizzi questa opzione, il valore predefinito è il file |
-report-console socket
|
Segnala la porta della console a una terza parte remota prima di avviare l'emulazione. Può essere utile per uno script per il test automatizzato.
Per ulteriori informazioni, utilizza l'opzione |
-shell
|
Crea una console shell root sul terminale attuale. Questa opzione differisce dal comando
Ecco alcuni esempi: emulator @Pixel8_API_34 -shell |
-snapshot name
|
Specifica il nome di uno snapshot all'interno di un file di archiviazione snapshot per le operazioni di avvio e salvataggio automatici. Anziché eseguire una sequenza di avvio completa, l'emulatore può riprendere l'esecuzione da uno snapshot dello stato precedente, che in genere è molto più veloce. Quando fornisci questa opzione, l'emulatore carica lo snapshot con quel nome dall'immagine dello snapshot e lo salva di nuovo con lo stesso nome all'uscita. Se non utilizzi questa opzione, l'impostazione predefinita è una sequenza di avvio completa. Se lo snapshot specificato non esiste, l'emulatore esegue una sequenza di avvio completa e un'operazione di salvataggio. Vedi l'opzione emulator @Pixel8_API_34 -snapshot snapshot2 Ricorda che, durante il caricamento di uno snapshot, tutti i contenuti del sistema, i dati utente e le immagini della scheda SD vengono sovrascritti con i contenuti conservati al momento della creazione dello snapshot. Se non salvi queste informazioni in uno snapshot diverso, tutte le modifiche apportate successivamente andranno perse. Puoi anche creare uno snapshot dalla console dell'emulatore utilizzando il comando |
-snapshot-list
|
Visualizza un elenco di snapshot disponibili. Questo comando stampa una tabella di snapshot archiviati nel file di archiviazione degli snapshot con cui è stato avviato l'emulatore, quindi viene chiuso. Se specifichi anche Ecco alcuni esempi: emulator @Pixel8_API_34 -snapshot-list -snapstorage ~/.android/avd/Pixel8_API_34.avd/snapshots-test.img Puoi utilizzare i valori delle colonne ID e TAG nell'output come argomenti per l'opzione |
-snapstorage filepath
|
Specifica un file di repository che contiene tutti gli snapshot dello stato. Tutti gli snapshot creati durante l'esecuzione vengono salvati in questo file. Durante l'esecuzione dell'emulatore puoi ripristinare solo gli snapshot in questo file. Ecco alcuni esempi: emulator @Pixel8_API_34 -snapstorage ~/.android/avd/Pixel8_API_34.avd/snapshots-test.img Se non specifichi questa opzione, il valore predefinito è |
-sysdir dir
|
Specifica una directory di sistema utilizzando un percorso assoluto. Per ulteriori informazioni, consulta la directory di sistema della durata di visualizzazione media. Ecco alcuni esempi: emulator @Pixel8_API_34 -sysdir ~/Library/Android/sdk/system-images/android-34/ google_apis/x86_64/test |
-system filepath
|
Specifica un file di sistema iniziale. Fornisce il nome file e un percorso assoluto o un percorso relativo alla directory di lavoro. Ecco alcuni esempi: emulator @Pixel8_API_34 -system ~/Library/Android/sdk/system-images/android-34/ google_apis/x86_64/system-test.img Se non utilizzi questa opzione, il valore predefinito è il file |
-use-system-libs
|
Su Linux, viene utilizzato il sistema Ecco alcuni esempi: me-linux$ emulator @Pixel8_API_34 -use-system-libs |
-writable-system
|
Utilizza questa opzione per avere un'immagine di sistema scrivibile durante la sessione di emulazione. Per farlo:
L'utilizzo di questo flag crea una copia temporanea dell'immagine di sistema che può essere molto grande, fino a diverse centinaia di MB, ma verrà eliminata alla chiusura dell'emulatore. |
Opzioni deprecate
Le seguenti opzioni della riga di comando sono deprecate:
-audio-in
-audio-out
-charmap
-code-profile
-cpu-delay
-dpi-device
-dynamic_skin
-enable-kvm
-gps
-image
-keyset
-help-keys
-help-keyset-file
-nand-limits
-noskin
-no-skin
-onion
-onion-alpha
-onion-rotation
-radio
-ranchu
-raw-keys
-scale
-shared-net-id
-shell-serial
-skin
-skindir
-trace
-useaudio
Assistenza per le opzioni della riga di comando
Questa sezione descrive come richiedere assistenza in merito alle opzioni della riga di comando. Fornisce informazioni più approfondite sulle opzioni a riga di comando dell'emulatore di uso comune, disponibili all'avvio dell'emulatore.
Elenca tutte le opzioni dell'emulatore
Per stampare un elenco di tutte le opzioni dell'emulatore, inclusa una breve descrizione, inserisci il seguente comando:
emulator -help
Ricevere assistenza dettagliata per un'opzione specifica
Per stampare la guida per un'opzione di avvio specifica, inserisci il seguente comando:
emulator -help-option
Ecco alcuni esempi:
emulator -help-netspeed
Questa guida è più dettagliata rispetto alla descrizione fornita dall'opzione -help
.
Assistenza dettagliata per tutte le opzioni
Per ricevere una guida dettagliata per tutte le opzioni dell'emulatore, inserisci il seguente comando:
emulator -help-all
Elenca le variabili di ambiente dell'emulatore
Per ottenere un elenco delle variabili di ambiente dell'emulatore, inserisci questo comando:
emulator -help-environment
Puoi impostare le variabili di ambiente nella finestra del terminale prima di avviare un dispositivo virtuale oppure tramite le impostazioni utente nel sistema operativo. Ad esempio, impostala nel file .bashrc
su Linux.
Elenca tag di debug
Per stampare un elenco di tag per le opzioni -debug
, inserisci il seguente comando:
emulator -help-debug-tags
Le opzioni -debug
consentono di attivare o disattivare i messaggi di debug da
componenti dell'emulatore specifici, come specificato dai tag.