Debug dell'app

Android Studio offre un debugger che consente di eseguire le seguenti operazioni e altro ancora:

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

Attiva il debug

Prima di iniziare il debug:

Attiva il debug sul tuo dispositivo.
Se utilizzi l'emulatore, il debug è abilitato per impostazione predefinita. Tuttavia, nel caso di un dispositivo connesso, devi attivare il debug nelle opzioni sviluppatore del dispositivo.
Esegui una variante di build di cui è possibile eseguire il debug.

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

In genere, puoi selezionare la variante di "debug" predefinita inclusa in ogni progetto Android Studio, anche se non è visibile nel file build.gradle. Tuttavia, se definisci nuovi tipi di build di cui è possibile eseguire il debug, devi aggiungere debuggable true al tipo di build:

trendy

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 di cui vuoi eseguire il debug, la libreria deve essere pacchettizzata anche con debuggable true in modo da conservare i simboli di debug. Per assicurarti 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 della libreria, pubblica le versioni non predefinite della libreria.

Avvia debug

Puoi avviare una sessione di debug nel seguente modo:

  1. Imposta i punti di interruzione nel codice dell'app.
  2. Nella barra degli strumenti, seleziona un dispositivo su cui eseguire il debug della tua app dal menu del dispositivo di destinazione.
    Menu del dispositivo di destinazione.
    Figura 1. Menu del dispositivo target.

    Se non hai configurato alcun dispositivo, devi connettere un dispositivo tramite USB, connettere un dispositivo tramite Wi-Fi oppure creare un AVD per utilizzare l'emulatore Android.

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

    Se la tua app è già in esecuzione sul dispositivo, viene visualizzata una finestra di dialogo che ti chiede se vuoi passare da Esegui a Debug. Il dispositivo dovrà essere riavviato per poter iniziare il debug. 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 della finestra degli strumenti.

Collega il debugger a un'app in esecuzione

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

  1. Fai clic su Allega 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 rooted, puoi selezionare Mostra tutti i processi per vedere tutti i processi. Su un dispositivo rooted vengono visualizzati tutti i processi in esecuzione sul dispositivo. Tuttavia, su un dispositivo non rooted verranno visualizzati solo i processi di cui è possibile eseguire il debug.
    2. Dal menu Usa le impostazioni di Android Debugger da, puoi selezionare una configurazione di esecuzione/debug esistente. Per il codice C e C++, questa opzione consente di riutilizzare i comandi di avvio 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 debugger migliore in base al fatto che il progetto includa codice Java o C/C++.
  3. Fai clic su Ok.

    Viene visualizzata la finestra Debug.

Anche la scheda Processi in Esplora dispositivi (Visualizza > Finestre degli strumenti > Esplora dispositivo) contiene un elenco dei processi di cui è possibile eseguire il debug. Da qui puoi selezionare un processo ed eseguire un'interruzione , forzare l'interruzione o collegare il debugger a un determinato processo .

Finestra di debug

Figura 2.Finestra Debug.

La finestra di debug è suddivisa

  1. Barra degli strumenti di esecuzione e navigazione Consulta Utilizzare i punti di interruzione
  2. Selettore thread
  3. Voce valutazione ed espressione di controllo. Consulta Esaminare le variabili.
  4. Visualizzazione stack
  5. Variabili. Consulta Esaminare le variabili.

Nota: il debugger e il garbage collector di Android Studio sono integrati in modo flessibile. La macchina virtuale Android garantisce che qualsiasi oggetto di cui il debugger è a conoscenza non venga garbage collection finché il debugger non si disconnette. Questo può causare l'accumulo di oggetti quando il debugger è connesso. Ad esempio, se il debugger rileva un thread in esecuzione, l'oggetto Thread associato non viene incluso nella garbage collection finché il debugger non si disconnette, anche se il thread è stato terminato.

Modifica del tipo di debugger

Poiché sono necessari diversi strumenti di debug 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 mediante 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 che viene visualizzata quando fai clic su Esegui > Allega 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 di cui stai eseguendo il debug. Ad esempio, se il tuo progetto include 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 di codice scritto in Java o Kotlin. Il debugger solo Java ignora eventuali punti di interruzione o smartwatch impostati 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 del debugger Java non è disponibile. Per impostazione predefinita, LLDB controlla 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 Rileva automaticamente o Debug 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 questo comando sulla shell ADB connessa al dispositivo:

    run-as your-package-name pwd
    

    Sostituisci your-package-name con il nome del pacchetto dell'app. Se il dispositivo supporta run-as, il comando dovrebbe restituire senza errori.

  • Sul dispositivo è attivo ptrace.

    Per verificare se ptrace è abilitato, esegui questo comando sulla shell ADB connessa al tuo dispositivo:

    sysctl kernel.yama.ptrace_scope
    

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

Doppia (Java + nativa): disponibile solo con codice C/C++
Seleziona questo tipo di debug se vuoi passare dal debug del codice Java a quello nativo. Android Studio collega sia il debugger Java sia il linguaggio LLDB al processo dell'app, in modo che tu possa ispezionare i punti di interruzione sia nel codice Java che nel codice nativo senza riavviare l'app o modificare la configurazione di debug.

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

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

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. In questo modo il debugger può segnalare informazioni impreviste o errate perché è 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 i messaggi di sistema mentre esegui il debug della tua app. Questi messaggi includono informazioni provenienti da 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 la traccia dello stack per rilevare 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 consentono di 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 quale parte dell'app non è riuscita. 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 sono disponibili informazioni sullo stato precedente 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 le 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 dal codice i messaggi di log di debug e le chiamate di stampa dell'analisi dello stack quando vuoi pubblicare l'app. Per farlo, imposta un flag DEBUG e inserisci i messaggi di log di debug all'interno delle istruzioni condizionali.

Visualizzare il log di sistema

Puoi visualizzare e filtrare il debug e gli altri messaggi di sistema nella finestra Logcat, come mostrato nella Figura 4. Ad esempio, puoi visualizzare i messaggi quando viene eseguita 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.

Figura 4. Finestra logcat con le impostazioni di filtro.

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 i punti di interruzione che attivano diverse azioni di debug. Esistono diversi tipi di punti di interruzione:

Punto di interruzione di 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. Quando sei in pausa, puoi esaminare le variabili, valutare le espressioni e quindi 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 mette in pausa l'esecuzione della tua app quando entra in o esce da un metodo specifico. Quando sei in pausa, puoi esaminare le variabili, valutare le espressioni e quindi 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 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 di eccezione 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 del logging che scrivono in Logcat senza sospendere l'esecuzione. In questo modo puoi evitare di sprecare il codice con istruzioni di log.

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

  1. Individua la riga di codice in cui vuoi mettere in pausa l'esecuzione.
  2. Fai clic sul bordo sinistro lungo la riga di codice oppure posiziona il cursore sulla riga e premi Ctrl+F8 (su macOS, Comando+F8).
  3. Se l'app è già in esecuzione, fai clic su Allega il debugger al processo Android . In caso contrario, per avviare il debug, fai clic su Debug .

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

Figura 5. Quando imposti un punto di interruzione viene visualizzato un punto rosso accanto alla riga.

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 ad albero degli oggetti per una variabile, espandila nella visualizzazione Variabili. Se la visualizzazione Variabili non è visibile, fai clic su Impostazioni layout e assicurati che le variabili siano selezionate.

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

  • Per passare alla prima riga all'interno di una chiamata al metodo, fai clic su Passaggio in .

  • Per passare alla riga successiva al di fuori del metodo attuale, fai clic su Esci .

  • Per continuare a eseguire l'app normalmente, fai clic su Riprendi programma .

Se il progetto utilizza un 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 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 usare un tipo di debug che supporti LLDB, ad esempio Rileva automaticamente, Nativo o Doppio. Puoi cambiare il tipo di debug utilizzato da Android Studio modificando la configurazione del 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 Debug con una scheda o una visualizzazione della sessione di debug per ogni processo del debugger, come mostrato nella figura 6.

Figura 6. Debug del codice nativo utilizzando LLDB.
  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 Smartwatch, 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 delle finestre e 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 alcuna informazione sullo stato dalla sessione del debugger Java, mentre ispezioni un punto di interruzione nel codice nativo.

  2. Android Studio passa alla scheda <your-module>-java quando il debugger Java riscontra 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 le opzioni della riga di comando a LLDB. Se vuoi che LLDB esegua alcuni comandi ogni volta che inizi a eseguire il debug dell'app, immediatamente prima o subito dopo che il debugger si collega al processo dell'app, puoi aggiungerli alla configurazione di debug.

Durante il debug del codice C/C++, puoi anche impostare tipi speciali di punti di interruzione, denominati punti di controllo, che possono sospendere il processo dell'app quando l'app interagisce con un determinato blocco di memoria. Per scoprire di più, leggi la sezione su come aggiungere punti di controllo.

Visualizza e configura 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.

Figura 7. La finestra Punti di interruzione elenca tutti i punti di interruzione correnti e include le impostazioni di comportamento per ciascuno.

La finestra Punti di interruzione consente di abilitare o disabilitare ciascun punto di interruzione dall'elenco nel riquadro. Se un punto di interruzione è disattivato, Android Studio non mette in pausa la tua 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 disabilitato inizialmente e che il sistema lo abiliti dopo l'individuazione 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 disattivare temporaneamente tutti i punti di interruzione, fai clic su Disattiva punti di interruzione nella finestra Debug. Fai di nuovo clic per riattivarlo.

Debug dei frame delle finestre

Nella finestra Debugger, il riquadro Frame consente di esaminare lo stack frame che ha causato l'hit del punto di interruzione attuale. In questo modo puoi esplorare ed esaminare lo stack frame, nonché controllare l'elenco dei thread nella tua app per Android.

Per selezionare un thread, utilizza il menu del selettore dei thread e visualizza lo stack frame. Fai clic sugli elementi nel frame per aprire il codice sorgente nell'editor. Puoi anche personalizzare la presentazione in thread ed esportare lo stack frame come descritto nella guida Esamina frame.

Ispeziona variabili

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

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

Figura 8. La struttura ad albero degli oggetti e la casella di immissione dell'espressione nella finestra Debug.
  1. Inserisci l'espressione da controllare o visualizzare
  2. Fai clic su Aggiungi a smartwatch o premi Invio per valutare l'espressione una volta.

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

Le espressioni osservate vengono aggiornate quando vengono raggiunti i punti di interruzione o quando si esegue una scansione del codice.

Le espressioni valutate rimarranno visualizzate nella parte superiore della struttura ad albero degli oggetti finché non valuti manualmente un'altra espressione o passaggi nel codice.

Per rimuovere un'espressione guardata dalla struttura ad albero degli oggetti, fai clic con il tasto destro del mouse sull'espressione, quindi fai clic su Rimuovi smartwatch.

Aggiungi punti di controllo

Durante il debug del codice C/C++, puoi impostare tipi speciali di punti di interruzione, chiamati punti di controllo, che possono sospendere il processo dell'app quando l'app interagisce con un determinato blocco di memoria. Ad esempio, se imposti due puntatori su un blocco di memoria e gli assegni un watchpoint, l'uso di entrambi i 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 assegna a questa variabile, non alla variabile stessa. Questa è diversa dall'aggiunta di una variabile al riquadro Smartwatch, che ti 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 distribuisce le sue variabili locali dalla memoria, devi riassegnare gli eventuali watchpoint che hai creato per queste variabili.

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

  • L'emulatore o il dispositivo 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 a 8 byte per i processori a 64 bit. Per allineare una variabile nel tuo 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 al massimo tre punti di controllo. Android Studio supporta fino a quattro watchpoint su dispositivi di destinazione x86 o x86_64. Altri dispositivi potrebbero supportare meno watchpoint.

Nota: durante il debug dell'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 esaminarne i valori potrebbe causare un arresto anomalo. Come soluzione alternativa, esegui il debug utilizzando programmi binari ARM, x86 o x86_64 a 64 bit. Questo problema verrà risolto in una release futura di Android Studio.

Se soddisfi i requisiti, puoi aggiungere un punto di controllo come segue:

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

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

    Configura il tuo punto di controllo 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 che assegni a un punto di controllo. Deseleziona questa opzione se non vuoi che questo comportamento si verifichi. Vengono visualizzate opzioni aggiuntive che puoi utilizzare per personalizzare il comportamento quando il sistema interagisce con il tuo punto di controllo: Registra messaggio nella console e Rimuovi quando viene premuto.
    • Tipo di accesso: scegli se l'app deve attivare il punto di controllo quando tenta di attivare la funzione Lettura o Scrittura per il blocco di memoria che il sistema assegna alla variabile. Per attivare il punto di controllo in una lettura o in scrittura, seleziona Qualsiasi.
  4. Fai clic su Fine.

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

Figura 10. La finestra di dialogo Punti di interruzione elenca i tuoi punti di controllo attuali e include le impostazioni del comportamento per ciascuno.

Dopo aver aggiunto il punto di monitoraggio, 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 a cui hai impostato un watchpoint, il sistema Android sospende il processo dell'app e viene visualizzata un'icona del punto di controllo accanto alla riga di codice eseguita per ultima dall'app, come mostrato nella figura 11.

Figura 11. Android Studio indica la riga di codice eseguita dall'app appena prima di attivare un punto di controllo.

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:

  1. Nell'elenco Variabili, fai clic con il tasto destro del mouse in un punto qualsiasi della riga della risorsa per visualizzare l'elenco.
  2. Dall'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:

    • Corso:mostra la definizione del corso.
    • toString: mostra il formato stringa.
    • Oggetto: visualizza la definizione dell'oggetto (un'istanza di una classe).
    • Array:vengono visualizzati in un formato array.
    • Timestamp: visualizza la data e l'ora come segue: 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 1.
    • MeasureSpec: il valore trasmesso dall'elemento padre all'elemento figlio selezionato. Vedi MeasureSpec.
    • Hex:viene visualizzato come valore esadecimale.
    • Primitivi: vengono visualizzati come valore numerico utilizzando un tipo di dati primitivi.
    • Numero intero: viene visualizzato 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 dei tipi di dati Java. Segui le istruzioni per i rendering dei tipi di dati Java.