Android Studio mette a disposizione un debugger che ti consente di eseguire le seguenti operazioni e non solo:
- Seleziona un dispositivo su cui eseguire il debug della tua app.
- Imposta punti di interruzione nel codice Java, Kotlin e C/C++.
- Esaminare le variabili e valutare le espressioni in fase di runtime.
Questa pagina include le istruzioni per le operazioni di debug di base. Per ulteriore documentazione, consulta anche la documentazione sul debug di Intelligence IDEA.
Attiva debug
Prima di iniziare il debug, segui questi passaggi:
- Attiva il debug sul tuo dispositivo.
- Se utilizzi l'emulatore, il debug è abilitato per impostazione predefinita. Per i dispositivi connessi, invece, devi attivare il debug nelle Opzioni sviluppatore del dispositivo.
- Esegui una variante di build di cui è possibile eseguire il debug.
Usa una variante della build che include
debuggable true
(isDebuggable = true
negli script Kotlin) nella configurazione della build.In genere, puoi selezionare la variante "debug" predefinita inclusa in ogni progetto Android Studio, anche se non è visibile nel file
build.gradle
. Tuttavia, se definisci nuovi tipi di build per cui è possibile eseguire il debug, devi aggiungeredebuggable true
al tipo di build:- Imposta i punti di interruzione nel codice della tua app.
- Nella barra degli strumenti, seleziona un dispositivo su cui eseguire il debug dell'app dal menu del dispositivo di destinazione.
Se non hai configurato alcun dispositivo, devi collegare un dispositivo tramite USB, connettere un dispositivo tramite Wi-Fi o creare una durata di visualizzazione media per utilizzare l'emulatore Android.
- Nella barra degli strumenti, fai clic su Debug .
Se l'app è già in esecuzione sul dispositivo, viene visualizzata una finestra di dialogo che ti chiede se vuoi passare da Esegui a Debug. Per iniziare il debug sarà necessario riavviare il dispositivo. Per mantenere in esecuzione la stessa istanza dell'app, fai clic su Annulla debug e collega il debugger a un'app in esecuzione. In caso contrario, Android Studio crea un APK, lo firma con una chiave di debug, lo installa sul dispositivo selezionato e lo esegue.
Se aggiungi codice C e C++ al tuo progetto, Android Studio esegue anche il debugger LLDB nella finestra di debug per eseguire il debug del codice nativo.
- Se la finestra Debug non è aperta, seleziona Visualizza > Finestre degli strumenti > Debug oppure fai clic su Debug nella barra della finestra degli strumenti.
- Fai clic su Collega debugger al processo Android .
- Nella finestra di dialogo Scegli processo, seleziona il processo a cui vuoi collegare il debugger.
- Se utilizzi un emulatore o un dispositivo rooted, puoi selezionare Mostra tutti i processi per visualizzare tutti i processi. Su un dispositivo rooted, verranno visualizzati tutti i processi in esecuzione sul dispositivo. Tuttavia, su un dispositivo non rooted, verranno mostrati solo i processi di cui è possibile eseguire il debug.
- Dal menu Usa le impostazioni di Android Debugger da, puoi selezionare una configurazione di esecuzione/debug esistente. Per il codice C e C++, ciò consente di riutilizzare i comandi di avvio LLDB, i comandi post-attach LLDB e le directory dei simboli in una configurazione esistente.
- Se non hai una configurazione di esecuzione/debug esistente, seleziona Crea nuova. Questa selezione attiva il menu Tipo di debug, in cui puoi selezionare un tipo di debug diverso. Per impostazione predefinita, Android Studio utilizza il tipo di debug Rileva automaticamente per selezionare l'opzione di debug più adatta a te a seconda che il progetto includa codice Java o C/C++.
- Fai clic su Ok.
Viene visualizzata la finestra Debug.
- Barra degli strumenti di esecuzione e navigazione. Consulta l'articolo Utilizzare i punti di interruzione
- Selettore thread
- Inserimento delle espressioni di valutazione e controllo. Consulta Ispezionare le variabili.
- Visualizzazione impilata
- Variabili. Consulta Ispezionare le variabili.
- Rileva automaticamente
- Seleziona questo tipo di debug se vuoi che Android Studio scelga automaticamente l'opzione migliore per il codice di cui esegui il debug. Ad esempio, se il tuo progetto contiene codice C o C++, Android Studio utilizza automaticamente il tipo di debug Dual. Altrimenti, Android Studio utilizza il tipo di debug solo Java.
- Solo Java
- Seleziona questo tipo di debug se vuoi eseguire il debug solo del codice scritto in Java o Kotlin. Il debugger solo Java ignora eventuali punti di interruzione o orologi impostati nel codice nativo.
- Solo nativo (disponibile solo con codice C/C++)
-
Seleziona questo tipo di debug se vuoi utilizzare solo LLDB per eseguire il debug del codice. Quando utilizzi questo tipo di debug, la visualizzazione della sessione del debugger Java non è disponibile. Per impostazione predefinita, LLDB ispeziona solo il codice nativo e ignora i punti di interruzione nel codice Java. Se vuoi eseguire anche il debug del codice Java, passa al tipo di debug Rileva automaticamente o Doppio.
Il debug nativo funziona solo su dispositivi che soddisfano i seguenti requisiti:
Il dispositivo supporta
run-as
.Per verificare se il dispositivo supporta
run-as
, esegui questo comando sulla shell ADB collegata al dispositivo:run-as your-package-name pwd
Sostituisci
your-package-name
con il nome del pacchetto dell'app. Se il dispositivo supportarun-as
, il comando dovrebbe essere restituito senza errori.Sul dispositivo è abilitato
ptrace
.Per verificare se
ptrace
è abilitato, esegui questo comando sulla shell ADB collegata al tuo dispositivo:sysctl kernel.yama.ptrace_scope
Se
ptrace
è abilitato, il comando stamperà il valore0
o un erroreunknown key
. Septrace
non è abilitato, verrà stampato un valore diverso da0
.
- Dual (Java + nativo): disponibile solo con il codice C/C++
-
Seleziona questo tipo di debug se vuoi passare dal debug di Java e del codice nativo.
Android Studio collega sia il debugger Java sia l'LLDB al processo dell'app per consentirti di controllare i punti di interruzione nel codice Java e nativo senza riavviare l'app o modificare la configurazione di debug.
Nella figura 2, sono presenti le due schede a destra del titolo della finestra di debug. Poiché l'app include codice sia Java che C++, una scheda consente di eseguire il debug del codice nativo e l'altra del codice Java, come indicato da -java.
- Punto di interruzione riga
- Il tipo più comune è un punto di interruzione di riga che mette in pausa l'esecuzione dell'app in corrispondenza di una specifica riga di codice. Con la pausa, puoi esaminare le variabili, valutare le espressioni e poi continuare l'esecuzione riga per riga per determinare le cause degli errori di runtime.
- Punto di interruzione metodo
- Un punto di interruzione del metodo mette in pausa l'esecuzione della tua app quando entra o esce da un metodo specifico. Con la pausa, puoi esaminare le variabili, valutare le espressioni e poi continuare l'esecuzione riga per riga per determinare le cause degli errori di runtime. Quando imposti un punto di interruzione su una funzione componibile, il debugger elenca i parametri dell'elemento componibile e il relativo stato per identificare le modifiche che potrebbero aver causato la ricomposizione.
- Punto di interruzione campo
- Un punto di interruzione campo mette in pausa l'esecuzione dell'app quando legge o scrive in un campo specifico.
- Punto di interruzione eccezione
- Un punto di interruzione eccezione mette in pausa l'esecuzione dell'app quando viene generata un'eccezione.
- Individua la riga di codice in cui vuoi mettere in pausa l'esecuzione.
- Fai clic sulla grondaia sinistra lungo la riga di codice o posiziona il cursore sulla riga e premi Ctrl+F8 (su macOS, Comando+F8).
- Se l'app è già in esecuzione, fai clic su Collega debugger al processo Android . In alternativa, per avviare il debug, fai clic su Debug .
-
Per esaminare una variabile nell'albero degli oggetti, espandila nella visualizzazione Variabili. Se la vista Variabili non è visibile, fai clic su Impostazioni di layout e assicurati che le variabili siano selezionate.
-
Per passare alla riga successiva del codice senza inserire un metodo, fai clic su Passa .
-
Per passare alla prima riga all'interno di una chiamata di metodo, fai clic su Accedi .
-
Per passare alla riga successiva al di fuori del metodo corrente, fai clic su Esci .
-
Per continuare a eseguire l'app normalmente, fai clic su Riprendi programma .
- Android Studio passa alla scheda <your-module> quando il debugger LLDB rileva un punto di interruzione nel codice C/C++. Anche i riquadri Frame, Variabili e Watch sono disponibili e funzionano esattamente come se eseguissi il debug del codice Java.
Sebbene il riquadro Thread non sia disponibile nella vista della sessione LLDB, puoi accedere ai processi dell'app utilizzando l'elenco nel riquadro Frame. Per saperne di più su questi riquadri, consulta le sezioni su come eseguire il debug dei frame delle finestre e su come controllare le variabili.
Nota:durante l'ispezione di un punto di interruzione nel codice nativo, il sistema Android sospende la macchina virtuale che esegue il bytecode Java dell'app. Ciò significa che non puoi interagire con il debugger Java o recuperare informazioni sullo stato dalla sessione del debugger Java durante l'ispezione di un punto di interruzione nel codice nativo.
- Android Studio passa alla scheda <your-module>-java quando il debugger Java rileva un punto di interruzione nel codice Java o Kotlin.
- Durante il debug con LLDB, puoi utilizzare il terminale LLDB nella vista della sessione LLDB per passare le opzioni della riga di comando a LLDB. Se hai determinati comandi che vorresti che LLDB esegua ogni volta che avvii il debug della tua app, subito prima o subito dopo il collegamento del debugger al processo dell'app, puoi aggiungerli alla configurazione di debug.
- Inserisci l'espressione da controllare o visualizzare
- Fai clic su Aggiungi a orologi o premi Invio per valutare l'espressione una volta.
- Il dispositivo o l'emulatore fisico di destinazione utilizza una CPU x86 o x86_64. Se il dispositivo utilizza una CPU ARM, devi allineare il limite dell'indirizzo della variabile in memoria a 4 byte per i processori a 32 bit o 8 byte per i processori a 64 bit. Per allineare una variabile nel codice nativo, specifica
__attribute__((aligned(num_bytes)))
nella decelerazione della variabile, come mostrato di seguito:// For a 64-bit ARM processor int my_counter __attribute__((aligned(8)));
- Hai già assegnato tre o meno watchpoint. Android Studio supporta solo fino a quattro watchpoint su dispositivi di destinazione x86 o x86_64. Altri dispositivi potrebbero supportare meno watchpoint.
- Mentre l'app è sospesa su un punto di interruzione, vai al riquadro Variabili nella vista della sessione LLDB.
-
Fai clic con il pulsante destro del mouse su una variabile che occupa il blocco di memoria che vuoi monitorare e seleziona Aggiungi watchpoint.
Viene visualizzata una finestra di dialogo per configurare il watchpoint, come mostrato nella Figura 9.
Configura il tuo watchpoint con le seguenti opzioni:
- Attivato: deseleziona questa opzione se vuoi indicare ad Android Studio di ignorare il punto di visualizzazione finché non modifichi l'impostazione. Android Studio salva il tuo punto di visualizzazione per consentirti di accedervi in un secondo momento.
- Sospensione: per impostazione predefinita, il sistema Android sospende il processo dell'app quando accede a un blocco di memoria assegnato a un watchpoint. Deseleziona questa opzione se non vuoi che si verifichi questo comportamento. Vengono visualizzate opzioni aggiuntive che puoi utilizzare per personalizzare il comportamento quando il sistema interagisce con il punto di visualizzazione: Registra il messaggio nella console e Rimuovi quando premi.
- Tipo di accesso: scegli se l'app deve attivare il tuo watchpoint quando tenta di leggere o di scrivere nel blocco di memoria assegnato dal sistema alla variabile. Per attivare il watchpoint in una lettura o una scrittura, seleziona Qualsiasi.
- Fai clic su Fine.
- Nell'elenco Variabili, fai clic con il tasto destro del mouse in un punto qualsiasi di una riga della risorsa per visualizzare l'elenco.
- Nell'elenco, seleziona Visualizza come e scegli il formato che vuoi utilizzare.
I formati disponibili dipendono dal tipo di dati della risorsa selezionata. Potresti visualizzare una o più delle seguenti opzioni:
- Classe:mostra la definizione della classe.
- toString: il formato stringa visualizzata.
- Oggetto: visualizza la definizione dell'oggetto (un'istanza di una classe).
- Array: viene visualizzato in formato array.
- Timestamp: mostra data e ora nel seguente modo: aaaa-mm-gg hh:mm:ss.
- Automatico: Android Studio sceglie il formato migliore in base al tipo di dati.
- Binario: mostra un valore binario utilizzando zeri e uno.
- MeasurementSpec: il valore trasmesso dall'elemento principale all'elemento secondario selezionato.
Vedi
MeasureSpec
. - Hex: viene visualizzato come valore esadecimale.
- Primitivi:vengono visualizzati come valore numerico utilizzando un tipo di dati primitivi.
- Numero intero: visualizzato come valore numerico di tipo
Integer
.
- Fai clic con il tasto destro del mouse sul valore della risorsa.
- Seleziona Visualizza come.
- Seleziona Crea.
- Viene visualizzata la finestra di dialogo Renderer per i tipi di dati Java. Segui le istruzioni dei rendering dei tipi di dati Java.
Alla moda
android { buildTypes { customDebugType { debuggable true ... } } }
Kotlin
android { buildTypes { create("customDebugType") { isDebuggable = true ... } } }
Questa proprietà si applica anche ai moduli con codice C/C++.
Nota: la proprietà jniDebuggable
non è più utilizzata.
Se la tua app dipende da un modulo della libreria di cui vuoi eseguire il debug, anche la libreria deve essere pacchettizzata con debuggable true
in modo da conservare i simboli di debug.
Per garantire che le varianti di cui è possibile eseguire il debug del progetto dell'app ricevano la variante di cui è possibile eseguire il debug di un modulo libreria, pubblica versioni non predefinite della libreria.
Avvia debug
Puoi avviare una sessione di debug nel seguente modo:
Collegamento del debugger a un'app in esecuzione
Se l'app è già in esecuzione sul tuo dispositivo, puoi avviare il debug senza riavviarla nel seguente modo:
Anche la scheda Processi di Esplora dispositivi (Visualizza > Windows strumenti > Esplora dispositivi) include un elenco di processi di cui è possibile eseguire il debug. Da qui puoi selezionare un processo ed eseguire un'operazione di terminazione , un'interruzione forzata di o collegare il debugger a un determinato processo .
La finestra di debug
La finestra di debug è suddivisa
Nota: il debugger e il garbage collector di Android Studio sono
parzialmente integrati. La macchina virtuale Android garantisce che qualsiasi oggetto di cui il debugger sia a conoscenza non venga considerato garbage collection fino alla disconnessione del debugger. Ciò può causare l'accumulo di oggetti mentre il debugger è connesso. Ad esempio, se il debugger vede un thread in esecuzione, l'oggetto Thread
associato non viene garbage collection finché il debugger non si disconnette, anche se il thread è stato terminato.
Modificare il tipo di debugger
Poiché per eseguire il debug del codice Java/Kotlin e del codice C/C++ sono necessari strumenti diversi, il debugger di Android Studio consente di selezionare il tipo di debugger da utilizzare. Per impostazione predefinita, Android Studio decide quale debugger utilizzare in base alle lingue rilevate nel progetto utilizzando il tipo di debugger Rileva automaticamente.
Per selezionare manualmente il debugger nella configurazione di debug, fai clic su Esegui > Modifica configurazioni. Puoi anche selezionare il debugger nella finestra di dialogo visualizzata quando fai clic su Esegui > Collega debugger a processo Android.
I tipi di debug disponibili includono:
Nota: durante il debug di codice nativo ottimizzato dal compilatore, potresti ricevere il seguente messaggio di avviso:This function was
compiled with optimizations enabled. Some debugger features may not be
available
. Quando utilizzi i flag di ottimizzazione, il compilatore apporta modifiche al codice compilato per renderlo più efficiente. Di conseguenza, il debugger può segnalare informazioni impreviste o errate, in quanto è difficile per il debugger mappare il codice compilato ottimizzato al codice sorgente originale.
Per questo motivo, devi disabilitare le ottimizzazioni del compilatore durante il debug del codice nativo.
Utilizzare il log di sistema
Il log di sistema mostra messaggi di sistema durante il debug dell'app. Questi messaggi includono informazioni sulle app in esecuzione sul dispositivo. Se vuoi utilizzare il log di sistema per eseguire il debug dell'app, assicurati che il codice scriva i messaggi di log e stampi l'analisi dello stack per individuare le eccezioni mentre l'app è in fase di sviluppo.
Scrivi messaggi di log nel codice
Per scrivere messaggi di log nel codice, utilizza la classe
Log
. I messaggi di log ti aiutano a comprendere il flusso di esecuzione raccogliendo l'output di debug di sistema mentre interagisci con la tua app. I messaggi di log possono anche indicare in quale parte dell'app non è riuscita l'operazione. Per maggiori informazioni sul logging, consulta
Scrivere e visualizzare i log con Logcat.
L'esempio seguente mostra come aggiungere messaggi di log per determinare se le informazioni sullo stato precedente sono disponibili all'inizio dell'attività:
Kotlin
import android.util.Log ... class MyActivity : Activity() { ... override fun onCreate(savedInstanceState: Bundle?) { ... if (savedInstanceState != null) { Log.d(TAG, "onCreate() Restoring previous state") /* restore state */ } else { Log.d(TAG, "onCreate() No saved state available") /* initialize app */ } ... } ... companion object { private val TAG: String = MyActivity::class.java.simpleName ... } }
Java
import android.util.Log; ... public class MyActivity extends Activity { private static final String TAG = MyActivity.class.getSimpleName(); ... @Override public void onCreate(Bundle savedInstanceState) { ... if (savedInstanceState != null) { Log.d(TAG, "onCreate() Restoring previous state"); /* restore state */ } else { Log.d(TAG, "onCreate() No saved state available"); /* initialize app */ } ... } }
Durante lo sviluppo, il codice può anche rilevare eccezioni e scrivere l'analisi dello stack nel log di sistema:
Kotlin
fun someOtherMethod() { try { ... } catch (e : SomeException) { Log.d(TAG, "someOtherMethod()", e) } }
Java
void someOtherMethod() { try { ... } catch (SomeException e) { Log.d(TAG, "someOtherMethod()", e); } }
Nota: rimuovi i messaggi dei log di debug e le chiamate di stampa dell'analisi dello stack dal codice quando è tutto pronto per pubblicare l'app. A tale scopo, imposta un flag DEBUG
e inserisci i messaggi di log di debug all'interno di istruzioni condizionali.
Visualizzare il log di sistema
Puoi visualizzare e filtrare i messaggi di debug e di altro tipo nella finestra di Logcat, come mostrato nella
figura 4. Ad esempio, puoi visualizzare i messaggi quando si verifica la garbage collection o i messaggi che aggiungi alla tua app con la classe Log
.
Per utilizzare Logcat, avvia il debug e seleziona la scheda Logcat.
Per una descrizione di Logcat e delle sue opzioni di filtro, consulta Scrivere e visualizzare i log con Logcat.
Utilizzare i punti di interruzione
Android Studio supporta punti di interruzione che attivano diverse azioni di debug. Esistono diversi tipi di punti di interruzione:
Puoi impostare punti di interruzione condizionali che sospenderanno l'esecuzione solo se vengono soddisfatte condizioni specifiche. Puoi anche impostare punti di interruzione di logging che scrivono in Logcat senza sospendere l'esecuzione. In questo modo, eviterai di riempire il codice con istruzioni di log.
Per aggiungere un punto di interruzione di riga, procedi come segue:
Quando imposti un punto di interruzione, accanto alla linea viene visualizzato un punto rosso, come mostrato nella Figura 5.
Quando l'esecuzione del codice raggiunge il punto di interruzione, Android Studio mette in pausa l'esecuzione dell'app.
Per identificare lo stato dell'app, usa gli strumenti nella scheda Debugger:
Se il progetto utilizza codice nativo, per impostazione predefinita il tipo di debug Rileva automaticamente collega il debugger Java e l'LLDB all'app come due processi separati. Puoi passare dall'ispezione dei punti di interruzione Java e C/C++ senza riavviare l'app o modificare le impostazioni.
Nota:per consentire ad Android Studio di rilevare i punti di interruzione nel codice C o C++, devi utilizzare un tipo di debug che supporti LLDB, come Rileva automaticamente, Nativo o Dual. Puoi modificare il tipo di debug utilizzato da Android Studio modificando la configurazione di debug. Per scoprire di più sui diversi tipi di debug, leggi la sezione sull'utilizzo di altri tipi di debug.
Quando Android Studio esegue il deployment dell'app sul dispositivo di destinazione, si apre la finestra di debug con una scheda o una visualizzazione della sessione di debug per ogni processo del debugger, come mostrato nella figura 6.
Durante il debug del codice C/C++, puoi anche impostare particolari tipi di punti di interruzione, chiamati watchpoint, che possono sospendere il processo dell'app quando quest'ultima interagisce con un determinato blocco di memoria. Per scoprire di più, leggi la sezione su come aggiungere watchpoint.
Visualizzare e configurare i punti di interruzione
Per visualizzare tutti i punti di interruzione e configurare le impostazioni dei punti di interruzione, fai clic su Visualizza punti di interruzione nella finestra di debug. Viene visualizzata la finestra Punti di interruzione, come mostrato nella Figura 7.
La finestra Punti di interruzione consente di abilitare o disabilitare ogni punto di interruzione dall'elenco nel riquadro. Se un punto di interruzione è disattivato, Android Studio non mette in pausa l'app quando raggiunge quel punto di interruzione.
Seleziona un punto di interruzione dall'elenco per configurarne le impostazioni. Puoi configurare un punto di interruzione da disabilitare inizialmente e fare in modo che il sistema lo abiliti dopo il raggiungimento di un punto di interruzione diverso. Puoi anche configurare se un punto di interruzione deve essere disabilitato dopo l'hit. Per impostare un punto di interruzione per qualsiasi eccezione, seleziona Punti di interruzione eccezioni nell'elenco dei punti di interruzione.
Per disabilitare temporaneamente tutti i punti di interruzione, fai clic su Disattiva punti di interruzione nella finestra di debug. Fai di nuovo clic per riattivarla.
Frame delle finestre di debug
Nella finestra Debugger, il riquadro Frame ti consente di ispezionare lo stack frame che ha causato l'ottenimento del punto di interruzione corrente. In questo modo puoi esplorare ed esaminare lo stack frame, nonché ispezionare l'elenco di thread nella tua app per Android.
Per selezionare un thread, utilizza il menu del selettore dei thread e visualizza il relativo stack frame. Fai clic sugli elementi nel frame per aprire il codice sorgente nell'editor. Puoi anche personalizzare la presentazione dei thread ed esportare lo stack frame come descritto nella guida Esamina i frame.
Ispeziona le variabili
Nella finestra Debugger, il riquadro Variabili consente di esaminare le variabili quando il sistema arresta l'app in un punto di interruzione e di selezionare un frame dal riquadro Frame. Il riquadro Variabili consente anche di valutare espressioni ad hoc utilizzando metodi statici e/o variabili disponibili all'interno del frame selezionato.
Per aggiungere un'espressione alla struttura ad albero degli oggetti (durante il debug dell'applicazione):
In alternativa, se la struttura degli oggetti contiene l'espressione da esaminare, puoi trascinarla in cima alla struttura per aggiungerla come espressione controllata.
Le espressioni osservate si aggiornano quando vengono raggiunti i punti di interruzione o quando passi nel codice.
Le espressioni valutate rimangono visualizzate nella parte superiore della struttura ad albero degli oggetti finché non valuti manualmente un'altra espressione o non passi nel codice.
Per rimuovere un'espressione controllata dalla struttura ad albero degli oggetti, fai clic con il tasto destro del mouse sull'espressione, quindi fai clic su Rimuovi orologio.
Aggiungi watchpoint
Durante il debug del codice C/C++, puoi impostare tipi speciali di punti di interruzione, denominati watchpoint, che possono sospendere il processo dell'app quando quest'ultima interagisce con un determinato blocco di memoria. Ad esempio, se imposti due puntatori a un blocco di memoria e assegni a quest'ultimo un watchpoint, l'utilizzo di uno dei due puntatori per accedere a quel blocco di memoria attiva il watchpoint.
In Android Studio, puoi creare un watchpoint durante il runtime selezionando una variabile specifica, ma LLDB assegna il watchpoint solo al blocco di memoria che il sistema alloca alla variabile, non alla variabile stessa. Questa è diversa dall'aggiunta di una variabile al riquadro Orologi, che ti consente di osservare il valore di una variabile, ma non ti consente di sospendere il processo dell'app quando il sistema legge o modifica il suo valore in memoria.
Nota:quando il processo dell'app esce da una funzione e il sistema distribuisce le variabili locali dalla memoria, devi riassegnare gli eventuali watchpoint che hai creato per queste variabili.
Per impostare un watchpoint, devi soddisfare i seguenti requisiti:
Nota:quando esegui il debug della tua app con ABI ARM a 32 bit, l'aggiunta di un watchpoint o il passaggio del mouse sopra le variabili all'interno del codice per analizzarne i valori potrebbe causare un arresto anomalo. Come soluzione alternativa, esegui il debug utilizzando file binari ARM, x86 o x86_64 a 64 bit. Questo problema verrà risolto in un'imminente release di Android Studio.
Se soddisfi i requisiti, puoi aggiungere un watchpoint come segue:
Per visualizzare tutti i watchpoint e configurarne le impostazioni, fai clic su Visualizza punti di interruzione nella finestra di debug. Viene visualizzata la finestra di dialogo Punti di interruzione, come mostrato nella Figura 10.
Dopo aver aggiunto il watchpoint, fai clic su Riprendi programma nella finestra di debug per riprendere il processo dell'app. Per impostazione predefinita, se la tua app tenta di accedere a un blocco di memoria su cui hai impostato un watchpoint, il sistema Android sospende il processo dell'app e accanto all'ultima riga di codice eseguita dall'app viene visualizzata un'icona , come mostrato nella figura 11.
Visualizza e modifica il formato di visualizzazione dei valori delle risorse
In modalità di debug, puoi visualizzare i valori delle risorse e selezionare un formato di visualizzazione diverso per le variabili nel codice Java o Kotlin. Dopo aver visualizzato la scheda Variabili e selezionato un frame, procedi nel seguente modo:
Per creare un formato personalizzato: