הבן את קריסות משחק Unity באמצעות תכונות מתקדמות של Crashlytics, הבן את קריסות משחק Unity באמצעות תכונות מתקדמות של Crashlytics

1. הקדמה

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

אתה תוסיף פונקציונליות חדשה למשחק לדוגמה, MechaHamster: Level Up with Firebase Edition . משחק לדוגמה זה הוא גרסה חדשה של משחק Firebase הקלאסי MechaHamster שמסיר את רוב הפונקציונליות המובנית של Firebase, מה שנותן לך את ההזדמנות ליישם שימושים חדשים ב-Firebase במקומם.

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

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

מה תלמד

  • סוגי השגיאות שנתפסו אוטומטית על ידי Crashlytics.
  • שגיאות נוספות שניתן לרשום בכוונה.
  • כיצד להוסיף מידע נוסף לשגיאות אלו כדי שיהיה קל יותר להבין אותן.

מה אתה צריך

  • Unity (מינימום גרסה מומלצת 2019+) עם אחד או שניהם מהבאים:
    • תמיכה בבניית iOS
    • תמיכה בבניית אנדרואיד
  • (עבור אנדרואיד בלבד) Firebase CLI (משמש להעלאת סמלים עבור דוחות קריסה)

2. הגדר את סביבת הפיתוח שלך

הסעיפים הבאים מתארים כיצד להוריד את הקוד Level Up עם Firebase ולפתוח אותו ב-Unity.

שים לב שמשחק ה-Level Up with Firebase הזה נמצא בשימוש על ידי מספר מעבדות קוד אחרות של Firebase + Unity, כך שייתכן שכבר השלמת את המשימות בסעיף זה. אם כן, תוכל לעבור ישירות לשלב האחרון בדף זה: "הוסף Firebase SDKs for Unity".

הורד את הקוד

שיבוט את מאגר GitHub של Codelab זה משורת הפקודה:

git clone https://github.com/firebase/level-up-with-firebase.git

לחלופין, אם לא התקנת git, אתה יכול להוריד את המאגר כקובץ ZIP .

פתח את Level Up עם Firebase בעורך Unity

  1. הפעל את Unity Hub ובכרטיסייה פרויקטים לחץ על החץ הנפתח לצד פתח .
  2. לחץ על הוסף פרוייקט מהדיסק .
  3. נווט אל הספרייה המכילה את הקוד ולאחר מכן לחץ על אישור .
  4. אם תתבקש, בחר בגרסת עורך Unity לשימוש ובפלטפורמת היעד שלך (אנדרואיד או iOS).
  5. לחץ על שם הפרויקט, רמה למעלה-עם-firebase , והפרויקט ייפתח בעורך Unity.
  6. אם העורך שלך לא פותח אותו אוטומטית, פתח MainGameScene בנכסים > אוגר בלשונית Project של Unity Editor.
    ff4ea3f3c0d29379.png

למידע נוסף על התקנה ושימוש ב-Unity, ראה עבודה ב-Unity .

3. הוסף את Firebase לפרויקט Unity שלך

צור פרויקט Firebase

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

רשום את האפליקציה שלך ב-Firebase

  1. עדיין במסוף Firebase , ממרכז דף סקירת הפרויקט, לחץ על סמל Unity כדי להפעיל את זרימת העבודה של ההגדרה או, אם כבר הוספת אפליקציה לפרויקט Firebase שלך, לחץ על הוסף אפליקציה כדי להציג את אפשרויות הפלטפורמה.
  2. בחר כדי לרשום הן את יעדי הבנייה של Apple (iOS) והן ל-Android.
  3. הזן את המזהים הספציפיים לפלטפורמה של פרויקט Unity שלך. עבור מעבדת קוד זה, הזן את הדברים הבאים:
  4. (אופציונלי) הזן את הכינוי/כינויים הספציפיים לפלטפורמה של פרויקט Unity שלך.
  5. לחץ על הרשמה אפליקציה ולאחר מכן המשך לקטע הורד קובץ תצורה .

הוסף קובצי תצורה של Firebase

לאחר לחיצה על הרשמה אפליקציה , תתבקש להוריד שני קובצי תצורה (קובץ תצורה אחד לכל יעד בנייה). פרויקט Unity שלך זקוק למטא נתונים של Firebase בקבצים האלה כדי להתחבר ל-Firebase.

  1. הורד את שני קבצי התצורה הזמינים:
    • עבור Apple (iOS) : הורד את GoogleService-Info.plist .
    • עבור אנדרואיד : הורד את google-services.json .
  2. פתח את חלון הפרויקט של פרויקט Unity שלך, ולאחר מכן העבר את שני קובצי התצורה לתיקיית הנכסים .
  3. בחזרה למסוף Firebase, בזרימת העבודה של ההגדרה, לחץ על Next והמשך להוספת Firebase SDKs for Unity.

הוסף ערכות פיתוח של Firebase עבור Unity

  1. לחץ על הורד Firebase Unity SDK במסוף Firebase.
  2. פתח את ה-SDK במקום נוח.
  3. בפרויקט Unity הפתוח שלך, נווט אל נכסים > ייבוא ​​חבילה > חבילה מותאמת אישית .
  4. בתיבת הדו-שיח 'ייבוא ​​חבילה' , נווט אל הספרייה המכילה את ה-SDK שנפרם, בחר FirebaseAnalytics.unitypackage ולאחר מכן לחץ על פתח .
  5. מתיבת הדו-שיח ייבוא ​​חבילת אחדות שמופיעה, לחץ על ייבוא ​​.
  6. חזור על השלבים הקודמים כדי לייבא FirebaseCrashlytics.unitypackage .
  7. חזור למסוף Firebase ובתהליך העבודה של ההגדרה, לחץ על הבא .

למידע נוסף על הוספת Firebase SDK לפרויקטים של Unity, ראה אפשרויות התקנה נוספות של Unity .

4. הגדר את Crashlytics בפרויקט Unity שלך

כדי להשתמש ב-Crashlytics בפרויקטים של Unity, תצטרך לבצע עוד כמה שלבי הגדרה. כמובן, תצטרך לאתחל את ה-SDK. אבל גם, תצטרך להעלות את הסמלים שלך כדי שתוכל לראות עקבות מחסניות סימבוליות במסוף Firebase, ותצטרך לאלץ קריסת בדיקה כדי לוודא ש-Firebase מקבל את אירועי הקריסה שלך.

אתחל את ה-SDK של Crashlytics

  1. ב- Assets/Hamster/Scripts/MainGame.cs , הוסף את הדברים הבאים using הצהרות:
    using Firebase.Crashlytics;
using Firebase.Extensions;
    המודול הראשון מאפשר לך להשתמש בשיטות מה-Crashlytics SDK והשני מכיל כמה הרחבות ל- C# Tasks API . בלי שניהם using במשפטים הקוד הבא לא יעבוד.
  2. עדיין ב- MainGame.cs , הוסף אתחול Firebase לשיטת Start() הקיימת על ידי קריאה ל- InitializeFirebaseAndStartGame() :
    void Start()
{
  Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
  InitializeFirebaseAndStartGame();
}
  3. ושוב, ב- MainGame.cs , מצא את InitializeFirebaseAndStartGame() , הכריז על משתנה אפליקציה ולאחר מכן תחליף את היישום של השיטה כך:
    public Firebase.FirebaseApp app = null;

// Begins the firebase initialization process and afterwards, opens the main menu.
private void InitializeFirebaseAndStartGame()
{
  Firebase.FirebaseApp.CheckAndFixDependenciesAsync()
  .ContinueWithOnMainThread(
    previousTask => 
    {
      var dependencyStatus = previousTask.Result;
      if (dependencyStatus == Firebase.DependencyStatus.Available) {
        // Create and hold a reference to your FirebaseApp,
        app = Firebase.FirebaseApp.DefaultInstance;
        // Set the recommended Crashlytics uncaught exception behavior.
        Crashlytics.ReportUncaughtExceptionsAsFatal = true;
        InitializeCommonDataAndStartGame();
      } else {
        UnityEngine.Debug.LogError(
          $"Could not resolve all Firebase dependencies: {dependencyStatus}\n" +
          "Firebase Unity SDK is not safe to use here");
      }
    });
}

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

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

בנה את הפרויקט שלך והעלה סמלים

השלבים לבנייה והעלאת סמלים שונים עבור אפליקציות iOS ו-Android.

iOS+ (פלטפורמת אפל)

  1. מתיבת הדו-שיח Build Settings , ייצא את הפרויקט שלך לסביבת עבודה של Xcode.
  2. בנה את האפליקציה שלך.
    עבור פלטפורמות אפל, הפלאגין Firebase Unity Editor מגדיר באופן אוטומטי את פרויקט ה-Xcode שלך ​​ליצור ולהעלות קובץ סמלים תואם Crashlytics לשרתי Firebase עבור כל build. מידע על סמלים זה נדרש כדי לראות עקבות מחסנית סימבולית בלוח המחוונים של Crashlytics.

דְמוּי אָדָם

  1. (רק במהלך ההגדרה הראשונית, לא עבור כל build) הגדר את ה-build שלך:
    1. צור תיקיה חדשה בשם Builds בשורש ספריית הפרויקט שלך (כלומר, בתור אח לספריית הנכסים שלך), ולאחר מכן צור תיקיית משנה בשם Android .
    2. בקובץ > Build Settings > Player Settings > Configuration , הגדר את Backend Scripting ל-IL2CPP.
      • IL2CPP בדרך כלל גורם לבנייה להיות קטנה יותר ובעלת ביצועים טובים יותר.
      • IL2CPP היא גם האפשרות הזמינה היחידה ב-iOS והבחירה בה כאן מאפשרת לשתי הפלטפורמות להיות זוגיות טובה יותר ולהפוך את הבדלי ניפוי באגים בין השתיים (אם תבחר לבנות את שתיהן) לפשוטה יותר.
  2. בנה את האפליקציה שלך. בקובץ > הגדרות בנייה , השלם את הפעולות הבאות:
    1. ודא ש- Create symbols.zip מסומן (או אם מוצג עם תפריט נפתח, בחר איתור באגים ).
    2. בנה את ה-APK שלך ישירות מעורך Unity לתוך תיקיית המשנה Builds/Android שיצרת זה עתה.
  3. לאחר שהבנייה שלך תסתיים, עליך ליצור קובץ סמלים תואם Crashlytics ולהעלות אותו לשרתי Firebase. מידע על סמלים זה נדרש כדי לראות עקבות מחסנית סימבולית עבור קריסות של ספרייה מקורית בלוח המחוונים של Crashlytics.

    צור והעלה את קובץ הסמלים הזה על ידי הפעלת פקודת Firebase CLI הבאה:
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
    • FIREBASE_APP_ID : מזהה אפליקציית Firebase Android שלך (לא שם החבילה שלך). מצא את הערך הזה בקובץ google-services.json שהורדת קודם לכן. זה הערך mobilesdk_app_id .
      מזהה אפליקציה ל-Android של Firebase לדוגמה: 1:567383003300:android:17104a2ced0c9b9b
    • PATH/TO/SYMBOLS : הנתיב של קובץ הסמלים המכווץ שנוצר בספריית Builds/Android עם סיום הבנייה (לדוגמה: Builds/Android/myapp-1.0-v100.symbols.zip ).

כפה קריסת בדיקה כדי לסיים את ההגדרה

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

  1. ב- MainGameScene מצא את EmptyObject GameObject ב- Hierarchy של העורך, הוסף לו את הסקריפט הבא ולאחר מכן שמור את הסצנה. סקריפט זה יגרום לקריסת בדיקה מספר שניות לאחר הפעלת האפליקציה.
    using System;
using UnityEngine;

public class CrashlyticsTester : MonoBehaviour {
    // Update is called once per frame
    void Update()
    {
        // Tests your Crashlytics implementation by
        // throwing an exception every 60 frames.
        // You should see reports in the Firebase console
        // a few minutes after running your app with this method.
        if(Time.frameCount >0 && (Time.frameCount%60) == 0)
        {
            throw new System.Exception("Test exception; please ignore");
        }
    }
}
  2. בנה את האפליקציה שלך והעלה מידע על סמלים לאחר סיום הבנייה.
    • iOS : הפלאגין Firebase Unity Editor מגדיר באופן אוטומטי את פרויקט ה-Xcode שלך ​​כדי להעלות את קובץ הסמלים שלך.
    • אנדרואיד : הפעל את פקודת Firebase CLI crashlytics:symbols:upload כדי להעלות את קובץ הסמלים שלך.
  3. הפעל את האפליקציה שלך. לאחר שהאפליקציה שלך פועלת, צפה ביומן המכשיר והמתן עד שהחריג יופעל מה- CrashlyticsTester .
    • iOS : הצג יומנים בחלונית התחתונה של Xcode.
    • אנדרואיד : הצג יומנים על ידי הפעלת הפקודה הבאה בטרמינל: adb logcat .
  4. בקר בלוח המחוונים של Crashlytics כדי לראות את החריג! תראה את זה בטבלת הבעיות בתחתית לוח המחוונים. בהמשך מעבדת הקוד, תלמד עוד כיצד לחקור דוחות אלה.
  5. לאחר שאישרת שהאירוע הועלה ל-Crashlytics, בחר את EmptyObject GameObject אליו צירפת אותו, הסר רק את רכיב CrashlyticsTester , ולאחר מכן שמור את הסצנה כדי לשחזר אותה למצבה המקורי.

5. הפעל והבין את תפריט ניפוי באגים

עד כה, הוספת את Crashlytics לפרויקט Unity שלך, סיימת את ההגדרה ואישרת ש-Crashlytics SDK מעלה אירועים ל-Firebase. כעת תיצור תפריט בפרויקט Unity שלך אשר ידגים כיצד להשתמש בפונקציונליות מתקדמת יותר של Crashlytics במשחק שלך. לפרויקט Level Up with Firebase Unity כבר יש תפריט Debug נסתר שתהפוך לגלוי ותכתוב את הפונקציונליות עבורו.

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

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

  1. ב-Unity Editor, פתח את התבנית הטרומית בשם MainMenu . 4148538cbe9f36c5.png
  2. בהיררכיה הטרומית, מצא את אובייקט המשנה המושבת בשם DebugMenuButton ולאחר מכן בחר אותו. 816f8f9366280f6c.png
  3. הפעל את DebugMenuButton על ידי סימון התיבה בפינה השמאלית העליונה משמאל לשדה הטקסט המכיל DebugMenuButton . 8a8089d2b4886da2.png
  4. שמור את הטרומי.
  5. הפעל את המשחק בעורך או במכשיר שלך. התפריט אמור להיות נגיש כעת.

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

בהמשך מעבדת הקוד הזה, תכתוב גופי שיטה עבור כמה שיטות ניפוי באגים של Crashlytics שהוגדרו מראש. עם זאת, בפרויקט Level Up with Firebase Unity, השיטות מוגדרות ב- DebugMenu.cs וקראו אותן.

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

פתח DebugMenu.cs ולאחר מכן מצא את השיטות הבאות:

שיטות ליצירה והערה של בעיות Crashlytics:

  • CrashNow
  • LogNonfatalError
  • LogStringsAndCrashNow
  • SetAndOverwriteCustomKeyThenCrash
  • SetLogsAndKeysBeforeANR

שיטות לרישום אירועים ב-Analytics כדי לסייע באיתור באגים:

  • LogProgressEventWithStringLiterals
  • LogIntScoreWithBuiltInEventAndParams

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

6. להבטיח מסירת דוחות קריסה בפיתוח

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

עבור פרויקטים של Unity, אירועי קריסה וחריגים במשחק שלך נכתבים מיד לדיסק. עבור חריגים שלא נתפסו שאינם קורסים את המשחק שלך (לדוגמה, חריגות C# שלא נתפסו בלוגיקה של המשחק), אתה יכול לבקש מה-Crashlytics SDK לדווח עליהם כאירועים קטלניים על ידי הגדרת המאפיין Crashlytics.ReportUncaughtExceptionsAsFatal ל- true במקום שבו אתה מאתחל את Crashlytics בפרויקט Unity שלך . אירועים אלו מדווחים ל-Cashlytics בזמן אמת ללא צורך במשתמש קצה שיפעיל מחדש את המשחק. שים לב שקריסות מקומיות תמיד מדווחות כאירועים קטלניים ונשלחות יחד כאשר משתמש קצה מפעיל מחדש את המשחק.

בנוסף, שים לב להבדלים הקטנים - אך המשמעותיים - הבאים בין האופן שבו סביבות זמן הריצה השונות שולחות מידע Crashlytics ל-Firebase:

סימולטור iOS:

  • מידע Crashlytics מדווח אם ורק אם מנתקים את Xcode מהסימולטור. אם Xcode מצורף, הוא תופס את השגיאות במעלה הזרם, ומונע מסירת מידע.

מכשירים פיזיים ניידים (אנדרואיד ו-iOS):

  • ספציפי לאנדרואיד: מקרי ANR מדווחים רק ב-Android 11+. ANRs ואירועים לא קטלניים מדווחים בריצה הבאה.

עורך אחדות:

בדוק את קריסת המשחק שלך בלחיצת כפתור ב- CrashNow()

לאחר הגדרת Crashlytics במשחק שלך, ה-SDK של Crashlytics מתעד אוטומטית קריסות וחריגים שלא נתפסו ומעלה אותם ל-Firebase לניתוח. והדוחות מוצגים בלוח המחוונים של Crashlytics במסוף Firebase.

  1. כדי להדגים שזה אכן אוטומטי: פתח DebugMenu.cs , ולאחר מכן החלף את השיטה CrashNow() באופן הבא:
    void CrashNow()
{
    TestCrash();
}
  2. בנה את האפליקציה שלך.
  3. (אנדרואיד בלבד) העלה את הסמלים שלך על ידי הפעלת פקודת Firebase CLI הבאה:
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  4. הקש על הלחצן Crash Now , והמשך לשלב הבא של מעבדת קוד זה כדי לגלות כיצד להציג ולפרש את דוח הקריסה.

7. הבן את דוחות הבעיות במסוף Firebase

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

  1. הקש על הלחצן Crash Now ולאחר מכן הפעל מחדש את האפליקציה שלך.
  2. עבור אל לוח המחוונים של Crashlytics . גלול מטה לטבלת הבעיות בתחתית לוח המחוונים, שם Crashlytics מקבץ אירועים שלכולם יש את אותה שורש ל"בעיות".
  3. לחץ על הבעיה החדשה הרשומה בטבלת הבעיות . פעולה זו מציגה את סיכום האירוע לגבי כל אירוע בודד שנשלח ל-Firebase.

    אתה אמור לראות משהו כמו כיסוי המסך הבא. שימו לב כיצד תקציר האירוע מציג בצורה בולטת את עקבות המחסנית של השיחה שהובילה להתרסקות. 40c96abe7f90c3aa.png

מטא נתונים נוספים

כרטיסייה מועילה נוספת היא הכרטיסייה Unity Metadata . סעיף זה מודיע לך על התכונות של המכשיר שבו התרחש האירוע, כולל תכונות פיזיות, דגם/מפרט המעבד וכל מיני מדדי GPU.

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

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

41d8d7feaa87454d.png

8. לזרוק, לתפוס ולתעד חריגה

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

  1. ב- Assets/Hamster/Scripts/States/DebugMenu.cs , הוסף את הדברים הבאים להצהרות using :
    // Import Firebase
using Firebase.Crashlytics;
  2. עדיין ב- DebugMenu.cs , החלף את LogNonfatalError() באופן הבא:
    void LogNonfatalError()
{
    try
    {
        throw new System.Exception($"Test exception thrown in {nameof(LogNonfatalError)}");
    }
    catch(System.Exception exception)
    {
        Crashlytics.LogException(exception);
    }
}
  3. בנה את האפליקציה שלך.
  4. (אנדרואיד בלבד) העלה את הסמלים שלך על ידי הפעלת פקודת Firebase CLI הבאה:
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  5. הקש על הלחצן Log Nonfatal Error ולאחר מכן הפעל מחדש את האפליקציה שלך.
  6. עבור אל לוח המחוונים של Crashlytics , ואתה אמור לראות משהו דומה למה שראית בשלב האחרון של מעבדת הקוד הזה.
  7. עם זאת, הפעם, הגבל את מסנן סוג האירוע ל- Non-fetals כך שתראה רק שגיאות שאינן קטלניות, כמו זו שרשמת זה עתה.
    a39ea8d9944cbbd9.png

9. התחבר מחרוזות ל-Crashlytics כדי להבין טוב יותר את זרימת ביצוע התוכנית

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

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

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

  1. ב- Assets/Hamster/Scripts/States/DebugMenu.cs , החלף את LogStringsAndCrashNow() באופן הבא:
    void LogStringsAndCrashNow()
{
    Crashlytics.Log($"This is the first of two descriptive strings in {nameof(LogStringsAndCrashNow)}");
    const bool RUN_OPTIONAL_PATH = false;
    if(RUN_OPTIONAL_PATH)
    {
        Crashlytics.Log(" As it stands, this log should not appear in your records because it will never be called.");
    }
    else
    {
        Crashlytics.Log(" A log that will simply inform you which path of logic was taken. Akin to print debugging.");
    }
    Crashlytics.Log($"This is the second of two descriptive strings in {nameof(LogStringsAndCrashNow)}");
    TestCrash();
}
  2. בנה את האפליקציה שלך.
  3. (אנדרואיד בלבד) העלה את הסמלים שלך על ידי הפעלת פקודת Firebase CLI הבאה:
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  4. הקש על הלחצן יומן מחרוזות וקרס עכשיו ולאחר מכן הפעל מחדש את האפליקציה שלך.
  5. חזור ללוח המחוונים של Crashlytics ולחץ על הגיליון החדש ביותר המופיע בטבלת הבעיות . שוב אתה אמור לראות משהו דומה לבעיות הקודמות.
    7aabe103b8589cc7.png
  6. עם זאת, אם תלחץ על הכרטיסייה יומנים בתוך סיכום אירוע , תקבל תצוגה כזו:
    4e27aa407b7571cf.png

10. כתוב והחלף מפתח מותאם אישית

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

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

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

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

  1. ב- Assets/Hamster/Scripts/States/DebugMenu.cs , החלף את SetAndOverwriteCustomKeyThenCrash() באופן הבא:
    void SetAndOverwriteCustomKeyThenCrash()
{
    const string CURRENT_TIME_KEY = "Current Time";
    System.TimeSpan currentTime = System.DateTime.Now.TimeOfDay;
    Crashlytics.SetCustomKey(
        CURRENT_TIME_KEY,
        DayDivision.GetPartOfDay(currentTime).ToString() // Values must be strings
        );

    // Time Passes
    currentTime += DayDivision.DURATION_THAT_ENSURES_PHASE_CHANGE;

    Crashlytics.SetCustomKey(
        CURRENT_TIME_KEY,
        DayDivision.GetPartOfDay(currentTime).ToString()
        );
    TestCrash();
}
  2. בנה את האפליקציה שלך.
  3. (אנדרואיד בלבד) העלה את הסמלים שלך על ידי הפעלת פקודת Firebase CLI הבאה:
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  4. הקש על כפתור הגדר מפתח מותאם אישית וקריסה ולאחר מכן הפעל מחדש את האפליקציה שלך.
  5. חזור ללוח המחוונים של Crashlytics ולחץ על הגיליון החדש ביותר המופיע בטבלת הבעיות . שוב אתה אמור לראות משהו דומה לבעיות הקודמות.
  6. עם זאת, הפעם, לחץ על הכרטיסייה מפתחות בסיכום האירוע כדי שתוכל לראות את הערך של המפתחות כולל Current Time :
    7dbe1eb00566af98.png

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

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

עם זאת, בדומה ליומנים, למפתחות מותאמים אישית יש מגבלה. Crashlytics תומך ב-64 צמדי מפתח-ערך לכל היותר. לאחר שתגיע לסף זה, ערכים נוספים לא יישמרו. כל זוג מפתח-ערך יכול להיות בגודל של עד 1 KB.

11. (אנדרואיד בלבד) השתמש במפתחות וביומנים מותאמים אישית כדי להבין ולאבחן ANR

אחד מקבוצות הבעיות הקשות ביותר לניפוי באגים עבור מפתחי אנדרואיד היא השגיאה Application Not Responding (ANR). מקרי ANR מתרחשים כאשר אפליקציה לא מצליחה להגיב לקלט במשך יותר מ-5 שניות. אם זה קורה, זה אומר שהאפליקציה קפאה, או שהיא פועלת לאט מאוד. תיבת דו-שיח מוצגת למשתמשים, והם יכולים לבחור אם "להמתין" או "לסגור את האפליקציה".

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

בשיטה זו, נשתמש בשילוב של Crashlytics.LogException , Crashlytics.Log ו- Crashlytics.SetCustomKey כדי להשלים את רישום הבעיות האוטומטי וכדי לתת לנו מידע נוסף.

  1. ב- Assets/Hamster/Scripts/States/DebugMenu.cs , החלף את SetLogsAndKeysBeforeANR() באופן הבא:
    void SetLogsAndKeysBeforeANR()
{
    System.Action<string,long> WaitAndRecord =
    (string methodName, long targetCallLength)=>
    {
        System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
        const string CURRENT_FUNCTION = "Current Async Function";

        // Initialize key and start timing
        Crashlytics.SetCustomKey(CURRENT_FUNCTION, methodName);
        stopWatch.Start();

        // The actual (simulated) work being timed.
        BusyWaitSimulator.WaitOnSimulatedBlockingWork(targetCallLength);

        // Stop timing
        stopWatch.Stop();

        if(stopWatch.ElapsedMilliseconds>=BusyWaitSimulator.EXTREME_DURATION_MILLIS)
        {
          Crashlytics.Log($"'{methodName}' is long enough to cause an ANR.");
        }
        else if(stopWatch.ElapsedMilliseconds>=BusyWaitSimulator.SEVERE_DURATION_MILLIS)
        {
          Crashlytics.Log($"'{methodName}' is long enough it may cause an ANR");
        }
    };

    WaitAndRecord("DoSafeWork",1000L);
    WaitAndRecord("DoSevereWork",BusyWaitSimulator.SEVERE_DURATION_MILLIS);
    WaitAndRecord("DoExtremeWork",2*BusyWaitSimulator.EXTREME_DURATION_MILLIS);
}
  2. בנה את האפליקציה שלך.
  3. העלה את הסמלים שלך על ידי הפעלת פקודת Firebase CLI הבאה:
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  4. הקש על הלחצן שכותרתו הגדר יומנים ומפתחות ← ANR ולאחר מכן הפעל מחדש את האפליקציה שלך.
  5. חזור אל לוח המחוונים של Crashlytics , ולאחר מכן לחץ על הנושא החדש בטבלת הבעיות כדי להציג את סיכום האירוע . אם השיחה עברה כמו שצריך, אתה אמור לראות משהו כזה:
    876c3cff7037bd07.png

    כפי שאתה יכול לראות, Firebase סימנה את ההמתנה העמוסה בשרשור כגורם העיקרי שהאפליקציה שלך הפעילה ANR.
  6. אם תסתכל על היומנים בכרטיסייה Logs של סיכום האירוע , תראה שהשיטה האחרונה שנרשמה כמושלמה היא DoSevereWork .
    5a4bec1cf06f6984.png

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

    89d86d5f598ecf3a.png

למה לעשות את זה?

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

12. שילוב אירועי אנליטיקה להעשרת דוחות נוספת

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

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

  1. ב- Assets/Hamster/Scripts/States/DebugMenu.cs , החלף את ההטמעות הקיימות של השיטות הבאות:
    public void LogProgressEventWithStringLiterals()
{
      Firebase.Analytics.FirebaseAnalytics.LogEvent("progress", "percent", 0.4f);
}

    public void LogIntScoreWithBuiltInEventAndParams()
{
      Firebase.Analytics.FirebaseAnalytics
        .LogEvent(
          Firebase.Analytics.FirebaseAnalytics.EventPostScore,
          Firebase.Analytics.FirebaseAnalytics.ParameterScore,
          42
        );
}
  2. בנה ופרוס את המשחק שלך, ולאחר מכן היכנס לתפריט ניפוי באגים .
  3. (אנדרואיד בלבד) העלה את הסמלים שלך על ידי הפעלת פקודת Firebase CLI הבאה:
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  4. לחץ על לפחות אחד מהלחצנים הבאים פעם אחת או יותר כדי לקרוא לפונקציות שלעיל:
    • יומן מחרוזת אירוע
    • אירוע התחבר
  5. לחץ על הלחצן קראש עכשיו .
  6. הפעל מחדש את המשחק שלך כדי להעלות את אירוע הקריסה ל-Firebase.
  7. כאשר אתה רושם רצפים שרירותיים שונים של אירועים ב-Analytics ולאחר מכן גורם למשחק שלך ליצור אירוע שממנו Crashlytics יוצר דוח (כמו שזה עתה יצרת), הם מתווספים ללשונית היומנים של סיכום האירועים של Crashlytics כך:
    d3b16d78f76bfb04.png

13. קדימה

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

אם האפליקציה שלך מתמקדת ב-Android 11 (רמת API 30) ומעלה, שקול לשלב את GWP-ASan , תכונה מקורית של מקצה זיכרון שימושית לניפוי קריסות הנגרמות על ידי שגיאות זיכרון מקורי כגון באגים use-after-free ו- heap-buffer-overflow . כדי לנצל את תכונת ניפוי הבאגים הזו, הפעל במפורש את GWP-ASan .

הצעדים הבאים

המשך למשחק המכשיר שלך ב-Unity עם מעבד הקוד של Config Remote , שבו תלמד על השימוש בתצורה מרחוק ובדיקת A/B ב-Unity.