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

ב-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:

מגניב

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.

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

   אם האפליקציה כבר פועלת במכשיר, תוצג תיבת דו-שיח שבה תתבקשו לבחור אם לעבור ממצב Run (הפעלה) למצב Debug (ניפוי באגים). כדי להתחיל את ניפוי הבאגים, צריך להפעיל מחדש את המכשיר. כדי להמשיך להריץ את אותו מופע של האפליקציה, לוחצים על Cancel Debug ומצרפים את מנקה הבאגים לאפליקציה שפועלת. אחרת, Android Studio יוצרת APK, חותמת עליו באמצעות מפתח ניפוי באגים, מתקינה אותו במכשיר שנבחר ומריצה אותו.

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

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

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

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

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

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

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

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

איור 2.החלון Debug.

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

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

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

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

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

כדי לבחור ידנית את מנפה הבאגים בהגדרת ניפוי הבאגים, לוחצים על Run > Edit Configurations. אפשר גם לבחור את מנפה הבאגים בתיבת הדו-שיח שמופיעה כשלוחצים על Run > Attach debugger to Android process.

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

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

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

Java בלבד

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

Native Only (זמין רק עם קוד C/C++‎)

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

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

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

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

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

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

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

כדי לכתוב הודעות ביומן בקוד, משתמשים במחלקה 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. אם התצוגה Variables לא מופיעה, לוחצים על Layout Settings ומוודאים שהאפשרות variables מסומנת.

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

• כדי להתקדם לשורה הראשונה בתוך הפעלת method, לוחצים על Step Into .

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

• כדי להמשיך להריץ את האפליקציה כרגיל, לוחצים על Resume Program .

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת משתנים

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

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

איור 8. עץ האובייקטים ותיבת הקלט של הביטויים בחלון Debug.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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