Depanarea aplicației

Android Studio oferă un depanator care vă permite să faceți următoarele și multe altele:

Selectați un dispozitiv pe care să vă depanați aplicația.

Setați puncte de întrerupere în codul dvs. Java, Kotlin și C/C++.

Examinați variabile și evaluați expresii în timpul execuției.

Această pagină include instrucțiuni pentru operațiile de bază ale depanatorului. Pentru mai multă documentație, consultați, de asemenea, documentația de depanare IntelliJ IDEA.

Activați depanarea
Începeți depanarea
Adaugați debuggerul la o aplicație în curs de execuție
Schimbarea tipului de depanator
Utilizați jurnalul de sistem
Scrieți mesaje de jurnal în codul dumneavoastră
Vezi jurnalul sistemului
Lucrați cu puncte de întrerupere
Vizualizarea și configurarea punctelor de întrerupere
Rame din fereastra de depanare
Inspectați variabilele
Adăugarea de puncte de supraveghere
Vizualizați și modificați formatul de afișare a valorilor resurselor

Activați depanarea

Înainte de a începe depanarea, trebuie să vă pregătiți după cum urmează:

Activați depanarea pe dispozitivul dumneavoastră:
Dacă utilizați emulatorul, acest lucru este activat în mod implicit. Dar pentru un dispozitiv conectat, trebuie să activați depanarea în opțiunile de dezvoltare a dispozitivului.
Rulați o variantă de compilare cu depanare:
Trebuie să utilizați o variantă de compilare careinclude debuggable true în configurația de compilare. De obicei, puteți selecta pur și simplu varianta implicită „debug” care este inclusă în fiecare proiect Android Studio (chiar dacă nu este vizibilă în fișierul build.gradle). Dar dacă definiți noi tipuri de compilare carear trebui să fie depanabile, trebuie să adăugați `debuggable true` la tipul de compilare:
```
android { buildTypes { customDebugType { debuggable true ... } }}
```
Această proprietate se aplică, de asemenea, modulelor cu cod C/C++. (Proprietatea jniDebuggable nu mai este utilizată.)

Dacă aplicația dvs. depinde de un modul de bibliotecă pe care doriți, de asemenea, să îl depanați, acea bibliotecă trebuie să fie, de asemenea, împachetată cu debuggable true astfel încât să își păstreze simbolurile de depanare.Pentru a vă asigura că variantele de depanare ale proiectului dvs. de aplicație primesc varianta de depanare a unui modul de bibliotecă, asigurați-vă că publicați versiuni altele decât cele implicite ale bibliotecii dvs.

Începeți depanarea

Puteți începe o sesiune de depanare după cum urmează:

Setați câteva puncte de întrerupere în codul aplicației.
În bara de instrumente, selectați un dispozitiv pe care să depanați aplicația dumneavoastră din meniul derulant dispozitiv țintă.

Dacă nu aveți niciun dispozitiv configurat, atunci trebuie fie să conectați un dispozitiv prin USB, fie să creați un AVD pentru a utiliza emulatorul Android.
În bara de instrumente, faceți clic pe Debug .
Dacă vedeți o fereastră de dialog care vă întreabă dacă doriți să „treceți de la Run la Debug”, înseamnă că aplicația dvs. rulează deja pe dispozitiv și acesta va fi repornit pentru a începe depanarea. Dacă preferați să păstrați aceeași instanță a aplicației care rulează, faceți clic pe Cancel Debug (Anulare depanare) și, în schimb, atașați depanatorul la o aplicație care rulează.

În rest, Android Studio construiește un APK, îl semnează cu o cheie de depanare, îl instalează pe dispozitivul selectat și îl rulează. Dacă adăugați cod C și C++ la proiectul dvs., Android Studio rulează, de asemenea, depanatorul LLDB în fereastra Depanare pentru a depana codul nativ.
Dacă fereastra Debug nu este deschisă, selectați View > Tool Windows > Debug (sau faceți clic pe Debug în bara ferestrei de instrumente), apoi faceți clic pe fila Debugger, așa cum se arată în figura 1.
Figura 1. Fereastra Debugger, care arată firul curent și arborele de obiecte pentru o variabilă

Adaugați debuggerul la o aplicație în curs de execuție

Dacă aplicația dvs. este deja în curs de execuție pe dispozitiv, puteți începe depanarea fără a reporni aplicația dvs. după cum urmează:

Click Attach debugger to Android process .
În fereastra de dialog Choose Process (Alege procesul), selectați procesul la care doriți să atașați depanatorul.
Dacă utilizați un emulator sau un dispozitiv cu rădăcină, puteți bifa Show all processes pentru a vedea toate procesele.

Din meniul derulant Use Android Debugger Settings from, puteți selecta o configurație de execuție/depanare existentă. (Pentru codul C și C++, acest lucru vă permite să refolosiți comenzile de pornire LLDB, comenzile de post-atacare LLDB și directoarele de simboluri dintr-o configurație existentă). Dacă nu aveți o configurație de execuție/depanare existentă, selectați Create New (Creați una nouă). Această selecție activează meniul derulant Debug Type (Tip de depanare), unde puteți selecta un alt tip de depanare. În mod implicit, Android Studio utilizează tipul de depanare Auto pentru a selecta cea mai bună opțiune de depanare pentru dumneavoastră, în funcție de faptul că proiectul dumneavoastră include cod Java sau C/C++.
Clic pe OK.
Apare fereastra Debug (Depanare).

Notă: Depanatorul Android Studio și colectorul de gunoi sunt slab integrate. Mașina virtuală Android garantează că orice obiect de care debuggerul are cunoștință nu este colectat la gunoi până după ce debuggerul se deconectează. Acest lucru poate duce la o acumulare de obiecte în timp, în timp ce depanatorul este conectat. De exemplu, dacă depanatorul vede un fir de execuție, obiectul Thread asociat nu este colectat la gunoi până când depanatorul se deconectează, chiar dacă firul s-a încheiat.

Schimbarea tipului de depanator

Pentru că sunt necesare instrumente de depanare diferite pentru depanarea codului Java/Kotlin și a codului C/C++, depanatorulAndroid Studio vă permite să selectați ce tip de depanator să utilizați. În mod implicit, Android Studiodecide ce depanator să utilizeze pe baza limbajelor pe care le detectează în proiectul dumneavoastră (cu tipul de depanareAuto). Cu toate acestea, puteți selecta manual depanatorul în configurația de depanare (faceți clic pe Run > EditConfigurations) sau în fereastra de dialog care apare atunci când faceți clic pe Run > Attach debugger to Androidprocess.

Tipurile de depanare disponibile includ următoarele:

Auto Selectați acest tip de depanare dacă doriți ca Android Studio să aleagă automat cea mai bună opțiune pentru codul pe care îl depanați. De exemplu, dacă aveți cod C sau C++ în proiectul dvs., Android Studio utilizează automat tipul de depanare Dual. În caz contrar, Android Studio utilizează tipul de depanare Java. Java Selectați acest tip de depanare dacă doriți să depanați numai codul scris în Java sau Kotlin – depanatorul Java ignoră orice puncte de întrerupere sau ceasuri pe care le-ați setat în codul nativ. Native (disponibil numai cu cod C/C++) Selectați acest tip de depanare dacă doriți să utilizați numai LLDB pentru a vă depana codul. Atunci când utilizați acest tip de depanare, vizualizarea sesiunii de depanare Java nu este disponibilă. În mod implicit, LLDB inspectează numai codul dvs. nativ și ignoră punctele de întrerupere din codul Java. Dacă doriți să vă depanați și codul Java, trebuie să treceți la tipul de depanare Auto sau Dual.

Depanarea nativă funcționează numai pe dispozitivele care îndeplinesc următoarele cerințe:

Dispozitivul suportă run-as.

Pentru a verifica dacă dispozitivul suportă run-as, rulați următoarea comandă pe shell-ul ADB care este conectat la dispozitivul dumneavoastră:
```
run-as your-package-name pwd
```
Înlocuiți your-package-name cu numele pachetului aplicației dumneavoastră. Dacă dispozitivul acceptă run-as, comanda ar trebui să se întoarcă fără erori.
Dispozitivul are ptrace activat.

Pentru a verifica dacă ptrace este activat, rulați următoarea comandă pe shell-ul ADB care este conectat la dispozitivul dumneavoastră:
```
sysctl kernel.yama.ptrace_scope
```
Dacă ptrace este activat, comanda va imprima valoarea 0 sau o eroare unknown key. Dacă nu este activată, comanda va imprima o altă valoare decât 0.

Dual (disponibil numai cu cod C/C++) Selectați acest tip de depanare dacă doriți să comutați între depanarea atât a codului Java, cât și a codului nativ. Android Studio atașează atât depanatorul Java, cât și LLDB la procesul aplicației dumneavoastră, unul pentru depanatorul Java și unul pentru LLDB, astfel încât puteți inspecta punctele de întrerupere atât în codul Java, cât și în cel nativ, fără a reporni aplicația sau a modifica configurația de depanare.

În figura 2, observați cele două file din dreapta titlului ferestrei Debug. Deoarece aplicația are atât cod Java, cât și C++, o filă este pentru depanarea codului nativ, iar cealaltă pentru depanarea codului Java, așa cum este indicat prin -java.

Figura 2. Fila pentru depanarea codului nativ și fila pentru depanarea codului Java

Notă: Dacă depanați codul nativ care este optimizat de compilator, este posibil să primiți următorul mesaj de avertizare: This function was compiled with optimizations enabled. Some debugger features may not be available. Atunci când se utilizează stegulețe de optimizare, cum ar fi stegulețele -O, compilatorul face modificări la codul compilat pentru a-l face să ruleze mai eficient. Acest lucru poate face ca depanatorul să raporteze informații neașteptate sau incorecte, deoarece este dificil pentru depanator să mapeze codul compilat optimizat înapoi la codul sursă original. Din acest motiv, ar trebui să dezactivați optimizările compilatorului în timpul depanării codului nativ.

Utilizați jurnalul de sistem

Jurnalul de sistem afișează mesajele de sistem în timp ce vă depanați aplicația. Aceste mesaje includinformații de la aplicațiile care rulează pe dispozitiv. Dacă doriți să utilizați jurnalul de sistem pentru a vă depana aplicația, asigurați-vă că codul dumneavoastră scrie mesaje de jurnal și tipărește stacktrace-ul pentru excepții în timp ce aplicația dumneavoastră se află în faza de dezvoltare.

Scrieți mesaje de jurnal în codul dumneavoastră

Pentru a scrie mesaje de jurnal în codul dumneavoastră, utilizați clasa Log. Mesajele de jurnal vă ajută să înțelegeți fluxul de execuție prin colectarea ieșirii de depanare a sistemului în timp ce interacționați cu aplicația dumneavoastră. Mesajele de jurnal vă pot spune ce parte a aplicației dvs. a eșuat. Pentru mai multe informații despre jurnalizare, consultați Scrieți și vizualizați jurnalele.

Exemplul următor arată cum ați putea adăuga mesaje de jurnal pentru a determina dacă informațiile de stare anterioare sunt disponibile atunci când activitatea dvs. începe:

În timpul dezvoltării, codul dvs. poate, de asemenea, să prindă excepții și să scrie urmărirea stivei în jurnalul de sistem:

Nota: Îndepărtați mesajele de jurnal de depanare și apelurile de imprimare a urmăririi stivei din codul dvs. atunci când sunteți gata să vă publicați aplicația. Ați putea face acest lucru prin setarea unui DEBUGflag și plasarea mesajelor din jurnalul de depanare în interiorul instrucțiunilor condiționale.

Vezi jurnalul sistemului

Puteți vizualiza și filtra mesajele de depanare și alte mesaje de sistem în fereastra Logcat. De exemplu, puteți vedea mesajele atunci când are loc colectarea gunoiului sau mesajele pe care le adăugați la aplicația dvs. cu clasa Log.

Pentru a utiliza logcat, începeți depanarea și selectați fila Logcat din bara de instrumente de jos, așa cum se arată în figura 3.

Figura 3. Fereastra Logcat cu setările de filtrare

Pentru o descriere a logcat și a opțiunilor sale de filtrare, consultați Scrieți și vizualizați jurnalele cu Logcat.

Lucrați cu puncte de întrerupere

Android Studio acceptă mai multe tipuri de puncte de întrerupere care declanșează diferite acțiuni de depanare. Cel mai comun tip este un punct de întrerupere a liniei care oprește execuția aplicației dvs. la o anumită linie de cod. În timpul pauzei,puteți să examinați variabilele, să evaluați expresii, apoi să continuați execuția linie cu linie pentru a determina cauzele erorilor de execuție.

Pentru a adăuga un punct de întrerupere a liniei, procedați după cum urmează:

Localizați linia de cod unde doriți să întrerupeți execuția, apoi fie faceți clic pe jgheabul din stânga de-a lungul acelei linii de cod, fie plasați semnul de atenție pe linie și apăsați Control+F8 (pe Mac, Command+F8).
Dacă aplicația dvs. este deja în execuție, nu trebuie să o actualizați pentru a adăuga punctul de întrerupere – trebuie doar să faceți clic pe Attach debugger to Android proccess . În caz contrar, începeți depanarea făcând clic pe Debug .

Figură 3. Un punct roșu apare lângă linie atunci când setați un punct de întrerupere

Când execuția codului dvs. ajunge la punctul de întrerupere,Android Studio întrerupe execuția aplicației dvs. Puteți utiliza apoi instrumentele din fila Debugger pentru a identifica starea aplicației:

Pentru a examina arborele de obiecte pentru o variabilă, extindeți-o în vizualizarea Variables. Dacă vizualizarea Variables nu este vizibilă, faceți clic pe Restore Variables View .
Pentru a evalua o expresie în punctul de execuție curent, faceți clic pe Evaluate Expression .
Pentru a trece la următoarea linie din cod (fără a introduce o metodă), faceți clic pe Step Over .
Pentru a avansa la prima linie din interiorul unui apel de metodă, faceți clic pe Step Into .
Pentru a avansa la următoarea linie din afara metodei curente, faceți clic pe Step Out .
Pentru a continua rularea normală a aplicației, faceți clic pe Resume Program .

Dacă proiectul dvs. utilizează cod nativ, în mod implicit, tipul de depanare Auto atașează atât depanatorul Java, cât și LLDB la aplicația dvs. ca două procese separate, astfel încât puteți comuta între inspectarea punctelor de întrerupere Java și C/C++ fără a reporni aplicația sau a schimba setările.

Notă: Pentru ca Android Studio să detecteze punctele de întrerupere în codul C sau C++, trebuie să utilizați un tip de depanare care acceptă LLDB, cum ar fi Auto, Native sau Dual. Puteți schimba tipul de depanare pe care îl utilizează Android Studio prin editarea configurației de depanare. Pentru a afla mai multe despre diferitele tipuri de depanare, citiți secțiunea despre utilizarea altor tipuri de depanare.

Când Android Studio implementează aplicația dvs. pe dispozitivul țintă, fereastra Debug se deschide cu o filă sau o vizualizare a sesiunii de depanare pentru fiecare proces de depanare, așa cum se arată în figura 4.

Figura 4. Depanarea codului nativ utilizând LLDB

Android Studio trece la fila <your-module> atunci când debuggerul LLDB întâlnește un punct de întrerupere în codul dumneavoastră C/C++. Panourile Frames, Variables și Watches sunt, de asemenea, disponibile și funcționează exact așa cum ar funcționa dacă ați depana codul Java. Deși panoul Threads (fire de execuție) nu este disponibil în vizualizarea sesiunii LLDB, puteți accesa procesele aplicației dvs. utilizând lista derulantă din panoul Frames (cadre). Puteți afla mai multe despre aceste panouri în secțiunile despre cum să depanați cadrele ferestrelor și cum să inspectați variabilele.
Notă: În timp ce inspectați un punct de întrerupere în codul dvs. nativ, sistemul Android suspendă mașina virtuală care execută bytecodul Java al aplicației dvs. Acest lucru înseamnă că nu puteți interacționa cu depanatorul Java sau să preluați informații de stare din sesiunea de depanare Java în timp ce inspectați un punct de întrerupere în codul nativ.
Android Studio trece la fila <modulul tău>-java atunci când depanatorul Java întâlnește un punct de întrerupere în codul tău Java.

În timpul depanării cu LLDB, puteți utiliza terminalul LLDB în vizualizarea sesiunii LLDB pentru a transmite opțiuni de linie de comandă către LLDB. Dacă aveți anumite comenzi pe care doriți ca LLDB să le execute de fiecare dată când începeți să vă depanați aplicația, fie chiar înainte, fie chiar după ce depanatorul se atașează la procesul aplicației dumneavoastră, puteți adăuga aceste comenzi la configurația de depanare.

În timpul depanării codului C/C++, puteți seta, de asemenea, tipuri speciale de puncte de întrerupere, numite watchpoints, care pot suspenda procesul aplicației dvs. atunci când aplicația dvs. interacționează cu un anumit bloc de memorie. Pentru a afla mai multe, citiți secțiunea despre cum să adăugați puncte de supraveghere.

Vizualizarea și configurarea punctelor de întrerupere

Pentru a vizualiza toate punctele de întrerupere și a configura setările punctelor de întrerupere, faceți clic pe View Breakpoints în partea stângă a ferestrei Debug. Apare fereastra Breakpoints (Puncte de întrerupere), așa cum se arată în figura 5.

Figura 5. Fereastra Breakpoints listează toate punctele de întrerupere curente și include setările de comportament pentru fiecare

Fereastra Breakpoints vă permite să activați sau să dezactivați fiecare punct de întrerupere din lista din stânga. Dacă un punct de întrerupere este dezactivat, Android Studio nu pune în pauză aplicația dvs. atunci când atinge acel punct de întrerupere. Selectați un punct de întrerupere din listă pentru a configura setările acestuia. Puteți configura un punct de întrerupere pentru a fi dezactivat la început și pentru ca sistemul să îl activeze după ce este atins un alt punct de întrerupere. De asemenea, puteți configura dacă un punct de întrerupere trebuie să fie dezactivat după ce este atins. Pentru a seta un punct de întrerupere pentru orice excepție, selectați Puncte de întrerupere pentru excepții în lista punctelor de întrerupere.

Rame din fereastra de depanare

În fereastra Debugger, panoul Rame vă permite să inspectați rama de stivă care a determinat atingerea punctului de întrerupere curent. Acest lucru vă permite să navigați și să examinați cadrul de stivă și, de asemenea, să inspectați lista de fire de execuție din aplicația Android. Pentru a selecta un fir, utilizați meniul derulant de selectare a firului și vizualizați cadrul de stivă al acestuia. Dacă faceți clic pe elementele din cadru, deschideți sursa în editor. De asemenea, puteți personaliza prezentarea firelor și puteți exporta cadrul stivei, așa cum se discută în ghidul Window Frames.

Inspectați variabilele

În fereastra Debugger, panoul Variables vă permite să inspectați variabilele atunci când sistemul vă oprește aplicația pe un punct de întrerupere și selectați un cadru din panoul Frames. Panoul Variables vă permite, de asemenea, să evaluați expresii ad-hoc utilizând metode și/sau variabile statice disponibile în cadrul cadrului selectat.

Panoul Watches oferă o funcționalitate similară, cu excepția faptului că expresiile adăugate în panoul Watches persistă între sesiunile de depanare. Ar trebui să adăugați ceasuri pentru variabilele și câmpurile pe care le accesați frecvent sau care furnizează o stare care este utilă pentru sesiunea de depanare curentă. Panourile Variables și Watches apar așa cum se arată în figura 5.

Pentru a adăuga o variabilă sau o expresie la lista Watches, urmați acești pași:

Începeți depanarea.
În panoul Watches, faceți clic pe Add .
În caseta de text care apare, tastați numele variabilei sau expresiei pe care doriți să o supravegheați și apoi apăsați Enter.

Pentru a elimina un element din lista Watches, selectați elementul respectiv și apoi faceți clic pe Remove .

Puteți reordona elementele din lista Watches selectând un element și apoi făcând clic pe Up sau Down . Panourile Variables și Watches din fereastra Debugger

Adăugarea de puncte de supraveghere

În timpul depanării codului C/C++, puteți seta tipuri speciale de puncte de întrerupere, numite watchpoints, care pot suspenda procesul aplicației dvs. atunci când aplicația dvs. interacționează cu un anumit bloc de memorie. De exemplu, dacă setați doi pointeri la un bloc de memorie și îi atribuiți un punct de supraveghere, utilizarea oricăruia dintre pointeri pentru a accesa acel bloc de memorie declanșează punctul de supraveghere.

În Android Studio, puteți crea un punct de supraveghere în timpul execuției prin selectarea unei variabile specifice, dar LLDB atribuie punctul de supraveghere doar blocului de memorie pe care sistemul îl alocă acelei variabile, nu variabilei în sine. Acest lucru este diferit de adăugarea unei variabile în panoul Watches, care vă permite să observați valoarea unei variabile, dar nu vă permite să suspendați procesul aplicației dvs. atunci când sistemul citește sau modifică valoarea acesteia în memorie.

Notă: Atunci când procesul dvs. de aplicație iese dintr-o funcție și sistemul dezalocă variabilele sale locale din memorie, trebuie să realocați orice puncte de supraveghere pe care le-ați creat pentru acele variabile.

Pentru a seta un punct de supraveghere, trebuie să îndepliniți următoarele cerințe:

Dispozitivul fizic țintă sau emulatorul dvs. utilizează un procesor x86 sau x86_64. Dacă dispozitivul dvs. utilizează un procesor ARM, atunci trebuie să aliniați limita adresei variabilei dvs. în memorie fie la 4 octeți pentru procesoarele pe 32 de biți, fie la 8 octeți pentru procesoarele pe 64 de biți. Puteți alinia o variabilă în codul dvs. nativ prin specificarea __attribute__((aligned(num_bytes))) în decelerația variabilei, așa cum se arată mai jos:
```
// For a 64-bit ARM processorint my_counter __attribute__((aligned(8)));
```
Ați alocat deja trei sau mai puține puncte de supraveghere. Android Studio acceptă numai până la patru puncte de supraveghere pe dispozitivele țintă x86 sau x86_64. Alte dispozitive pot suporta mai puține puncte de supraveghere.

Notă: La depanarea aplicației dvs. cu ABI-uri ARM pe 32 de biți, adăugarea unui watchpoint sau trecerea peste variabilele din interiorul codului pentru a investiga valorile acestora poate provoca o blocare. Ca o soluție de rezolvare, vă rugăm să depanați folosind binare ARM pe 64 de biți, x86 sau x86_64. Această problemă va fi rezolvată într-o versiune viitoare a Android Studio.

Dacă îndepliniți cerințele de mai sus, puteți adăuga un watchpoint după cum urmează:

În timp ce aplicația dvs. este suspendată pe un breakpoint, navigați în panoul Variables din vizualizarea sesiunii LLDB.
Faceți clic dreapta pe o variabilă care ocupă blocul de memorie pe care doriți să îl urmăriți și selectați Add Watchpoint. Apare o fereastră de dialog pentru a configura punctul de supraveghere, așa cum se arată în figura 7.

Figura 7. Adăugarea unui watchpoint la o variabilă din memorie
Configurați watchpoint-ul cu următoarele opțiuni:

Suspend: În mod implicit, sistemul Android suspendă procesul aplicației dvs. atunci când acesta accesează un bloc de memorie pe care îl atribuiți unui watchpoint. Puteți deselecta această opțiune dacă nu doriți acest comportament – acest lucru dezvăluie opțiuni suplimentare pe care le puteți utiliza pentru a personaliza comportamentul atunci când sistemul interacționează cu punctul dumneavoastră de supraveghere: Log message to console și Remove when hit. Tip acces: Selectați dacă aplicația dvs. ar trebui să declanșeze punctul dvs. de supraveghere atunci când încearcă să citească sau să scrie în blocul de memorie pe care sistemul îl alocă variabilei. Pentru a vă declanșa punctul de supraveghere la citire sau la scriere, selectați Any (Orice). Click Done (Efectuat).

Pentru a vizualiza toate punctele de supraveghere și pentru a configura setările punctelor de supraveghere, faceți clic pe View Breakpoints în partea stângă a ferestrei Debug. Apare fereastra de dialog Breakpoints (Puncte de întrerupere), așa cum se arată în figura 8.

Figura 8. Caseta de dialog Breakpoints listează punctele de supraveghere actuale și include setările de comportament pentru fiecare

După ce ați adăugat punctul de supraveghere, faceți clic pe Resume Program din partea stângă a ferestrei Debug pentru a relua procesul aplicației. În mod implicit, dacă aplicația dvs. încearcă să acceseze un bloc de memorie pentru care ați setat un watchpoint, sistemul Android suspendă procesul aplicației dvs. și apare o pictogramă de watchpoint în dreptul liniei de cod pe care aplicația dvs. a executat-o ultima dată, așa cum se arată în figura 9.

Figura 9. Android Studio indică linia de cod pe care aplicația dvs. o execută chiar înainte de declanșarea unui watchpoint

Vizualizați și modificați formatul de afișare a valorilor resurselor

În modul de depanare, puteți vizualiza valorile resurselor și puteți selecta un format de afișare diferit pentru variabilele din codul Java. Cu fila Variables (Variabile) afișată și un cadru selectat, efectuați următoarele:

În lista Variables (Variabile), faceți clic cu butonul drept al mouse-ului oriunde pe o linie de resursă pentru a afișa lista derulantă.
În lista derulantă, selectați View as (Vizualizare ca) și selectați formatul pe care doriți să îl utilizați.
Foratele disponibile depind de tipul de date al resursei pe care l-ați selectat. Este posibil să vedeți una sau mai multe dintre următoarele opțiuni:
- Clasa: Afișează definiția clasei.
- toString: Afișează formatul de șir de caractere.

Array: Afișează în format array.
Timestamp: Afișează data și ora după cum urmează: yyyy-mm-dd hh:mm:ss.

Auto: Android Studio alege cel mai bun format pe baza tipului de date.
Binary: Afișează o valoare binară folosind zerouri și unu.

MeasureSpec: Valoarea transmisă de la părintele la copilul selectat. A se vedea MeasureSpec. Hex: Afișare ca o valoare hexazecimală. Primitive: Afișare ca valoare numerică folosind un tip de date primitiv. Integer: Afișează o valoare numerică de tip Integer.

Puteți crea un format personalizat (randare tip de date), după cum urmează:

Free Press