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

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. לוחצים על אישור.

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

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

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

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

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

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) לחריגה

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת משתנים

בחלון של מנתח הבאגים, בחלונית Variables אפשר לבדוק משתנים כשהמערכת עוצרת את האפליקציה בנקודת עצירה ובוחרים מסגרת בחלונית 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 (הסרה בעת ההתאמה).
   • סוג גישה: בוחרים אם האפליקציה תפעיל את נקודת הצפייה כשהיא מנסה לקרוא או לכתוב הזיכרון שהמערכת מקצה למשתנה. כדי להפעיל את נקודת המעקב בקריאה או בכתיבה, בוחרים באפשרות Any.
4. לוחצים על סיום.

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

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

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

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

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

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

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

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

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