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

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

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

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

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

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

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

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

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

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

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

GroovyKotlin

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

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

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

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

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

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

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

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

   

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

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

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

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

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

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

צירוף הכלי לניפוי באגים לאפליקציה פועלת

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Java בלבד

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

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

יש לבחור את סוג ניפוי הבאגים הזה אם רוצים להשתמש רק ב-LLDB לניפוי באגים בקוד. כשמשתמשים ב מהסוג של ניפוי הבאגים, התצוגה של הסשן בכלי לניפוי באגים ב-Java לא זמינה. כברירת מחדל, LLDB בודק רק את הקוד המקורי ומתעלם מנקודות עצירה (breakpoint) ב-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 לאפליקציה כדי שתוכלו לבדוק נקודות עצירה (breakpoint) גם ב-Java וגם בקוד ה-Native בלי להפעיל מחדש את האפליקציה או שינוי התצורה של ניפוי הבאגים.

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

איור 3. כרטיסייה לניפוי באגים בקוד מקורי ובכרטיסייה לניפוי באגים בקוד Java.

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

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

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

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

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

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

KotlinJava

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

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

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

KotlinJava

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

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) בשיטה

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

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

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

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

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

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

כדי להוסיף נקודת מעבר של שורה:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הביטויים הנצפים יתעדכנו בכל פעם שיגיעו לנקודות עצירה (breakpoint) או כשתעברו דרך הקוד.

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

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

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

בזמן ניפוי באגים בקוד 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 יש תמיכה רק בעד ארבע נקודות מעקב במכשירי יעד מסוג x86 או x86_64. יכול להיות שמכשירים אחרים יתמכו בפחות נקודות מעקב.

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

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

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

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

   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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