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

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

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

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

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

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

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

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

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

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

בדרך כלל אפשר לבחור את וריאנט ברירת המחדל של 'ניפוי באגים' שכלול בכל פרויקט ב-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. סרגל הכלים לביצוע וניווט זמין במאמר עבודה עם נקודות עצירה (breakpoint).
2. בורר שרשורים
3. הערכה והזנה של ביטוי שעון. בדיקת משתנים
4. תצוגת מקבץ
5. החלונית Variables (משתנים). בדיקת משתנים

הערה: מנקה האשפה והכלי לניפוי באגים ב-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 בלבד מתעלם מנקודות עצירה (breakpoint) או שעונים שהגדרתם בקוד הנייטיב.

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

הערה: במהלך ניפוי באגים בקוד מקורי שעבר אופטימיזציה על ידי המהדר (compiler), יכול להיות שתופיע הודעת האזהרה הבאה:
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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   

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

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

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

   • מופעל: מבטלים את הבחירה באפשרות הזו אם רוצים לומר ל-Android Studio להתעלם מנקודת הבקרה עד לשינוי ההגדרה. Android Studio שומר את נקודת המעקב כדי שתוכלו לגשת אליה מאוחר יותר.
   • השהיה: כברירת מחדל, מערכת Android משהה את תהליך האפליקציה כשהיא ניגשת לבלוק של זיכרון שהוקצה לנקודת מעקב. אם אתם לא רוצים שההתנהגות הזו תתבצע, צריך לבטל את הסימון של האפשרות הזו. יוצגו אפשרויות נוספות להתאמה אישית של ההתנהגות כשהמערכת תיצור אינטראקציה עם נקודת המעקב: Log message to console ו-Remove when hit.
   • 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.

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

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