ניפוי באגים באפליקציה

ב-Android Studio יש תכונת ניפוי באגים שמאפשרת לבצע את הפעולות הבאות ועוד:

• בוחרים מכשיר שבו יתבצע ניפוי הבאגים של האפליקציה.
• הגדרת נקודות עצירה בקוד Java,‏ Kotlin ו-C/C++.
• בדיקת משתנים והערכת ביטויים בזמן הריצה.

בדף הזה מפורטות הוראות לביצוע פעולות בסיסיות של תדירת באגים. מידע נוסף זמין גם במסמכי העזרה בנושא ניפוי באגים ב-IntelliJ IDEA.

הפעלת ניפוי באגים

לפני שמתחילים לנפות באגים, צריך לבצע את הפעולות הבאות:

מפעילים את ניפוי הבאגים במכשיר.

אם אתם משתמשים במהדר, ניפוי הבאגים מופעל כברירת מחדל. אבל במכשיר מחובר, צריך להפעיל את ניפוי הבאגים באפשרויות למפתחים במכשיר.

מריצים וריאנט build שניתן לנפות בו באגים.

משתמשים בגרסת build שכוללת את debuggable true (isDebuggable = true בסקריפטים של Kotlin) בתצורת ה-build.

בדרך כלל אפשר לבחור את גרסת ברירת המחדל 'debug' שכלולה בכל פרויקט ב-Android Studio, גם אם היא לא מוצגת בקובץ build.gradle. עם זאת, אם מגדירים סוגי build חדשים שאפשר לנפות בהם באגים, צריך להוסיף את debuggable true לסוג ה-build:

Groovy

android {
    buildTypes {
        customDebugType {
            debuggable true
            ...
        }
    }
}

Kotlin

android {
    buildTypes {
        create("customDebugType") {
            isDebuggable = true
            ...
        }
    }
}

המאפיין הזה רלוונטי גם למודולים עם קוד C/C++.

הערה: לא נעשה יותר שימוש במאפיין jniDebuggable.

אם האפליקציה שלכם תלויה במודול של ספרייה שאתם רוצים לנפות באגים גם בו, צריך גם לארוז את הספרייה הזו באמצעות debuggable true כדי לשמור על סמלי ניפוי הבאגים שלה. כדי לוודא שהגרסאות שניתן לנפות באפליקציה יקבלו את הגרסה שניתן לנפות של מודול הספרייה, צריך לפרסם גרסאות שאינן ברירת המחדל של הספרייה.

התחלת ניפוי הבאגים

כדי להתחיל סשן ניפוי באגים:

1. מגדירים נקודות עצירה בקוד של האפליקציה.
2. בסרגל הכלים, בוחרים מכשיר לתיקון באגים באפליקציה בתפריט של מכשיר היעד.

   

   איור 1. תפריט של מכשיר היעד.

   אם לא הגדרתם מכשיר, תצטרכו לחבר מכשיר באמצעות USB, לחבר מכשיר באמצעות Wi-Fi או ליצור מכשיר AVD כדי להשתמש ב-Android Emulator.

3. בסרגל הכלים, לוחצים על ניפוי באגים .

   אם האפליקציה כבר פועלת במכשיר, תוצג תיבת דו-שיח עם שאלה אם רוצים לעבור מ'הפעלה' ל'ניפוי באגים'. כדי להתחיל בניפוי הבאגים, צריך להפעיל מחדש את המכשיר. כדי להמשיך להפעיל את אותה מופע של האפליקציה, לוחצים על ביטול ניפוי הבאגים ובמקום זאת מחברים את מנתח הבאגים לאפליקציה שפועלת. אחרת, Android Studio יוצרת קובץ APK, חותמת עליו באמצעות מפתח ניפוי באגים, מתקינה אותו במכשיר שבחרתם ומפעילה אותו.

   אם מוסיפים לפרויקט קוד ב-C וב-C++‎, ב-Android Studio פועל גם מתקן הבאגים LLDB בחלון ניפוי הבאגים כדי לנפות באגים בקוד המקורי.

4. אם חלון ניפוי הבאגים לא פתוח, בוחרים באפשרות View > Tool Windows > Debug (תצוגה > חלונות כלים > ניפוי באגים), או לוחצים על Debug (ניפוי באגים) בסרגל של חלון הכלים.

חיבור מנתח הבאגים לאפליקציה שפועלת

אם האפליקציה כבר פועלת במכשיר, אפשר להתחיל לנפות באגים בלי להפעיל מחדש את האפליקציה באופן הבא:

1. לוחצים על צירוף מנתח הבאגים לתהליך Android .
2. בתיבת הדו-שיח Choose Process, בוחרים את התהליך שאליו רוצים לצרף את מנתח הבאגים.
   1. אם אתם משתמשים במהדמ או במכשיר עם הרשאת root, תוכלו לסמן את התיבה Show all processes כדי לראות את כל התהליכים. במכשיר עם הרשאת root, יוצגו כל התהליכים שפועלים במכשיר. עם זאת, במכשיר ללא הרשאת root יוצגו רק תהליכים שאפשר לנפות בהם באגים.
   2. בתפריט Use Android Debugger Settings from, בוחרים הגדרת הפעלה/ניפוי באגים קיימת. בקוד C ו-C++, אפשר להשתמש שוב בפקודות ההפעלה של LLDB, בפקודות של LLDB לאחר הצירוף ובספריות הסמלים בהגדרה קיימת.
   3. אם אין לכם הגדרה קיימת של הפעלה/ניפוי באגים, בוחרים באפשרות Create New. הבחירה הזו מפעילה את התפריט Debug Type, שבו אפשר לבחור סוג ניפוי באגים אחר. כברירת מחדל, Android Studio משתמשת בסוג ניפוי הבאגים 'זיהוי אוטומטי' כדי לבחור את אפשרות ניפוי הבאגים המתאימה ביותר לכם, על סמך הקוד שכלול בפרויקט – Java או C/C++.
3. לוחצים על אישור.

   החלון Debug יופיע.

בכרטיסייה Processes (תהליכים) ב-Device Explorer (View > Tool Windows > Device Explorer) מופיעה גם רשימה של תהליכים שאפשר לנפות באגים בהם. מכאן אפשר לבחור תהליך ולבצע פעולות כמו (הפסקה), (עצירה בכוח) או (צירוף מנתח הבאגים לתהליך נתון).

חלון ניפוי הבאגים

איור 2. חלון ניפוי הבאגים.

חלון ניפוי הבאגים מחולק ל-

1. סרגל הכלים לביצוע ולניווט. מידע נוסף זמין במאמר עבודה עם נקודות עצירה
2. בורר שרשורים
3. הערכה והזנה של ביטוי שעון. בדיקת משתנים
4. תצוגת מקבץ
5. החלונית 'משתנים'. בדיקת משתנים

הערה: מנקה האשפה והכלי לניפוי באגים ב-Android Studio משולבים באופן רופף. המכונה הווירטואלית של Android מבטיחה שאף אובייקט שידוע למנטר לא ייכלל באיסוף האשפה עד שהמנטר יתנתק. כתוצאה מכך, יכול להיות שיצטברו אובייקטים בזמן שהמתקף מחובר. לדוגמה, אם מנתח הבאגים מזהה שרשרת פעילות, אובייקט Thread המשויך אליה לא ייכלל באיסוף האשפה עד שהמנתח יתנתק, גם אם השרשרת הסתיימה.

שינוי סוג הכלי לניפוי באגים

כדי לנפות באגים בקוד Java/Kotlin ובקוד C/C++ נדרשים כלים שונים לניפוי באגים, ולכן בכלי לניפוי באגים ב-Android Studio אפשר לבחור את סוג הכלי שבו רוצים להשתמש. כברירת מחדל, מערכת Android Studio מחליטה באיזה מנתח באגים להשתמש על סמך השפות שהיא מזהה בפרויקט באמצעות סוג מנתח הבאגים זיהוי אוטומטי.

כדי לבחור את מנתח הבאגים באופן ידני בהגדרת ניפוי הבאגים, לוחצים על הפעלה > עריכת ההגדרות. אפשר גם לבחור את מנתח הבאגים בתיבת הדו-שיח שמופיעה כשלוחצים על הפעלה > צירוף מנתח הבאגים לתהליך Android.

סוגי ניפוי הבאגים הזמינים כוללים את האפשרויות הבאות:

זיהוי אוטומטי

בוחרים בסוג ניפוי הבאגים הזה אם רוצים ש-Android Studio יבחר באופן אוטומטי את האפשרות הטובה ביותר לקוד שרוצים לנפות את הבאגים שלו. לדוגמה, אם יש בפרויקט קוד ב-C או ב-C++, ‏ Android Studio משתמש באופן אוטומטי בסוג ניפוי הבאגים Dual. אחרת, Android Studio משתמשת בסוג ניפוי הבאגים Java-Only.

Java בלבד

בוחרים בסוג ניפוי הבאגים הזה אם רוצים לנפות באגים רק בקוד שנכתב ב-Java או ב-Kotlin. מנתח הבאגים של Java בלבד מתעלם מנקודות עצירה או מתבניות מעקב שהגדרתם בקוד המקורי.

מותאמות בלבד (זמינות רק עם קוד C/C++)

בוחרים בסוג ניפוי הבאגים הזה אם רוצים להשתמש רק ב-LLDB כדי לנפות באגים בקוד. כשמשתמשים בסוג ניפוי הבאגים הזה, תצוגת הסשן של מנתח הבאגים של Java לא זמינה. כברירת מחדל, LLDB בודק רק את הקוד המקורי ומשבית נקודות עצירה בקוד Java. אם רוצים לנפות באגים גם בקוד Java, עוברים לסוג 'זיהוי אוטומטי' או לסוג 'ניפוי באגים כפול'.

ניפוי באגים מקורי פועל רק במכשירים שעומדים בדרישות הבאות:

• המכשיר תומך ב-run-as.

  כדי לבדוק אם המכשיר תומך ב-run-as, מריצים את הפקודה הבאה במעטפת ADB שמחובר למכשיר:

  run-as your-package-name pwd
  

  מחליפים את your-package-name בשם החבילה של האפליקציה. אם המכשיר תומך ב-run-as, הפקודה אמורה לחזור ללא שגיאות.

• התכונה ptrace מופעלת במכשיר.

  כדי לבדוק אם ptrace מופעל, מריצים את הפקודה הבאה במעטפת ADB שמחובר למכשיר:

  sysctl kernel.yama.ptrace_scope
  

  אם ptrace מופעל, הפקודה תדפיס את הערך 0 או שגיאה מסוג unknown key. אם ptrace לא מופעל, יודפס ערך אחר מלבד 0.

כפול (Java + Native) – זמין רק עם קוד C/C++‎

בוחרים בסוג ניפוי הבאגים הזה אם רוצים לעבור בין ניפוי באגים ב-Java לבין ניפוי באגים בקוד מקורי. Android Studio מחבר את מנתח הבאגים של Java וגם את LLDB לתהליך האפליקציה, כדי שתוכלו לבדוק נקודות עצירה בקוד Java ובקוד המקורי בלי להפעיל מחדש את האפליקציה או לשנות את הגדרות ניפוי הבאגים.

באיור 2, שימו לב לשתי הכרטיסיות שמשמאל לשם של חלון ניפוי הבאגים. מכיוון שהאפליקציה כוללת קוד Java וגם קוד C++‎, כרטיסייה אחת מיועדת לניפוי שגיאות בקוד המקורי והשנייה לניפוי שגיאות בקוד Java, כפי שמצוין ב--java.

איור 3. Tab לניפוי באגים בקוד נייטיב ו-Tab לניפוי באגים בקוד Java.

הערה: במהלך ניפוי באגים בקוד מקורי שעובר אופטימיזציה על ידי המהדר, עשויה להופיע הודעת האזהרה הבאה:
This function was compiled with optimizations enabled. Some debugger features may not be available. כשמשתמשים בדגלים של אופטימיזציה, המהדר מבצע שינויים בקוד המהדר כדי שהוא יפעל ביעילות רבה יותר. כתוצאה מכך, יכול להיות שמאתר הבאגים ידווח על מידע לא צפוי או שגוי, כי קשה למאתר הבאגים למפות את הקוד המהופעל המותאם לקוד המקור המקורי. לכן, מומלץ להשבית את האופטימיזציות של המהדר בזמן ניפוי הבאגים בקוד המקומי.

שימוש ביומן המערכת

ביומן המערכת מוצגות הודעות מערכת בזמן ניפוי הבאגים באפליקציה. ההודעות האלה כוללות מידע מאפליקציות שפועלות במכשיר. אם אתם רוצים להשתמש ביומן המערכת כדי לנפות באגים באפליקציה, עליכם לוודא שהקוד שלכם כותב הודעות ביומן ומדפיס את מעקב ה-stack של חריגות בזמן שהאפליקציה נמצאת בשלב הפיתוח.

כתיבת הודעות ביומן בקוד

כדי לכתוב הודעות ביומן בקוד, משתמשים בכיתה Log. הודעות ביומן עוזרות לכם להבין את תהליך הביצוע על ידי איסוף הפלט של ניפוי הבאגים במערכת בזמן האינטראקציה שלכם עם האפליקציה. הודעות ביומן יכולות גם להראות לכם איזה חלק באפליקציה נכשל. מידע נוסף על רישום ביומן זמין במאמר כתיבה וצפייה ביומני Logcat.

בדוגמה הבאה מוסבר איך מוסיפים הודעות ביומן כדי לקבוע אם פרטי המצב הקודם זמינים כשהפעילות מתחילה:

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 */
        }
        ...
    }
}

במהלך הפיתוח, הקוד יכול גם לזהות חריגות ולכתוב את מעקב הסטאק ביומן המערכת:

Kotlin

fun someOtherMethod() {
    try {
        ...
    } catch (e : SomeException) {
        Log.d(TAG, "someOtherMethod()", e)
    }
}

Java

void someOtherMethod() {
    try {
        ...
    } catch (SomeException e) {
        Log.d(TAG, "someOtherMethod()", e);
    }
}

הערה: כשתהיו מוכנים לפרסם את האפליקציה, תוכלו להסיר מהקוד את ההודעות ביומן ניפוי הבאגים ואת הקריאות להדפסת נתיב סטאק. כדי לעשות זאת, מגדירים את הדגל DEBUG וממקמים את ההודעות ביומן ניפוי הבאגים בתוך משפטי תנאי.

הצגת יומן המערכת

אפשר להציג ולסנן הודעות ניפוי באגים והודעות מערכת אחרות בחלון Logcat, כפי שמוצג באיור 4. לדוגמה, אפשר לראות הודעות כשמתרחשת איסוף אשפה או הודעות שמוסיפים לאפליקציה באמצעות הכיתה Log.

כדי להשתמש ב-Logcat, מתחילים את ניפוי הבאגים ובוחרים בכרטיסייה Logcat.

איור 4. חלון Logcat עם הגדרות מסנן.

תיאור של Logcat ואפשרויות הסינון שלו מופיע במאמר כתיבה והצגה של יומנים באמצעות Logcat.

עבודה עם נקודות עצירה

ב-Android Studio יש תמיכה בנקודות עצירה שמפעילות פעולות שונות לניפוי באגים. יש כמה סוגים של נקודות עצירה:

נקודת עצירה (breakpoint) בשורה

הסוג הנפוץ ביותר הוא נקודת עצירה בקו שמשהה את ביצוע האפליקציה בשורת קוד מסוימת. במצב מושהה, אפשר לבדוק משתנים, להעריך ביטויים ולהמשיך את ההרצה שורה אחרי שורה כדי לקבוע את הגורמים לשגיאות זמן ריצה.

נקודת עצירה (breakpoint) בשיטה

נקודת עצירה לבדיקה של שיטות משהה את ביצוע האפליקציה כשהיא נכנסת לשיטה ספציפית או יוצאת ממנה. במצב מושהה, אפשר לבדוק משתנים, להעריך ביטויים ולהמשיך את ההרצה שורה אחרי שורה כדי לקבוע את הגורמים לשגיאות זמן ריצה. כשמגדירים נקודת עצירה בפונקציה ניתנת לקישור, מנתח הבאגים מציג את הפרמטרים של הרכיב הניתן לקישור ואת המצב שלהם כדי לעזור לזהות אילו שינויים גרמו ליצירה מחדש.

נקודת עצירה בשדה

נקודת עצירה בשדה משהה את ביצוע האפליקציה כשהיא קוראת משדה ספציפי או כותבת אליו.

נקודת עצירה (breakpoint) לחריגה

נקודת עצירה לחריגה משהה את ביצוע האפליקציה כשמתרחשת חריגה.

אפשר להגדיר נקודות עצירה מותנות שיביאו להשהיית הביצוע רק אם יתקיימו תנאים ספציפיים. אפשר גם להגדיר נקודות עצירה לצורך רישום ביומן, שכותבות ב-Logcat בלי להשעות את הביצוע. כך תוכלו להימנע מהצפת הקוד בהצהרות ביומן.

כדי להוסיף נקודת עצירה בשורה, פועלים לפי השלבים הבאים:

1. מאתרים את שורת הקוד שבה רוצים להשהות את הביצוע.
2. לוחצים על פס ההפרדה הימני של שורת הקוד או ממרכזים את הסמן בשורה ומקישים על Control+F8 (ב-macOS, Command+F8).
3. אם האפליקציה כבר פועלת, לוחצים על Attach debugger to Android process (צירוף מנתח הבאגים לתהליך Android) . אחרת, כדי להתחיל בניפוי הבאגים, לוחצים על ניפוי באגים .

כשמגדירים נקודת עצירה, מופיעה נקודה אדומה לצד השורה, כפי שמוצג באיור 5.

איור 5. כשמגדירים נקודת עצירה, מופיעה נקודה אדומה לצד השורה.

כשהרצת הקוד מגיעה לנקודת העצירה, Android Studio משהה את ביצוע האפליקציה.

כדי לזהות את המצב של האפליקציה, משתמשים בכלים בכרטיסייה Debugger:

• כדי לבדוק את עץ האובייקטים של משתנה, מרחיבים אותו בתצוגת המשתנים. אם התצוגה Variables (משתנים) לא מוצגת, לוחצים על Layout Settings (הגדרות פריסה) ומוודאים שהאפשרות variables (משתנים) מסומנת.

• כדי לעבור לשורה הבאה בקוד בלי להזין שיטה, לוחצים על Step Over .

• כדי לעבור לשורה הראשונה בקריאה ל-method, לוחצים על Step into .

• כדי לעבור לשורה הבאה מחוץ לשיטה הנוכחית, לוחצים על Step out .

• כדי להמשיך להפעיל את האפליקציה באופן רגיל, לוחצים על המשך התוכנית .

אם בפרויקט שלכם נעשה שימוש בקוד מקורי, כברירת מחדל, סוג ניפוי הבאגים 'זיהוי אוטומטי' מחבר את תכונת ניפוי הבאגים של Java ואת LLDB לאפליקציה כשני תהליכים נפרדים. אפשר לעבור בין בדיקת נקודות עצירה ב-Java לבין בדיקת נקודות עצירה ב-C/C++ בלי להפעיל מחדש את האפליקציה או לשנות את ההגדרות.

הערה: כדי ש-Android Studio יזהה נקודות עצירה בקוד C או C++, צריך להשתמש בסוג ניפוי באגים שתומך ב-LLDB, כמו 'זיהוי אוטומטי', 'מקורי' או 'דו-כיווני'. אתם יכולים לשנות את סוג ניפוי הבאגים שבו Android Studio משתמש על ידי עריכת הגדרות ניפוי הבאגים. למידע נוסף על סוגי ניפוי הבאגים השונים, אפשר לקרוא את הקטע בנושא שימוש בסוגי ניפוי באגים אחרים.

כש-Android Studio פורסת את האפליקציה במכשיר היעד, חלון ניפוי הבאגים נפתח עם כרטיסייה או תצוגה של סשן ניפוי באגים לכל תהליך ניפוי באגים, כפי שמוצג באיור 6.

איור 6. ניפוי באגים בקוד מקומי באמצעות LLDB.

1. Android Studio עובר לכרטיסייה <your-module> כשמתבצע מפגש של תהליך ניפוי הבאגים של LLDB עם נקודת עצירה בקוד C/C++. גם החלוניות Frames‏, Variables ו-Watches זמינות, והן פועלות בדיוק כמו שהן פועלות כשבודקים באגים בקוד Java.

   חלונית השרשור לא זמינה בתצוגת הסשן של LLDB, אבל אפשר לגשת לתהליכי האפליקציה באמצעות הרשימה בחלונית Frames. מידע נוסף על החלונות האלה זמין בקטעים בנושא ניפוי באגים בפריימים של חלונות ובדיקת משתנים.

   הערה: בזמן בדיקת נקודת עצירה בקוד המקורי, מערכת Android משהה את המכונה הווירטואלית שמריצה את הקוד הבינארי של Java באפליקציה. המשמעות היא שאין לכם אפשרות לקיים אינטראקציה עם מנתח הבאגים של Java או לאחזר מידע על המצב מסשן מנתח הבאגים של Java בזמן בדיקת נקודת עצירה בקוד המקורי.

2. Android Studio עובר לכרטיסייה <your-module>-java כשמתבצע נקודת עצירה בקוד Java או Kotlin על ידי מנתח הבאגים של Java.
3. בזמן ניפוי באגים באמצעות LLDB, אפשר להשתמש בטרמינל LLDB בתצוגת הסשן של LLDB כדי להעביר אפשרויות של שורת הפקודה ל-LLDB. אם יש לכם פקודות מסוימות שאתם רוצים ש-LLDB תבצע בכל פעם שאתם מתחילים לנפות באגים באפליקציה, לפני או אחרי שמאתר הבאגים מצורף לתהליך האפליקציה, תוכלו להוסיף את הפקודות האלה להגדרת ניפוי הבאגים.

בזמן ניפוי באגים בקוד C/C++‎, אפשר גם להגדיר סוגים מיוחדים של נקודות עצירה שנקראות נקודות מעקב, שיכולות להשעות את תהליך האפליקציה כשהאפליקציה מקיימת אינטראקציה עם בלוק זיכרון מסוים. מידע נוסף זמין בקטע הוספת נקודות מעקב.

הצגה והגדרה של נקודות עצירה

כדי להציג את כל נקודות העצירה ולהגדיר את ההגדרות שלהן, לוחצים על הצגת נקודות העצירה בחלון ניפוי הבאגים. החלון Breakpoints (נקודות עצירה) מופיע, כפי שמוצג באיור 7.

איור 7. בחלון Breakpoints מפורטות כל נקודות העצירה הנוכחיות, כולל הגדרות ההתנהגות של כל אחת מהן.

בחלון Breakpoints אפשר להפעיל או להשבית כל נקודת עצירה מהרשימה שבחלונית. אם נקודת העצירה מושבתת, Android Studio לא תשהה את האפליקציה כשהיא תגיע לנקודת העצירה הזו.

בוחרים נקודת עצירה מהרשימה כדי להגדיר את ההגדרות שלה. אפשר להגדיר נקודת עצירה כך שתהיה מושבתת בהתחלה, והמערכת תפעיל אותה אחרי שתגיעו לנקודת עצירה אחרת. אפשר גם להגדיר אם נקודת העצירה תושבת אחרי שהיא תגיע. כדי להגדיר נקודת עצירה לכל חריגה, בוחרים באפשרות נקודות עצירה של חריגות ברשימת נקודות העצירה.

כדי להשבית באופן זמני את כל נקודות העצירה, לוחצים על השתקת נקודות העצירה בחלון ניפוי הבאגים. לוחצים שוב כדי להפעיל מחדש.

ניפוי באגים של מסגרות חלונות

בחלון של מנתח הבאגים, בחלונית Frames אפשר לבדוק את מסגרת ה-stack שגרמה להגעה לנקודת העצירה הנוכחית. כך תוכלו לנווט ולבדוק את מסגרת ה-stack, וגם לבדוק את רשימת השרשור באפליקציה ל-Android.

כדי לבחור חוט, משתמשים בתפריט לבחירת חוטים ומציגים את מסגרת ה-stack שלו. לוחצים על הרכיבים בפריים כדי לפתוח את המקור בכלי העריכה. אפשר גם להתאים אישית את הצגת השרשור ולייצא את מסגרת ה-stack, כפי שמתואר במדריך לבדיקה של מסגרות.

בדיקת המשתנים

בחלון של מנתח הבאגים, בחלונית Variables אפשר לבדוק משתנים כשהמערכת עוצרת את האפליקציה בנקודת עצירה ובוחרים מסגרת מחלונית Frames. בחלונית Variables אפשר גם להעריך ביטויים אד-הוק באמצעות שיטות סטטיות ו/או משתנים שזמינים בתוך המסגרת שנבחרה.

כדי להוסיף ביטוי לעץ האובייקטים (בזמן ניפוי הבאגים באפליקציה):

איור 8. עץ האובייקטים ותיבת הזנת הביטוי בחלון ניפוי הבאגים.

1. מזינים את הביטוי שרוצים לעקוב אחריו או להציג
2. לוחצים על הוספה למעקב או מקישים על Enter כדי להעריך את הביטוי פעם אחת.

לחלופין, אם עץ האובייקטים מכיל את הביטוי שרוצים לעקוב אחריו, אפשר לגרור אותו לחלק העליון של העץ כדי להוסיף אותו כביטוי במעקב.

הביטויים שנמצאים במעקב יעודכנו כשמגיעים לנקודות עצירה או כשמבצעים ניתוח קוד.

ביטויים שעברו הערכה יוצגו בחלק העליון של עץ האובייקטים עד שתעריכו ביטוי אחר באופן ידני או שתבצעו בדיקה של הקוד.

כדי להסיר ביטוי במעקב מעץ האובייקטים, לוחצים לחיצה ימנית על הביטוי ואז על הסרת מעקב.

הוספת נקודות מעקב

בזמן ניפוי באגים בקוד C/C++‎, אפשר להגדיר סוגים מיוחדים של נקודות עצירה, שנקראות נקודות מעקב, שיכולות להשעות את תהליך האפליקציה כשהאפליקציה מקיימת אינטראקציה עם בלוק זיכרון מסוים. לדוגמה, אם מגדירים שני מצביעים למקטע זיכרון ומקצים לו נקודת מעקב, שימוש בכל אחד מהמצביעים כדי לגשת למקטע הזיכרון הזה יפעיל את נקודת המעקב.

ב-Android Studio אפשר ליצור נקודת מעקב במהלך זמן הריצה על ידי בחירת משתנה ספציפי, אבל LLDB מקצה את נקודת המעקב רק לבלוק הזיכרון שהמערכת מקצה למשתנה הזה, ולא למשתנה עצמו. ההבדל הוא בהוספת משתנה לחלונית 'מעקב', שמאפשרת לעקוב אחרי הערך של המשתנה אבל לא מאפשרת להשעות את תהליך האפליקציה כשהמערכת קוראת את הערך שלו בזיכרון או משנה אותו.

הערה: כשתהליך האפליקציה יוצא מפונקציה והמערכת מבטלת את ההקצאה של המשתנים המקומיים שלה מהזיכרון, צריך להקצות מחדש את נקודות הבקרה שיצרתם למשתנים האלה.

כדי להגדיר נקודת מעקב, צריך לעמוד בדרישות הבאות:

• במכשיר הפיזי או בסימולטור היעד נעשה שימוש ב-CPU מסוג x86 או x86_64. אם במכשיר שלכם מותקן מעבד ARM, עליכם להתאים את הגבול של כתובת המשתנה בזיכרון ל-4 בייטים למעבדים של 32 ביט או ל-8 בייטים למעבדים של 64 ביט. כדי ליישר משתנה בקוד המקורי, מציינים את הערך __attribute__((aligned(num_bytes))) בביטול המהירות של המשתנה, כפי שמתואר בהמשך:

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

• כבר הקצית שלוש נקודות מעקב או פחות. ב-Android Studio יש תמיכה רק ב-4 נקודות מעקב במכשירי יעד מסוג x86 או x86_64. יכול להיות שמכשירים אחרים יתמכו בפחות נקודות מעקב.

הערה: כשמנפים באגים באפליקציה עם ממשקי ARM ABI של 32 ביט, הוספת נקודת מעקב או החזקת העכבר מעל משתנים בקוד כדי לבדוק את הערכים שלהם עלולים לגרום לקריסה. כפתרון זמני, אפשר לנפות באגים באמצעות קובצי ‎ARM‏ 64-bit,‏ x86 או x86_64. הבעיה הזו תטופל במהדורה הקרובה של Android Studio.

אם אתם עומדים בדרישות, תוכלו להוסיף נקודת מעקב באופן הבא:

1. כשהאפליקציה מושהית בנקודת עצירה, עוברים לחלונית Variables בתצוגת הסשן של LLDB.

2. לוחצים לחיצה ימנית על משתנה שמאכלס את בלוק הזיכרון שרוצים לעקוב אחריו, ובוחרים באפשרות Add Watchpoint.

   

   איור 9. הוספת נקודת מעקב למשתנה בזיכרון.

3. תופיע תיבת דו-שיח להגדרת נקודת המעקב, כפי שמוצג באיור 9.

   מגדירים את נקודת המעקב באמצעות האפשרויות הבאות:

   • מופעלת: מבטלים את הבחירה באפשרות הזו אם רוצים לומר ל-Android Studio להתעלם מנקודת הבקרה עד לשינוי ההגדרה. Android Studio שומר את נקודת המעקב כדי שתוכלו לגשת אליה מאוחר יותר.
   • השהיה: כברירת מחדל, מערכת Android משהה את תהליך האפליקציה כשהיא ניגשת לבלוק של זיכרון שהוקצה לנקודת מעקב. אם אתם לא רוצים שההתנהגות הזו תתבצע, צריך לבטל את הסימון של האפשרות הזו. תוצג רשימה של אפשרויות נוספות להתאמה אישית של ההתנהגות כשהמערכת תיצור אינטראקציה עם נקודת המעקב: רישום הודעה ביומן במסוף והסרה כשהיא מופעלת.
   • Access Type (סוג הגישה): בוחרים אם האפליקציה תפעיל את נקודת המעקב כשהיא תנסה לקרוא או לכתוב בבלוק הזיכרון שהמערכת מקצה למשתנה. כדי להפעיל את נקודת המעקב בקריאה או בכתיבה, בוחרים באפשרות Any.
4. לוחצים על סיום.

כדי להציג את כל נקודות הבקרה ולהגדיר את ההגדרות שלהן, לוחצים על View Breakpoints (הצגת נקודות העצירה) בחלון ניפוי הבאגים. תיבת הדו-שיח Breakpoints מופיעה, כפי שמוצג באיור 10.

איור 10. בתיבת הדו-שיח Breakpoints מפורטות נקודות המעקב הנוכחיות, ומוצגות בה הגדרות ההתנהגות של כל אחת מהן.

אחרי שמוסיפים את נקודת המעקב, לוחצים על Resume Program (המשך התוכנית) בחלון ניפוי הבאגים כדי להמשיך את תהליך האפליקציה. כברירת מחדל, אם האפליקציה תנסה לגשת למקטע זיכרון שהגדרתם לו נקודת מעקב, מערכת Android תשהה את תהליך האפליקציה ויופיע סמל נקודת המעקב לצד שורת הקוד שהאפליקציה הטילה בפעם האחרונה, כפי שמוצג באיור 11.

איור 11. Android Studio מציין את שורת הקוד שהאפליקציה מבצעת ממש לפני הפעלת נקודת מעקב.

הצגה ושינוי של פורמט התצוגה של ערכי המשאבים

במצב ניפוי באגים, אפשר להציג את ערכי המשאבים ולבחור פורמט תצוגה אחר למשתנים בקוד Java או Kotlin. כשהכרטיסייה Variables מוצגת ותבנית מסוימת מסומנת, מבצעים את הפעולות הבאות:

1. ברשימת המשתנים, לוחצים לחיצה ימנית במקום כלשהו בשורת המשאב כדי להציג את הרשימה.
2. ברשימה, בוחרים באפשרות View as (תצוגה כ') ובפורמט שבו רוצים להשתמש.

   הפורמטים הזמינים תלויים בסוג הנתונים של המשאב שבחרתם. יכול להיות שתראו אחת או יותר מהאפשרויות הבאות:

   • כיתה: הצגת הגדרת הכיתה.
   • toString: פורמט של מחרוזת תצוגה.
   • Object (אובייקט): הצגת ההגדרה של האובייקט (מופע של כיתה).
   • מערך: הצגה בפורמט מערך.
     
   • חותמת זמן: הצגת התאריך והשעה באופן הבא: yyyy-mm-dd hh:mm:ss.
   • אוטומטי: Android Studio בוחרת את הפורמט הטוב ביותר על סמך סוג הנתונים.
     
   • בינארי: הצגת ערך בינארי באמצעות אפסים ואחדים.
   • MeasureSpec: הערך שמוענק מההורה לצאצא שנבחר. מידע נוסף זמין במאמר MeasureSpec.
   • Hex: הצגה כערך הקסדצימלי.
   • פרימיטיבי: הצגה כערך מספרי באמצעות סוג נתונים פרימיטיבי.
   • Integer: הצגה כערך מספרי מסוג Integer.

כדי ליצור פורמט מותאם אישית:

1. לוחצים לחיצה ימנית על ערך המשאב.
2. בוחרים באפשרות הצגה בתור.
3. בוחרים באפשרות יצירה.
4. תיבת הדו-שיח Java Data Type Renderers מוצגת. פועלים לפי ההוראות במאמר מעבדי נתונים מסוג Java.