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

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

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

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

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

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

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

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

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

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

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

   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Java בלבד

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

מודעות מותאמות בלבד (זמין רק עם קוד 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.

Dual (Java + Native) – זמינה רק עם קוד C/C++

יש לבחור בסוג הזה לניפוי באגים אם רוצים לעבור בין ניפוי באגים גם ב-Java וגם בקוד נייטיב. Android Studio מצרף את הכלי לניפוי באגים Java וגם LLDB לאפליקציה כדי שתוכלו לבדוק נקודות עצירה (breakpoint) גם ב-Java וגם בקוד ה-Native בלי להפעיל מחדש את האפליקציה או שינוי התצורה של ניפוי הבאגים.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת משתנים

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

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

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

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

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

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

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

הוספה של נקודות שעון

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

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

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

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

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

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

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

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

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

   

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

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

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

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

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

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

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

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

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

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

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

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