Per vedere l'aspetto e il comportamento della tua app su un dispositivo, devi compilarla ed eseguirla. Android Studio configura nuovi progetti in modo da poter eseguire il deployment dell'app su un dispositivo virtuale o fisico con pochi clic.
Questa panoramica si concentra su come utilizzare Android Studio per compilare ed eseguire l'app per testing e debug. Per informazioni su come utilizzare Android Studio per compilare la tua app in modo che possa essere rilasciata agli utenti, consulta Creare l'app per il rilascio agli utenti. Per informazioni più dettagliate su come gestire e personalizzare la build con o senza Android Studio, consulta Configurare la build.
Creazione ed esecuzione di base
Per compilare ed eseguire l'app, segui questi passaggi:
- Nella barra degli strumenti, seleziona la tua app dal menu delle configurazioni di esecuzione.
Nel menu del dispositivo di destinazione, seleziona il dispositivo su cui vuoi eseguire l'app.
Se non hai configurato alcun dispositivo, devi creare un dispositivo virtuale Android per utilizzare Android Emulator o collegare un dispositivo fisico.
Fai clic su Esegui
.
Android Studio ti avvisa se provi a lanciare il progetto su un dispositivo con un errore o un avviso associato. Le modifiche iconografiche e stilistiche consentono di distinguere tra errori (selezioni di dispositivi che comportano una configurazione non funzionante) e avvisi (selezioni di dispositivi che potrebbero comportare un comportamento imprevisto, ma che possono comunque essere eseguite).
Monitora il processo di compilazione
Per visualizzare i dettagli sulla procedura di compilazione, seleziona Visualizza > Finestre strumenti > Compila o fai clic su Compila
nella barra della finestra degli strumenti. La finestra dello strumento Build visualizza le attività eseguite da Gradle per compilare l'app, come mostrato nella figura 1.
- Scheda Sincronizza:mostra le attività eseguite da Gradle per eseguire la sincronizzazione con i file del progetto. Come per la scheda Output di compilazione, se riscontri un errore di sincronizzazione, seleziona gli elementi nell'albero per visualizzare ulteriori informazioni sull'errore. Viene visualizzato anche un riepilogo dell'impatto del download per determinare se i download delle dipendenze stanno influenzando negativamente la compilazione.
- Scheda Output build:mostra le attività che Gradle esegue come albero,
dove ogni nodo rappresenta una fase di compilazione o un gruppo
di dipendenze delle attività. Se ricevi errori di compilazione o di build, esamina l'albero e seleziona un elemento per leggere l'output dell'errore, come mostrato nella figura 2.
Figura 2. Controlla la scheda Output build per verificare la presenza di messaggi di errore. - Scheda Strumento di analisi delle build:fornisce informazioni sull'analisi del rendimento della build. Per ulteriori informazioni, consulta Risolvere i problemi relativi alle prestazioni di compilazione con Build Analyzer.
- Riavvia:esegue di nuovo l'ultima azione di compilazione. Se l'ultima volta che hai eseguito Compila > Crea modulo selezionato è stato creato il modulo corrente. Se la ultima volta che hai eseguito Build > Crea progetto sono stati generati file di compilazione intermedi per tutti i moduli del progetto.
- Filtri:filtra gli avvisi, le attività o entrambi che sono stati completati correttamente. In questo modo, è più facile trovare i problemi nell'output.
Se le varianti di build utilizzano i sapori del prodotto, Gradle invoca anche le attività per compilare questi sapori del prodotto. Per visualizzare l'elenco di tutte le attività di compilazione disponibili,
fai clic su Visualizza > Finestre degli strumenti > Gradle o su Gradle
nella barra della finestra degli strumenti.
Se si verifica un errore durante il processo di compilazione, Gradle potrebbe consigliare opzioni di riga di comando per aiutarti a risolvere il problema, ad esempio --stacktrace o --debug. Per utilizzare le opzioni a riga di comando con il processo di compilazione:
- Apri la finestra di dialogo Impostazioni o Preferenze:
- Su Windows o Linux, seleziona File > Impostazioni dalla barra dei menu.
- Su macOS, seleziona Android Studio > Preferenze dalla barra dei menu.
- Vai a Compilazione, esecuzione, implementazione > Compilatore.
- Nel campo di testo accanto a Opzioni riga di comando, inserisci le opzioni della riga di comando.
- Fai clic su OK per salvare ed uscire.
Gradle applica queste opzioni a riga di comando la prossima volta che provi a compilare la tua app.
Funzionalità di compilazione ed esecuzione avanzate
Il modo predefinito per compilare ed eseguire l'app in Android Studio dovrebbe essere sufficiente per testare un'app semplice. Tuttavia, puoi utilizzare queste funzionalità di compilazione ed esecuzione per casi d'uso più avanzati:
Per eseguire il deployment dell'app in modalità di debug, fai clic su Debug
.
L'esecuzione dell'app in modalità di debug ti consente di impostare breakpoint nel codice, esaminare le variabili e valutare le espressioni in fase di esecuzione ed eseguire gli strumenti di debug. Per scoprire di più, vedi Eseguire il debug dell'app.Se hai un'app più grande e complessa, utilizza Applica modifiche anziché fare clic su Esegui
. In questo modo risparmi tempo, perché eviti di riavviare
la tua app ogni volta che vuoi implementare una modifica. Per ulteriori informazioni su Applica modifiche, consulta la sezione Eseguire il deployment in modo incrementale con Applica modifiche.Se utilizzi Jetpack Compose, la funzionalità di modifica in tempo reale è una funzionalità sperimentale che consente di aggiornare i composabili in tempo reale senza fare nuovamente clic su Esegui
.
In questo modo, puoi concentrarti sulla scrittura del codice dell'interfaccia utente con interruzioni minime. Per ulteriori informazioni, consulta la sezione Modifica in tempo reale (sperimentale).Se hai un'app con più versioni o varianti di build, puoi scegliere la variante di build da eseguire il deployment utilizzando la finestra dello strumento Varianti di build. Per ulteriori informazioni sull'esecuzione di una variante di build specifica, consulta la sezione Modificare la variante di build.
Per perfezionare le opzioni di installazione, lancio e test delle app, puoi modificare la configurazione di esecuzione/debug. Per ulteriori informazioni sulla creazione di configurazioni di esecuzione/debug personalizzate, consulta la sezione Creare configurazioni di esecuzione/debug.
Ti consigliamo di utilizzare Android Studio per le tue esigenze di sviluppo, ma puoi anche eseguire il deployment dell'app su un dispositivo virtuale o fisico dalla riga di comando. Per ulteriori informazioni, vedi Creare l'app dalla riga di comando.
Esegui il deployment in modo incrementale con Applica modifiche
In Android Studio 3.5 e versioni successive, Applica modifiche ti consente di inviare modifiche al codice e alle risorse all'app in esecuzione senza riavviarla e, in alcuni casi, senza riavviare l'attività corrente. Questa flessibilità ti consente di controllare la quantità di app che viene riavviata quando vuoi implementare e testare piccole modifiche incrementali, preservando al contempo lo stato corrente del dispositivo.
Applica modifiche utilizza le funzionalità nell'implementazione JVMTI di Android supportate sui dispositivi con Android 8.0 (livello API 26) o versioni successive. Per scoprire di più su come funziona Applica modifiche, consulta Project Marble di Android Studio: Applica modifiche.
Requisiti
Le azioni Applica modifiche sono disponibili solo se soddisfi le seguenti condizioni:
- Compili l'APK della tua app utilizzando una variante di build di debug.
- Esegui il deployment dell'app su un dispositivo o un emulatore di destinazione che esegue Android 8.0 (livello API 26) o versioni successive.
Utilizzare Applica modifiche
Utilizza le seguenti opzioni quando vuoi eseguire il deployment delle modifiche su un dispositivo compatibile:
Applica modifiche e riavvia attività 
: tenta di applicare sia le modifiche alle risorse sia quelle al codice riavviando l'attività, ma senza riavviare l'app. In genere, puoi utilizzare questa opzione quando hai modificato il codice nel corpo di un metodo o una risorsa esistente.
Puoi eseguire questa azione anche premendo Control+Alt+F10 (Control+Comando+Maiusc+R su macOS).
Applica modifiche al codice 
: tenta di applicare solo le modifiche al codice senza riavviare nulla. In genere, puoi utilizzare questa
opzione quando hai modificato il codice nel corpo di un metodo, ma non hai
modificato alcuna risorsa. Se hai modificato sia il codice sia le risorse, utilizza
Applica modifiche e riavvia attività.
Puoi eseguire questa azione anche premendo Control+F10 (Control+Comando+R su macOS).
Esegui : esegue il deployment di tutte le modifiche e riavvia l'app. Utilizza questa
opzione quando le modifiche apportate non possono essere applicate utilizzando una delle opzioni Applica
modifiche. Per scoprire di più sui tipi di modifiche che richiedono il riavvio di un'app, consulta la sezione Limitazioni di Applica modifiche.
Attivare il fallback per l'esecuzione di Applica modifiche
Quando fai clic su Applica modifiche e riavvia attività o su
Applica modifiche al codice, Android Studio crea un nuovo APK e determina se
le modifiche possono essere applicate. Se le modifiche non possono essere applicate e causano un errore di Applicazione modifiche, Android Studio ti chiede di Eseguire di nuovo l'app.
Se non vuoi che ti venga chiesto ogni volta che si verifica questo problema, puoi configurare Android Studio in modo che riavvii automaticamente l'app quando non è possibile applicare le modifiche. Per attivare questo comportamento, segui questi passaggi:
Apri la finestra di dialogo Impostazioni o Preferenze:
- Su Windows o Linux, seleziona File > Impostazioni dal menu.
- Su macOS, seleziona Android Studio > Preferenze dal menu.
Vai a Compilazione, esecuzione, deployment > Deployment.
Seleziona le caselle di controllo per attivare il fallback per l'esecuzione automatica per una o entrambe le azioni Applica modifiche.
Fai clic su OK.
Modifiche dipendenti dalla piattaforma
Alcune funzionalità di Applica modifiche dipendono da versioni specifiche della piattaforma Android. Per applicare questi tipi di modifiche, l'app deve essere dispiattata su un dispositivo con quella versione di Android (o successive). Ad esempio, l'aggiunta di un metodo richiede Android 11 o versioni successive.
Limitazioni di Applica modifiche
La funzionalità Applica modifiche è progettata per velocizzare la procedura di deployment dell'app. Tuttavia, esistono alcune limitazioni relative al momento in cui può essere utilizzata.
Modifiche al codice che richiedono il riavvio dell'app
Alcune modifiche al codice e alle risorse non possono essere applicate finché l'app non viene riavviata, tra cui:
- Aggiunta o rimozione di un campo
- Rimuovere un metodo
- Modifica delle firme dei metodi
- Modifica dei modificatori di metodi o classi
- Modificare l'ereditarietà della classe
- Modifica dei valori negli enum
- Aggiunta o rimozione di una risorsa
- Modifica del file manifest dell'app
- Modifica delle librerie native (file SO)
Librerie e plug-in
Alcune librerie e plug-in apportano automaticamente modifiche ai file manifest della tua app o alle risorse a cui viene fatto riferimento nel manifest. Questi aggiornamenti automatici possono interferire con Applica modifiche nei seguenti modi:
- Se una libreria o un plug-in apporta modifiche al file manifest della tua app, non puoi utilizzare Applica modifiche. Per visualizzare le modifiche, devi riavviare l'app.
- Se una libreria o un plug-in apporta modifiche ai file di risorse dell'app, non puoi utilizzare Applica modifiche al codice . Per visualizzare le modifiche, devi utilizzare Applica modifiche e riavvia attività
(o riavviare l'app).
Per evitare queste limitazioni, disattiva tutti gli aggiornamenti automatici per le varianti di compilazione di debug.
Ad esempio, Firebase
Crashlytics aggiorna le risorse dell'app con un ID build univoco durante ogni build, il che ti impedisce di utilizzare Applica modifiche al codice
e ti richiede di riavviare l'attività dell'app per visualizzare le modifiche. Disattiva questo comportamento per utilizzare Applica modifiche al codice insieme a Crashlytics con le tue build di debug.
Codice che fa riferimento direttamente ai contenuti di un APK installato
Se il codice fa riferimento direttamente ai contenuti dell'APK dell'app installato sul dispositivo, può causare arresti anomali o comportarsi in modo anomalo dopo aver fatto clic su Applica modifiche al codice . Questo comportamento si verifica
perché quando fai clic su Applica modifiche al codice, l'APK di base sul dispositivo
viene sostituito durante l'installazione. In questi casi, puoi fare clic su Applica modifiche
e riavvia attività
o su Esegui .
Se riscontri altri problemi durante l'utilizzo di Applica modifiche, segnala un bug.
Live Edit
La modifica in tempo reale è una funzionalità sperimentale di Android Studio che ti consente di aggiornare i composabili in emulatori e dispositivi fisici in tempo reale. Questa funzionalità minimizza i cambi di contesto tra la scrittura e la creazione dell'app, consentendoti di concentrarti sulla scrittura del codice per più tempo senza interruzioni.
Modificare la variante di compilazione
Per impostazione predefinita, Android Studio crea la versione di debug dell'app, che è destinada all'uso solo durante lo sviluppo, quando fai clic su Esegui 
.
Per modificare la variante di build utilizzata da Android Studio, esegui una delle seguenti operazioni:
- Seleziona Build > Seleziona variante di build nel menu.
- Seleziona Visualizza > Finestre degli strumenti > Varianti di build nel menu.
- Fai clic sulla scheda Crea varianti nella barra della finestra dello strumento.
Per i progetti senza codice nativo/C++, il riquadro Varianti di compilazione contiene due colonne: Modulo e Variante di compilazione attiva. Il valore Active Build Variant per il modulo determina la variante di build di cui l'IDE esegue il deployment sul dispositivo connesso ed è visibile nell'editor.
Figura 9. Il riquadro Varianti di compilazione contiene due colonne per i progetti che non hanno codice nativo/C++.
Per passare da una variante all'altra, fai clic sulla cella Variante di compilazione attiva per un modulo e scegli la variante che ti interessa dall'elenco.
Per i progetti con codice nativo/C++, il riquadro Varianti di build contiene tre colonne:
- Modulo
- Variante di compilazione attiva
- ABI attivo
Il valore Active Build Variant (Variante di build attiva) per il modulo determina la variante di build che l'IDE esegue il deployment sul dispositivo ed è visibile nell'editor. Per i moduli nativi, il valore ABI attivo determina l'ABI utilizzato dall'editor, ma non influisce su ciò che viene disegnato.
Figura 10. Il riquadro Varianti di compilazione aggiunge la colonna ABI attivo per i progetti con codice nativo/C++.
Per modificare la variante di build o l'ABI, fai clic sulla cella corrispondente alla colonna Variante di build attiva o ABI attivo e scegli la variante o l'ABI che preferisci dall'elenco. Dopo aver modificato la selezione, l'IDE sincronizza automaticamente il progetto. La modifica di una delle colonne per un modulo di app o libreria applica la modifica a tutte le righe dipendenti.
Per impostazione predefinita, i nuovi progetti vengono configurati con due varianti di build: una variante di debug e una variante di release. Devi creare la variante di release per preparare la tua app per la release pubblica. Per definire altre varianti della tua app con funzionalità o requisiti del dispositivo diversi, puoi definire varianti di compilazione aggiuntive.
Conflitti nella finestra di dialogo Varianti di compilazione di Android Studio
Nella finestra di dialogo Varianti di build di Android Studio, potresti visualizzare messaggi di errore che indicano conflitti tra le varianti di build, ad esempio:
Questo errore non indica un problema di compilazione con Gradle. Indica che IDE Android Studio non riesce a risolvere i simboli tra le varianti dei moduli selezionati.
Ad esempio, se hai un modulo M1 che dipende dalla variante v1 del modulo
M2, ma M2 ha la variante v2 selezionata nell'IDE, hai simboli non risolti
nell'IDE. Supponiamo che M1 dipenda da una classe disponibile solo in v1. Quando è selezionato v2, la classe non è nota all'IDE. Di conseguenza, non riesce a risolvere il nome della classe e mostra errori nel codice del modulo M1.
Questi messaggi di errore vengono visualizzati perché l'IDE non può caricare il codice per più varianti contemporaneamente. Tuttavia, in termini di compilazione dell'app, la variante selezionata in questa finestra di dialogo non ha alcun effetto, perché Gradle compila l'app con il codice sorgente specificato nelle ricette di compilazione di Gradle, non in base a ciò che è attualmente caricato nell'IDE.
Modificare la configurazione di esecuzione/debug
Quando esegui l'app per la prima volta, Android Studio utilizza una configurazione di esecuzione predefinita. La configurazione di esecuzione specifica se eseguire il deployment dell'app da un APK o da un Android App Bundle, nonché il modulo da eseguire, il pacchetto da eseguire il deployment, l'attività da avviare, il dispositivo di destinazione, le impostazioni dell'emulatore, le opzioni di Logcat e altro ancora.
La configurazione di esecuzione/debug predefinita genera un APK, avvia l'attività del progetto predefinita e utilizza la finestra di dialogo Seleziona destinazione di deployment per la selezione del dispositivo di destinazione. Se le impostazioni predefinite non sono adatte al tuo progetto o modulo, puoi personalizzare la configurazione di esecuzione/debug o crearne una nuova a livello di progetto, predefinito e modulo.
Per modificare una configurazione di esecuzione/debug, seleziona Esegui > Modifica configurazioni. Per maggiori informazioni, consulta Creare e modificare le configurazioni di esecuzione/debug.