Questa pagina è stata tradotta dall'API Cloud Translation.

Debug dell'app

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 la documentazione sul debug di IntelliJ 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. Ma per un dispositivo connesso, devi attivare il debug nello sviluppatore del dispositivo opzioni.

Esegui una variante di build di cui è possibile eseguire il debug.

Utilizza una variante della build che include debuggable true (isDebuggable = true negli script Kotlin) nella configurazione della build.

Di solito, puoi selezionare il "debug" predefinito una variante inclusa in ogni Android Studio progetto, anche se non è visibile nel file build.gradle. Tuttavia, se per definire nuovi tipi di build di cui deve essere possibile eseguire il debug, devi aggiungere debuggable true al tipo di build:

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: il La proprietà jniDebuggable non è più utilizzata.

Se la tua app dipende da un modulo della libreria di cui vuoi eseguire il debug, anche questa libreria deve essere pacchettizzato con debuggable true in modo da conservare i simboli di debug. Per assicurarti che le varianti di cui può essere eseguito il debug del progetto di app ricevano la variante di cui può essere eseguito il debug di un modulo libreria, pubblicare versioni non predefinite della libreria.

Avvia debug

Puoi avviare una sessione di debug nel seguente modo:

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.

Figura 1. Menu del dispositivo di destinazione.

Se non hai dispositivi configurati, devi: collega un dispositivo tramite USB, connettere un dispositivo tramite Wi-Fi oppure crea una durata di visualizzazione media per utilizzare 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 desideri e passare da Esegui a Debug. Per iniziare il debug sarà necessario riavviare il dispositivo. A mantenere in esecuzione la stessa istanza dell'app, fai clic su Annulla debug e, collegare il debugger a un'app in esecuzione. Altrimenti, 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 sezione 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.

Collegamento del debugger a un'app in esecuzione

Se la tua app è già in esecuzione sul tuo dispositivo, puoi iniziare il debug senza riavvia l'app nel seguente modo:

Fai clic su Collega debugger al processo Android .
Nella finestra di dialogo Scegli processo, seleziona il processo che vuoi collegare il debugger.
1. Se utilizzi un emulatore o un dispositivo rooted, puoi controllare Mostra tutti i processi per visualizzare tutti i processi. Su un dispositivo rooted, verranno mostrate tutte processi in esecuzione sul dispositivo. Tuttavia, su un dispositivo non rooted, verrà visualizzata solo di cui è possibile eseguire il debug.
2. Dal menu Usa le impostazioni di Android Debugger da, puoi selezionare un modello esistente configurazione di esecuzione/debug. Per i codici C e C++, Ciò consente di riutilizzare i comandi di avvio LLDB, i comandi post-attach LLDB e in una configurazione esistente.
3. Se non hai un'esecuzione/debug esistente configurazione, seleziona Crea nuova. Questa selezione attiva la colonna Debug Type (Tipo di debug) in cui puoi selezionare un tipo di debug diverso. Di predefinita, Android Studio utilizza il tipo di debug Rileva automaticamente per selezionare dell'opzione debugger a seconda che il progetto includa codice Java o C/C++.
Fai clic su OK.
Viene visualizzata la finestra Debug.

Scheda Processi di Esplora dispositivi (Visualizza > Finestre strumenti > Esplora dispositivi) include anche un elenco di processi di cui è possibile eseguire il debug. Da qui puoi selezionare un processo ed eseguire un kill , interruzione forzata , o collegare il debugger a un determinato processo .

La finestra di debug

La finestra di debug è suddivisa

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.

Nota: il debugger e il garbage collection di Android Studio vengono non sono strettamente integrati. La macchina virtuale Android garantisce che qualsiasi oggetto il debugger è a conoscenza della garbage collection solo dopo il debugger viene disconnesso. Ciò può causare l'accumulo di oggetti mentre debugger connesso. Ad esempio, se il debugger vede un thread in esecuzione, 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 di debug diversi, la classe Il debugger di Android Studio ti consente di selezionare il tipo di debugger da utilizzare. Per impostazione predefinita, Android Studio decide quale debugger utilizzare in base alle lingue che rileva nel progetto utilizzando Rileva automaticamente il tipo di debugger.

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 fai clic su Esegui > Collega il debugger al processo Android.

I tipi di debug disponibili includono:

Rileva automaticamente

Seleziona questo tipo di debug se vuoi che Android Studio scelga automaticamente l'opzione migliore. per il codice che stai eseguendo il debug. Ad esempio, se disponi di codice C o C++ nel tuo progetto, Android Studio usa automaticamente il di testo. 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. Solo Java il debugger 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 si utilizza 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 tuo Java le API nel tuo codice. Se vuoi eseguire anche il debug del codice Java, passa a il 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: la shell ADB collegata al tuo dispositivo:
```
run-as your-package-name pwd
```
Sostituisci your-package-name con il nome del pacchetto dell'app. Se dispositivo supporta run-as, il comando dovrebbe essere restituito senza errori.
Sul dispositivo è abilitato ptrace.

Per verificare se ptrace è abilitato, esegui questo comando sull'ADB all'interfaccia utente connessa al tuo dispositivo:
```
sysctl kernel.yama.ptrace_scope
```
Se ptrace è abilitato, il comando stamperà il valore 0 o un un errore unknown key. Se la funzionalità ptrace non è attiva, verrà stampata diverso da 0.

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 il debugger Java e l'LLDB all'app per poter esaminare punti di interruzione sia nel codice Java che in quello 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 contiene codice sia Java che C++, una scheda consente di eseguire il debug e l'altro per il debug del codice Java, come indicato da -java.

**Figura 3.** Scheda per il debug del codice nativo e scheda per il debug del codice Java.

Nota:durante il debug del codice nativo ottimizzato dalla funzione viene visualizzato 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 il codice compilato per eseguirlo in modo più efficiente. Questo può far sì che il debugger segnalare informazioni impreviste o errate, perché è difficile per debugger per mappare il codice compilato ottimizzato al codice sorgente originale. Per questo motivo, devi disattivare le ottimizzazioni del compilatore durante il debug il codice nativo.

Utilizzare il log di sistema

Il log di sistema mostra messaggi di sistema durante il debug dell'app. Questi messaggi includono informazioni dalle app in esecuzione sul dispositivo. Se vuoi utilizzare log di sistema per eseguire il debug dell'app, assicurati che il codice scriva messaggi di log e stampi lo stack monitorare 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. Guida per i messaggi di log per comprendere il flusso di esecuzione raccogliendo l'output di debug del sistema interagisci con la tua app. I messaggi di log possono anche indicare errore nell'app. Per ulteriori informazioni sul logging, consulta Scrivi e visualizza i log con Logcat.

L'esempio seguente mostra come aggiungere messaggi di log per determinare se lo stato precedente sono disponibili informazioni 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 sistema log:

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 da il codice quando è tutto pronto per pubblicare l'app. Per farlo, imposta un DEBUG e inserire 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 come mostrato nella figura 4. Ad esempio, puoi visualizzare i messaggi quando si verifica la garbage collection o i messaggi che che aggiungi all'app Log.

Per utilizzare Logcat, avvia il debug e seleziona la scheda Logcat.

**Figura 4.** Finestra Logcat con impostazioni di filtro.

Per una descrizione di Logcat e delle sue opzioni di filtro, vedi Scrivi e visualizza i log con Logcat.

Utilizzare i punti di interruzione

Android Studio supporta i punti di interruzione attivare diverse azioni di debug. Esistono diversi tipi di punti di interruzione:

Punto di interruzione riga: Il tipo più comune è un punto di interruzione di riga che mette in pausa l'esecuzione dell'app in un punto specificato riga di codice. Mentre sei in pausa, puoi esaminare le variabili, valutare le espressioni e poi continuare 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 una specifica . Mentre sei in pausa, puoi esaminare le variabili, valutare le espressioni e poi continuare 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 del componibile e il relativo stato per identificare le modifiche che potrebbero aver causato la ricomposizione.
Punto di interruzione campo: Un punto di interruzione di 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.

Puoi impostare punti di interruzione condizionali che sospenderanno l'esecuzione solo in presenza di condizioni specifiche sono soddisfatti. Puoi anche impostare punti di interruzione di logging che scrivono in Logcat senza sospendere dell'esecuzione. In questo modo, eviterai di riempire il codice con istruzioni di log.

Per aggiungere un punto di interruzione di riga, procedi come segue:

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 caso contrario, per avviare il debug, fai clic su Debug. .

Quando imposti un punto di interruzione, accanto alla linea viene visualizzato un punto rosso, come mostrato nella Figura 5.

**Figura 5.** Viene visualizzato un punto rosso accanto quando imposti un punto di interruzione.

Quando l'esecuzione del codice raggiunge il punto di interruzione, Android Studio mette in pausa l'esecuzione della tua app.

Per identificare lo stato dell'app, usa gli strumenti nella scheda Debugger:

Per esaminare una variabile nell'albero degli oggetti, espandila nella visualizzazione Variabili. Se La vista Variabili non è visibile, fai clic su Impostazioni layout. e assicurati che variables sia selezionata.
Per passare alla riga successiva del codice senza inserire un metodo, fai clic su Passaggio Più di .
Per passare alla prima riga di una chiamata di metodo, fai clic su Passaggio In .
Per passare alla riga successiva all'esterno del metodo corrente, fai clic su Passaggio Fuori .
Per continuare a eseguire l'app normalmente, fai clic su Riprendi programma. .

Se il progetto utilizza codice nativo, per impostazione predefinita il tipo di debug Rileva automaticamente collega sia il debugger Java sia il file LLDB all'app come due indirizzi separati i processi di machine learning. Puoi passare dall'ispezione dei punti di interruzione Java e C/C++ tra un'analisi e l'altra 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 Doppio. Puoi modificare il tipo di debug utilizzato da Android Studio modificando la configurazione di debug. A per saperne di più sui diversi tipi di debug, leggi la sezione sull'utilizzo con altri tipi di debug.

Quando Android Studio implementa l'app sul dispositivo di destinazione, viene visualizzata la finestra di debug si apre con una visualizzazione scheda o sessione di debug per ogni processo del debugger, come mostrato come mostrato nella figura 6.

**Figura 6.** Debug del codice nativo tramite LLDB.

Android Studio passa alla <your-module> quando il debugger LLDB rileva un nel tuo codice C/C++. Frame, variabili e Anche i riquadri degli orologi sono disponibili e funzionano esattamente come era il debug del codice Java.

Sebbene il riquadro Thread non sia disponibile nella vista della sessione LLDB, puoi accedere ai processi dell'app utilizzando nel riquadro Cornici. Scopri di più su questi argomenti riquadri nelle sezioni su come eseguire il debug della finestra frame ed ispeziona le variabili.
Nota:mentre ispezioni un punto di interruzione nel codice nativo, la classe Il sistema Android sospende la macchina virtuale che esegue Java della tua app in bytecode. Ciò significa che non puoi interagire con Java debugger o recuperare informazioni sullo stato dal debugger Java mentre ispezioni un punto di interruzione nel codice nativo.
Android Studio passa alla Scheda <your-module>-java quando si utilizza il debugger Java incontra un punto di interruzione nel tuo codice Java o Kotlin.
Durante il debug con LLDB, puoi utilizzare il terminale LLDB nella Vista di sessione LLDB per passare opzioni della riga di comando a LLDB. Se hai comandi che desideri venga eseguito da LLDB ogni volta che avvii il debug appena prima o subito dopo che il debugger si collega al tuo di un'app, puoi aggiungere questi comandi alla configurazione di debug.

Durante il debug del codice C/C++, puoi anche impostare tipi speciali di punti di interruzione, chiamati watchpoint, che possono sospendere il processo dell'app quando interagisce con un particolare blocco di memoria. Per saperne 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 relative impostazioni, fai clic su Visualizza i punti di interruzione nel Finestra di debug. Viene visualizzata la finestra Punti di interruzione. come mostrato nella Figura 7.

. **Figura 7.** La finestra Punti di interruzione elenca tutte le punti di interruzione e include le impostazioni del comportamento per ciascuno.

La finestra Punti di interruzione consente di abilitare o disabilitare ogni punto di interruzione l'elenco nel riquadro. Se un punto di interruzione è disattivato, Android Studio non mettere in pausa l'app quando raggiunge il punto di interruzione.

Seleziona un punto di interruzione dal per configurarne le impostazioni. Puoi configurare un punto di interruzione da disabilitare e fare in modo che il sistema lo abiliti dopo il raggiungimento di un diverso punto di interruzione. Puoi anche configurare se un punto di interruzione deve essere disabilitato dopo che . Per impostare un punto di interruzione per un'eccezione, seleziona Eccezione Punti di interruzione nell'elenco dei punti di interruzione.

Per disattivare temporaneamente tutti i punti di interruzione, fai clic su Disattiva punti di interruzione nel Finestra di debug. Fai di nuovo clic per riattivarla.

Frame delle finestre di debug

Nella finestra Debugger, il riquadro Cornici ti consente di ispezionare lo stack frame che ha causato l'ottenimento del punto di interruzione corrente. Ciò consente è necessario navigare ed esaminare lo stack frame, nonché esaminare l'elenco thread nella tua app per Android.

Per selezionare un thread, utilizza il selettore di thread e visualizzare lo stack frame. Fai clic sugli elementi nel frame per aprire il codice sorgente nell'editor. Puoi anche personalizzare il thread presentazione ed esportate lo stack frame, come spiegato nella sezione Esamina la guida ai frame.

Ispeziona le variabili

Nella finestra Debugger, il riquadro Variabili consente di ispeziona le variabili quando il sistema interrompe l'app in un punto di interruzione seleziona un frame dal riquadro Cornici. Il riquadro Variabili consente di valutare espressioni ad hoc utilizzando metodi statici e/o disponibili all'interno del frame selezionato.

Per aggiungere un'espressione alla struttura ad albero degli oggetti (durante il debug dell'applicazione):

Figura 8. Struttura ad albero degli oggetti e casella di immissione delle espressioni nella finestra di debug.

Inserisci l'espressione da controllare o visualizzare
Fai clic su Aggiungi a orologi o premi Invio per valutare l'espressione una volta.

In alternativa, se la struttura ad albero degli oggetti contiene l'espressione che vuoi esaminare, puoi trascinare nella parte superiore della 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 viene eseguita manualmente valutare un'altra espressione o eseguire i passaggi del 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 smartwatch.

Aggiungi watchpoint

Durante il debug del codice C/C++, puoi impostare tipi speciali di punti di interruzione, chiamati watchpoint, che possono sospendere il processo dell'app quando interagisce con un particolare blocco di memoria. Ad esempio, se imposta due puntatori a un blocco di memoria e assegnagli un watchpoint, utilizzando su entrambi i cursori per accedere a quel blocco di memoria attiva il watchpoint.

In Android Studio, puoi creare un watchpoint durante il runtime selezionando per una variabile specifica, ma LLDB assegna il watchpoint solo al blocco memoria che il sistema alloca a quella variabile, non alla variabile stessa. Questo è diversa dall'aggiunta di una variabile al riquadro Orologi, che consente di osservare il valore di una variabile ma non ti consente di sospendere processo dell'app quando il sistema legge o modifica il proprio valore in memoria.

Nota: quando il processo dell'app chiude una funzione e il sistema dealloca le variabili locali dalla memoria, devi riassegnare i watchpoint creati per le variabili.

Per impostare un watchpoint, devi soddisfare i seguenti requisiti:

Il dispositivo o l'emulatore fisico di destinazione utilizza una CPU x86 o x86_64. Se utilizza una CPU ARM, devi allineare il in memoria a 4 byte, per processori a 32 bit, o 8 per i processori a 64 bit. Per allineare una variabile nel codice nativo, specifica __attribute__((aligned(num_bytes))) in una decelerazione variabile, come mostrato di seguito:
```
// For a 64-bit ARM processor
int my_counter __attribute__((aligned(8)));
```
Hai già assegnato tre o meno watchpoint. Solo Android Studio supporta fino a quattro watchpoint su dispositivi di destinazione x86 o x86_64. Altro i dispositivi potrebbero supportare meno watchpoint.

Nota:quando esegui il debug dell'app con ABI ARM a 32 bit, aggiungi un watchpoint o passi il mouse sopra sulle variabili all'interno del codice per analizzare i relativi valori potrebbero causare un arresto anomalo. Come soluzione alternativa, puoi eseguire il debug utilizzando ARM a 64 bit, file binari x86 o x86_64. Questo problema verrà risolto in un'imminente release di Android Studio.

Se soddisfi i requisiti, puoi aggiungere un watchpoint come segue:

Mentre la tua app è sospesa su un punto di interruzione, vai alla Riquadro Variabili nella vista della sessione LLDB.
Fai clic con il tasto destro del mouse su una variabile che occupa il blocco di memoria che vuoi e seleziona Aggiungi watchpoint.

. Figura 9. Aggiungi un watchpoint a una variabile in memoria.
Viene visualizzata una finestra di dialogo per configurare il watchpoint, come mostrato nella Figura 9.

Configura il tuo watchpoint con le seguenti opzioni:
- Attivata: deseleziona questa opzione se vuoi indicarlo. Android Studio per 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 la tua app. processo quando accede a un blocco di memoria che assegni a un watchpoint. Deseleziona questa opzione se non vuoi che si verifichi questo comportamento. Questo rivela altre opzioni che puoi utilizzare per personalizzare il comportamento quando Il sistema interagisce con il tuo watchpoint: Registra il messaggio nella console e Rimuovi quando premi.
- Tipo di accesso: scegli se l'app deve attivare o meno la tua watchpoint quando prova a Read o Write sul blocco di memoria che il sistema alloca alla variabile. Per attivare il tuo watchpoint durante una lettura o una scrittura, seleziona Qualsiasi.
Fai clic su Fine.

Per visualizzare tutti i tuoi watchpoint e configurarne le relative impostazioni, fai clic su Visualizza punti di interruzione nella finestra Debug. La Viene visualizzata la finestra di dialogo Punti di interruzione, come mostrato nella Figura 10.

. **Figura 10.** La finestra di dialogo Punti di interruzione elenca watchpoint e include le impostazioni del comportamento per ciascuno.

Dopo aver aggiunto il punto di visualizzazione, fai clic su Riprendi programma. nella finestra di debug per ripristinare l'app e il processo di sviluppo. Per impostazione predefinita, se la tua app tenta di accedere a un blocco di memoria hai impostato un watchpoint, il sistema Android sospende il processo dell'app e icona watchpoint accanto alla riga di codice dell'app eseguiti per ultimi, come mostrato nella figura 11.

. **Figura 11.** Android Studio indica la riga di codice la tua app viene eseguita poco prima di attivare un watchpoint.

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 variabili nel tuo codice Java o Kotlin. Con la scheda Variabili visualizzata e un frame selezionata, procedi nel seguente modo:

Nell'elenco Variabili, fai clic con il tasto destro del mouse in un punto qualsiasi di una riga della risorsa per visualizzare dall'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.

Per creare un formato personalizzato:

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 alla pagina Renderer dei tipi di dati Java.