Debug dell'app

Android Studio fornisce un debugger che ti consente di eseguire quanto segue e non solo:

• Seleziona un dispositivo su cui eseguire il debug dell'app.
• Imposta punti di interruzione nel codice Java, Kotlin e C/C++.
• Esamina le variabili e valuta le espressioni in fase di runtime.

Questa pagina include le istruzioni per le operazioni di base del debugger. Per ulteriore documentazione, consulta anche la documentazione sul debug di IntelliJ IDEA.

Attivare il debug

Prima di poter iniziare il debug, segui questi passaggi:

Attiva il debug sul dispositivo.

Se utilizzi l'emulatore, il debug è attivato per impostazione predefinita. Per un dispositivo connesso, devi abilitare il debug nelle opzioni sviluppatore del dispositivo.

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

Utilizza una variante di build che includa 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 che devono essere sottoposti a debug, devi aggiungere debuggable true al tipo di build:

Groovy

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 viene più utilizzata.

Se la tua app dipende da un modulo della libreria che vuoi anche eseguire il debug, anche questa libreria deve essere inclusa nel pacchetto con debuggable true in modo da conservare i simboli di debug. Per assicurarti che le varianti di debug del progetto dell'app ricevano la variante di debug di un modulo della libreria, pubblica versioni non predefinite della libreria.

Avvia debug

Puoi avviare una sessione di debug nel seguente modo:

1. Imposta punti di interruzione nel codice della tua app.
2. 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, collegare un dispositivo tramite Wi-Fi o creare un AVD per utilizzare Android Emulator.

3. Nella barra degli strumenti, fai clic su Debug .

   Se l'app è già in esecuzione sul dispositivo, viene visualizzata una finestra di dialogo che chiede se vuoi passare da Esegui a Debug. Per iniziare il debug, il dispositivo dovrà essere riavviato. 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 Debug per eseguire il debug del codice nativo.

4. Se la finestra Debug non è aperta, seleziona Visualizza > Finestre degli strumenti > Debug, oppure fai clic su Debug nella barra delle finestre degli strumenti.

Collega il debugger a un'app in esecuzione

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

1. Fai clic su Collega il debugger al processo Android .
2. Nella finestra di dialogo Scegli processo, seleziona il processo a cui vuoi collegare il debugger.
   1. Se utilizzi un emulatore o un dispositivo sottoposto a rooting, puoi selezionare Mostra tutti i processi per visualizzarli tutti. Su un dispositivo con accesso root, vengono mostrati tutti i processi in esecuzione sul dispositivo. Tuttavia, su un dispositivo non sottoposto a rooting, verranno visualizzati solo i processi di cui è possibile eseguire il debug.
   2. Dal menu Usa impostazioni di Android Debugger da, puoi selezionare una configurazione di esecuzione/debug esistente. Per il codice C e C++, questo ti consente di riutilizzare i comandi di avvio di LLDB, i comandi post-attach di LLDB e le directory dei simboli in una configurazione esistente.
   3. Se non hai una configurazione di esecuzione/debug esistente, seleziona Crea nuova. Questa selezione attiva il menu Tipo di debug, dove 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 migliore in base al fatto che il progetto includa codice Java o C/C++.
3. Fai clic su OK.

   Viene visualizzata la finestra Debug.

La scheda Processi in Device Explorer (Visualizza > Finestre degli strumenti > Device Explorer) contiene anche un elenco di processi di cui è possibile eseguire il debug. Da qui puoi selezionare un processo ed eseguire un'interruzione , un arresto forzato o collegare il debugger a un determinato processo .

La finestra di debug

La finestra di debug è divisa in

1. Barra degli strumenti di esecuzione e navigazione. Vedi Utilizzare i punti di interruzione.
2. Selettore di thread
3. Valutazione e inserimento dell'espressione di visualizzazione. Vedi Ispezionare le variabili.
4. Visualizzazione a pila
5. Riquadro Variabili. Vedi Ispezionare le variabili.

Nota:il debugger e il garbage collector di Android Studio sono integrati in modo lasco. La macchina virtuale Android garantisce che nessun oggetto di cui il debugger è a conoscenza venga sottoposto a garbage collection fino a quando il debugger non si disconnette. Ciò può comportare un accumulo di oggetti mentre il debugger è connesso. Ad esempio, se il debugger rileva un thread in esecuzione, l'oggetto Thread associato non viene sottoposto a garbage collection finché il debugger non si disconnette, anche se il thread è terminato.

Modificare il tipo di debugger

Poiché sono necessari strumenti di debug diversi per eseguire il debug del codice Java/Kotlin e del codice C/C++, 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 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 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 sottoponendo a debug. Ad esempio, se nel tuo progetto è presente codice C o C++, Android Studio utilizza automaticamente il tipo di debug doppio. In caso contrario, 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 tutti i punti di interruzione o le espressioni di controllo impostate nel codice nativo.

Solo nativi (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 di debug Java non è disponibile. Per impostazione predefinita, LLDB ispeziona solo il codice nativo e ignora i punti di interruzione nel codice Java. Se vuoi eseguire il debug anche del codice Java, passa al tipo di debug Rileva automaticamente o Doppio.

Il debug nativo funziona solo sui dispositivi che soddisfano i seguenti requisiti:

• Il dispositivo supporta run-as.

  Per verificare se il dispositivo supporta run-as, esegui il seguente comando nella shell ADB connessa al dispositivo:

  run-as your-package-name pwd
  

  Sostituisci your-package-name con il nome del pacchetto della tua app. Se il dispositivo supporta run-as, il comando deve essere restituito senza errori.

• Sul dispositivo è attivo ptrace.

  Per verificare se ptrace è abilitato, esegui il seguente comando nella shell ADB connessa al tuo dispositivo:

  sysctl kernel.yama.ptrace_scope
  

  Se ptrace è abilitato, il comando stamperà il valore 0 o un errore unknown key. Se ptrace non è abilitato, verrà stampato un valore diverso da 0.

Doppio (Java + nativo) - disponibile solo con codice C/C++

Seleziona questo tipo di debug se vuoi passare dal debug del codice Java a quello nativo e viceversa. Android Studio collega sia il debugger Java che LLDB al processo dell'app, in modo da poter esaminare i punti di interruzione sia nel codice Java che in quello nativo senza riavviare l'app o modificare la configurazione di debug.

Nella figura 2, nota le due schede a destra del titolo della finestra Debug. Poiché l'app contiene codice Java e C++, una scheda è per il debug del codice nativo e l'altra per il debug del codice Java, come indicato da -java.

Nota:durante il debug del 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. Ciò può causare la segnalazione di informazioni impreviste o errate da parte del debugger, perché è difficile per il debugger mappare il codice compilato ottimizzato al codice sorgente originale. Per questo motivo, devi disattivare le ottimizzazioni del compilatore durante il debug del codice nativo.

Utilizzare il log di sistema

Il log di sistema mostra i messaggi di sistema durante il debug dell'app. Questi messaggi includono informazioni dalle app in esecuzione sul dispositivo. Se vuoi utilizzare il log di sistema per eseguire il debug della tua app, assicurati che il codice scriva messaggi di log e stampi la traccia dello stack per le eccezioni mentre l'app è in fase di sviluppo.

Scrivere 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 del sistema mentre interagisci con la tua app. I messaggi di log possono anche indicare la parte dell'app che non è riuscita. Per ulteriori informazioni sulla registrazione, 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'avvio 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 la traccia 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 di log di debug e le chiamate di stampa dello stack trace dal codice quando è tutto pronto per pubblicare l'app. A questo 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 altri messaggi di sistema nella finestra 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 relative opzioni di filtro, consulta Scrivere e visualizzare i log con Logcat.

Utilizzare i punti di interruzione

Android Studio supporta i punti di interruzione che attivano 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 una riga di codice specificata. Durante 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 del metodo

Un punto di interruzione del metodo sospende l'esecuzione dell'app quando entra o esce da un metodo specifico. Durante 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 del componibile e il relativo stato per aiutarti a identificare quali modifiche potrebbero aver causato la ricomposizione.

Punto di interruzione campo

Un punto di interruzione del campo sospende l'esecuzione dell'app quando legge o scrive in un campo specifico.

Punto di interruzione per eccezione

Un punto di interruzione delle eccezioni mette in pausa l'esecuzione dell'app quando viene generata un'eccezione.

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 puoi evitare di riempire il codice con istruzioni di log.

Per aggiungere un punto di interruzione di riga:

1. Individua la riga di codice in cui vuoi mettere in pausa l'esecuzione.
2. Fai clic sul margine sinistro lungo la riga di codice o posiziona il cursore sulla riga e premi Ctrl+F8 (su macOS, Cmd+F8).
3. Se la tua app è già in esecuzione, fai clic su Collega il debugger al processo Android . Altrimenti, per iniziare il debug, fai clic su Debug .

Quando imposti un punto di interruzione, accanto alla riga 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, utilizza gli strumenti nella scheda Debugger:

• Per esaminare la struttura degli oggetti di una variabile, espandila nella visualizzazione Variabili. Se la visualizzazione Variabili non è visibile, fai clic su Impostazioni layout e assicurati che Variabili sia selezionato.

• Per passare alla riga successiva del codice senza inserire un metodo, fai clic su Passo avanti .

• Per passare alla prima riga all'interno di una chiamata al metodo, fai clic su Esegui istruzione per istruzione .

• 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 .

Se il tuo progetto utilizza codice nativo, per impostazione predefinita il tipo di debug Rileva automaticamente collega sia il debugger Java sia LLDB alla tua app come due processi separati. Puoi passare dall'ispezione dei punti di interruzione Java a quelli C/C++ senza riavviare l'app o modificare le impostazioni.

Nota:affinché Android Studio rilevi i punti di interruzione nel codice C o C++, devi utilizzare un tipo di debug che supporti LLDB, ad esempio Rileva automaticamente, Nativo o Doppio. 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, la finestra Debug si apre con una scheda o una visualizzazione della sessione di debug per ogni processo di debugger, come mostrato nella figura 6.

1. Android Studio passa alla scheda <your-module> quando il debugger LLDB rileva un punto di interruzione nel codice C/C++. Sono disponibili anche i riquadri Frame, Variabili e Espressioni di controllo, che funzionano esattamente come se stessi eseguendo il debug del codice Java.

   Anche se il riquadro Thread non è disponibile nella visualizzazione della sessione LLDB, puoi accedere ai processi dell'app utilizzando l'elenco nel riquadro Frame. Scopri di più su questi riquadri nelle sezioni su come eseguire il debug dei frame della finestra e ispezionare 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 della tua 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.

2. Android Studio passa alla scheda <your-module>-java quando il debugger Java rileva un punto di interruzione nel codice Java o Kotlin.
3. Durante il debug con LLDB, puoi utilizzare il terminale LLDB nella visualizzazione della sessione LLDB per passare opzioni della riga di comando a LLDB. Se hai determinati comandi che vuoi che LLDB esegua ogni volta che avvii il debug della tua app, subito prima o subito dopo che il debugger si collega al processo dell'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 l'app interagisce con un particolare blocco di memoria. Per saperne di più, leggi la sezione su come aggiungere punti di osservazione.

Visualizzare e configurare i punti di interruzione

Per visualizzare tutti i punti di interruzione e configurare le relative impostazioni, 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 ti consente di attivare o disattivare 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 in modo che venga disattivato all'inizio e che il sistema lo attivi dopo che è stato raggiunto un altro punto di interruzione. Puoi anche configurare se un punto di interruzione deve essere disattivato dopo essere stato raggiunto. Per impostare un punto di interruzione per qualsiasi eccezione, seleziona Punti di interruzione eccezioni nell'elenco dei punti di interruzione.

Per disattivare temporaneamente tutti i punti di interruzione, fai clic su Disattiva punti di interruzione nella finestra Debug. Fai di nuovo clic per riattivarlo.

Frame della finestra di debug

Nella finestra Debugger, il riquadro Frame ti consente di esaminare il frame dello stack che ha causato l'interruzione corrente. In questo modo puoi navigare ed esaminare il frame dello stack e ispezionare l'elenco dei thread nella tua app per Android.

Per selezionare un thread, utilizza il menu di selezione dei thread e visualizza il relativo stack frame. Fai clic sugli elementi nel frame per aprire l'origine nell'editor. Puoi anche personalizzare la presentazione del thread ed esportare il frame dello stack come descritto nella guida Esamina i frame.

Esamina le variabili

Nella finestra Debugger, il riquadro Variabili ti consente di esaminare le variabili quando il sistema arresta l'app in un punto di interruzione e tu selezioni un frame dal riquadro Frame. Il riquadro Variabili consente anche di valutare espressioni ad hoc utilizzando metodi statici e/o variabili disponibili nel frame selezionato.

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

1. Inserisci l'espressione da guardare o visualizzare
2. Fai clic su Aggiungi a Espressioni di controllo o premi Invio per valutare l'espressione una volta.

In alternativa, se l'albero degli oggetti contiene l'espressione che vuoi monitorare, puoi trascinarla in cima all'albero per aggiungerla come espressione monitorata.

Le espressioni osservate vengono aggiornate quando vengono raggiunti i punti di interruzione o quando esegui il debug del codice.

Le espressioni valutate rimarranno visualizzate nella parte superiore dell'albero degli oggetti finché non ne valuti manualmente un'altra o non esegui il codice passo passo.

Per rimuovere un'espressione osservata dall'albero degli oggetti, fai clic con il tasto destro del mouse sull'espressione e poi fai clic su Rimuovi osservazione.

Aggiungere punti di osservazione

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 l'app interagisce con un particolare blocco di memoria. Ad esempio, se imposti due puntatori a un blocco di memoria e gli assegni un punto di controllo, l'utilizzo di uno dei due puntatori per accedere a quel blocco di memoria attiva il punto di controllo.

In Android Studio, puoi creare un punto di osservazione durante l'esecuzione selezionando una variabile specifica, ma LLDB assegna il punto di osservazione solo al blocco di memoria che il sistema alloca a quella variabile, non alla variabile stessa. Questa operazione è diversa dall'aggiunta di una variabile al riquadro Espressioni di controllo, che consente di osservare il valore di una variabile, ma non 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 dealloca le relative variabili locali dalla memoria, devi riassegnare i punti di osservazione creati per queste variabili.

Per impostare un punto di osservazione, devi soddisfare i seguenti requisiti:

• Il dispositivo fisico o l'emulatore di destinazione utilizza una CPU x86 o x86_64. Se il tuo 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 a 8 byte per i processori a 64 bit. Per allineare una variabile nel codice nativo, specifica __attribute__((aligned(num_bytes))) nella dichiarazione della variabile, come mostrato di seguito:

  // For a 64-bit ARM processor
  int my_counter __attribute__((aligned(8)));

• Hai già assegnato tre o meno punti di osservazione. Android Studio supporta solo fino a quattro punti di osservazione sui dispositivi di destinazione x86 o x86_64. Altri dispositivi potrebbero supportare un numero inferiore di punti di controllo.

Nota:quando esegui il debug dell'app con ABI ARM a 32 bit, l'aggiunta di un punto di osservazione o il passaggio del mouse sopra le variabili all'interno del codice per esaminare i relativi valori potrebbe causare un arresto anomalo. Come soluzione alternativa, esegui il debug utilizzando binari ARM a 64 bit, x86 o x86_64. Questo problema verrà risolto in una release futura di Android Studio.

Se soddisfi i requisiti, puoi aggiungere un punto di osservazione nel seguente modo:

1. Mentre l'app è sospesa in un punto di interruzione, vai al riquadro Variabili nella visualizzazione della sessione LLDB.

2. Fai clic con il tasto destro del mouse su una variabile che occupa il blocco di memoria che vuoi monitorare e seleziona Aggiungi punto di osservazione.

   

3. Viene visualizzata una finestra di dialogo per configurare il punto di controllo, come mostrato nella Figura 9.

   Configura il punto di controllo con le seguenti opzioni:

   • Attivato:deseleziona questa opzione se vuoi che Android Studio ignori il punto di osservazione finché non modifichi l'impostazione. Android Studio salva il punto di interruzione in modo che tu possa accedervi in un secondo momento.
   • Sospendi:per impostazione predefinita, il sistema Android sospende il processo dell'app quando accede a un blocco di memoria assegnato a un punto di controllo. Deseleziona questa opzione se non vuoi questo comportamento. In questo modo vengono visualizzate opzioni aggiuntive che puoi utilizzare per personalizzare il comportamento quando il sistema interagisce con il punto di interruzione: Messaggio di log nella console e Rimuovi quando viene raggiunto.
   • Tipo di accesso:seleziona se l'app deve attivare il watchpoint quando tenta di Leggere o Scrivere nel blocco di memoria che il sistema alloca alla variabile. Per attivare il punto di controllo in caso di lettura o scrittura, seleziona Qualsiasi.
4. Fai clic su Fine.

Per visualizzare tutti i punti di osservazione e configurare le relative 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 punto di interruzione, fai clic su Riprendi programma nella finestra Debug per riprendere il processo dell'app. Per impostazione predefinita, se la tua app tenta di accedere a un blocco di memoria per il quale hai impostato un punto di osservazione, il sistema Android sospende il processo dell'app e viene visualizzata un'icona del punto di osservazione accanto all'ultima riga di codice eseguita dall'app, come mostrato nella figura 11.

Visualizzare e modificare il formato di visualizzazione del valore della risorsa

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. Con la scheda Variabili visualizzata e un frame selezionato, procedi nel seguente modo:

1. Nell'elenco Variabili, fai clic con il tasto destro del mouse in un punto qualsiasi di una riga di risorse per visualizzare l'elenco.
2. Nell'elenco, seleziona Visualizza come e seleziona 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:visualizza la definizione della classe.
   • toString: formato della stringa di visualizzazione.
   • Oggetto:visualizza la definizione dell'oggetto (un'istanza di una classe).
   • Array:visualizza in un formato array.
     
   • Timestamp:visualizza la data e l'ora nel seguente formato: aaaa-mm-gg hh:mm:ss.
   • Automatico:Android Studio sceglie il formato migliore in base al tipo di dati.
     
   • Binario:visualizza un valore binario utilizzando zeri e uno.
   • MeasureSpec:il valore passato dall'elemento principale all'elemento secondario selezionato. Vedi MeasureSpec.
   • Esadecimale:visualizza il valore esadecimale.
   • Primitivo:visualizza come valore numerico utilizzando un tipo di dati primitivo.
   • Numero intero:visualizza come valore numerico di tipo Integer.

Per creare un formato personalizzato:

1. Fai clic con il tasto destro del mouse sul valore della risorsa.
2. Seleziona Visualizza come.
3. Seleziona Crea.
4. Viene visualizzata la finestra di dialogo Renderer del tipo di dati Java. Segui le istruzioni riportate in Renderer dei tipi di dati Java.