ทำความเข้าใจข้อขัดข้องของเกม Unity โดยใช้ฟีเจอร์ขั้นสูงของ Crashlytics

1. บทนำ

ในโค้ดแล็บนี้ คุณจะได้เรียนรู้วิธีใช้ฟีเจอร์ขั้นสูงของ Crashlytics ซึ่งจะช่วยให้คุณมองเห็นข้อขัดข้องและสถานการณ์ที่อาจทำให้เกิดข้อขัดข้องได้ดียิ่งขึ้น

คุณจะเพิ่มฟังก์ชันใหม่ลงในเกมตัวอย่าง MechaHamster: Level Up with Firebase Edition เกมตัวอย่างนี้เป็นเกมเวอร์ชันใหม่ของเกม Firebase คลาสสิกอย่าง MechaHamster ซึ่งนำฟังก์ชันการทำงานของ Firebase ในตัวส่วนใหญ่ออก เพื่อให้คุณมีโอกาสได้ใช้ Firebase ในรูปแบบใหม่แทน

คุณจะเพิ่มเมนูแก้ไขข้อบกพร่องลงในเกม เมนูแก้ไขข้อบกพร่องนี้จะเรียกใช้เมธอดที่คุณสร้างขึ้น และช่วยให้คุณใช้ฟังก์ชันต่างๆ ของ Crashlytics ได้ วิธีเหล่านี้จะแสดงวิธีประกอบรายงานข้อขัดข้องอัตโนมัติด้วยคีย์ที่กำหนดเอง บันทึกที่กำหนดเอง ข้อผิดพลาดที่ไม่ร้ายแรง และอื่นๆ

หลังจากสร้างเกมแล้ว คุณจะใช้เมนูแก้ไขข้อบกพร่องและตรวจสอบผลลัพธ์เพื่อทำความเข้าใจมุมมองที่ไม่ซ้ำกันซึ่งจะช่วยให้คุณทราบว่าเกมทำงานอย่างไรในสภาพแวดล้อมจริง

สิ่งที่คุณจะได้เรียนรู้

  • ประเภทข้อผิดพลาดที่ Crashlytics ตรวจพบโดยอัตโนมัติ
  • ข้อผิดพลาดเพิ่มเติมที่บันทึกได้โดยตั้งใจ
  • วิธีเพิ่มข้อมูลเพิ่มเติมในข้อผิดพลาดเหล่านี้เพื่อให้เข้าใจได้ง่ายขึ้น

สิ่งที่ต้องมี

  • Unity (เวอร์ชันที่แนะนำขั้นต่ำคือ 2019+) โดยมีอย่างใดอย่างหนึ่งหรือทั้ง 2 อย่างต่อไปนี้
    • การรองรับการสร้าง iOS
    • การสนับสนุนการสร้าง Android
  • (สําหรับ Android เท่านั้น) Firebase CLI (ใช้เพื่ออัปโหลดสัญลักษณ์สําหรับรายงานข้อขัดข้อง)

2. ตั้งค่าสภาพแวดล้อมในการพัฒนาซอฟต์แวร์

ส่วนต่อไปนี้จะอธิบายวิธีดาวน์โหลดโค้ด Level Up with Firebase และเปิดใน Unity

โปรดทราบว่าเกมตัวอย่าง Level Up with Firebase นี้ใช้ใน Codelab อื่นๆ ของ Firebase + Unity ด้วย ดังนั้นคุณอาจทำภารกิจในส่วนนี้เสร็จแล้ว หากเป็นเช่นนั้น คุณสามารถไปที่ขั้นตอนสุดท้ายในหน้านี้ได้โดยตรง ซึ่งก็คือ "เพิ่ม Firebase SDK สำหรับ Unity"

ดาวน์โหลดรหัส

โคลนที่เก็บ GitHub ของ Codelab นี้จากบรรทัดคำสั่ง

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

หรือหากไม่ได้ติดตั้ง git คุณสามารถดาวน์โหลดที่เก็บเป็นไฟล์ ZIP

เปิด Level Up with Firebase ในโปรแกรมแก้ไข Unity

  1. เปิด Unity Hub แล้วคลิกลูกศรแบบเลื่อนลงข้างเปิดจากแท็บโปรเจ็กต์
  2. คลิกเพิ่มโปรเจ็กต์จากดิสก์
  3. ไปที่ไดเรกทอรีที่มีโค้ด แล้วคลิกตกลง
  4. หากมีข้อความแจ้ง ให้เลือกเวอร์ชัน Unity Editor ที่จะใช้และแพลตฟอร์มเป้าหมาย (Android หรือ iOS)
  5. คลิกชื่อโปรเจ็กต์ level-up-with-firebase แล้วโปรเจ็กต์จะเปิดขึ้นใน Unity Editor
  6. หากโปรแกรมแก้ไขไม่เปิดโดยอัตโนมัติ ให้เปิด MainGameScene ใน Assets > Hamster ในแท็บ Project ของ Unity Editor
    ff4ea3f3c0d29379.png

ดูข้อมูลเพิ่มเติมเกี่ยวกับการติดตั้งและใช้ Unity ได้ที่การทำงานใน Unity

3. เพิ่ม Firebase ไปยังโปรเจ็กต์ Unity

สร้างโปรเจ็กต์ Firebase

  1. ลงชื่อเข้าใช้คอนโซล Firebase โดยใช้บัญชี Google
  2. คลิกปุ่มเพื่อสร้างโปรเจ็กต์ใหม่ แล้วป้อนชื่อโปรเจ็กต์ (เช่น Mechahamster Codelab)
  3. คลิกต่อไป
  4. หากได้รับแจ้ง ให้อ่านและยอมรับข้อกำหนดของ Firebase แล้วคลิกต่อไป
  5. (ไม่บังคับ) เปิดใช้ความช่วยเหลือจาก AI ในคอนโซล Firebase (เรียกว่า "Gemini ใน Firebase")
  6. สำหรับโค้ดแล็บนี้ คุณต้องใช้ Google Analytics เพื่อใช้ผลิตภัณฑ์ Firebase ได้อย่างมีประสิทธิภาพสูงสุด ดังนั้นให้เปิดตัวเลือก Google Analytics ไว้ ทำตามวิธีการบนหน้าจอเพื่อตั้งค่า Google Analytics
  7. คลิกสร้างโปรเจ็กต์ รอให้ระบบจัดสรรโปรเจ็กต์ แล้วคลิกดำเนินการต่อ

ลงทะเบียนแอปกับ Firebase

  1. ยังอยู่ในคอนโซล Firebase จากตรงกลางหน้าภาพรวมโปรเจ็กต์ ให้คลิกไอคอน Unity เพื่อเปิดเวิร์กโฟลว์การตั้งค่า หรือหากเพิ่มแอปไปยังโปรเจ็กต์ Firebase แล้ว ให้คลิกเพิ่มแอปเพื่อแสดงตัวเลือกแพลตฟอร์ม
  2. เลือกเพื่อลงทะเบียนทั้งเป้าหมายของบิลด์ Apple (iOS) และ Android
  3. ป้อนรหัสเฉพาะแพลตฟอร์มของโปรเจ็กต์ Unity สำหรับ Codelab นี้ ให้ป้อนข้อมูลต่อไปนี้
  4. (ไม่บังคับ) ป้อนชื่อเล่นเฉพาะแพลตฟอร์มของโปรเจ็กต์ Unity
  5. คลิกลงทะเบียนแอป แล้วไปที่ส่วนดาวน์โหลดไฟล์การกำหนดค่า

เพิ่มไฟล์การกำหนดค่า Firebase

หลังจากคลิกลงทะเบียนแอปแล้ว ระบบจะแจ้งให้คุณดาวน์โหลดไฟล์การกำหนดค่า 2 ไฟล์ (ไฟล์การกำหนดค่า 1 ไฟล์สำหรับแต่ละเป้าหมายการสร้าง) โปรเจ็กต์ Unity ต้องมีข้อมูลเมตาของ Firebase ในไฟล์เหล่านี้เพื่อเชื่อมต่อกับ Firebase

  1. ดาวน์โหลดไฟล์การกำหนดค่าทั้ง 2 ไฟล์ที่มีอยู่
    • สำหรับ Apple (iOS): ดาวน์โหลด GoogleService-Info.plist
    • สำหรับ Android: ดาวน์โหลด google-services.json
  2. เปิดหน้าต่างโปรเจ็กต์ของโปรเจ็กต์ Unity จากนั้นย้ายไฟล์การกำหนดค่าทั้ง 2 ไฟล์ไปยังโฟลเดอร์ชิ้นงาน
  3. กลับไปที่คอนโซล Firebase ในเวิร์กโฟลว์การตั้งค่า ให้คลิกถัดไป แล้วไปที่เพิ่ม Firebase SDK สำหรับ Unity

เพิ่ม Firebase SDK สำหรับ Unity

  1. คลิกดาวน์โหลด Firebase Unity SDK ในคอนโซล Firebase
  2. แยกไฟล์ SDK ไว้ที่ใดก็ได้ที่คุณสะดวก
  3. ในโปรเจ็กต์ Unity แบบเปิด ให้ไปที่ชิ้นงาน > นำเข้าแพ็กเกจ > แพ็กเกจที่กำหนดเอง
  4. ในกล่องโต้ตอบนำเข้าแพ็กเกจ ให้ไปที่ไดเรกทอรีที่มี SDK ที่แยกไฟล์แล้ว เลือก FirebaseAnalytics.unitypackage แล้วคลิกเปิด
  5. จากกล่องโต้ตอบนำเข้าแพ็กเกจ Unity ที่ปรากฏขึ้น ให้คลิกนำเข้า
  6. ทำขั้นตอนก่อนหน้าซ้ำเพื่อนำเข้า FirebaseCrashlytics.unitypackage
  7. กลับไปที่คอนโซล Firebase แล้วคลิกถัดไปในเวิร์กโฟลว์การตั้งค่า

ดูข้อมูลเพิ่มเติมเกี่ยวกับการเพิ่ม Firebase SDK ลงในโปรเจ็กต์ Unity ได้ที่ตัวเลือกการติดตั้ง Unity เพิ่มเติม

4. ตั้งค่า Crashlytics ในโปรเจ็กต์ Unity

หากต้องการใช้ Crashlytics ในโปรเจ็กต์ Unity คุณจะต้องทำตามขั้นตอนการตั้งค่าเพิ่มเติมอีก 2-3 ขั้นตอน แน่นอนว่าคุณจะต้องเริ่มต้นใช้งาน SDK นอกจากนี้ คุณยังต้องอัปโหลดสัญลักษณ์เพื่อให้เห็น Stacktrace ที่มีสัญลักษณ์ในคอนโซล Firebase และต้องบังคับให้เกิดข้อขัดข้องในการทดสอบเพื่อให้แน่ใจว่า Firebase ได้รับเหตุการณ์ข้อขัดข้อง

เริ่มต้น SDK ของ Crashlytics

  1. ใน Assets/Hamster/Scripts/MainGame.cs ให้เพิ่มข้อความ using ต่อไปนี้
    using Firebase.Crashlytics;
using Firebase.Extensions;
    โมดูลแรกช่วยให้คุณใช้วิธีการจาก Crashlytics SDK ได้ และโมดูลที่ 2 มีส่วนขยายบางอย่างสำหรับ 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+ (แพลตฟอร์มของ Apple)

  1. จากกล่องโต้ตอบการตั้งค่าการสร้าง ให้ส่งออกโปรเจ็กต์ไปยังพื้นที่ทำงาน Xcode
  2. สร้างแอป
    สำหรับแพลตฟอร์ม Apple ปลั๊กอิน Firebase Unity Editor จะกำหนดค่าโปรเจ็กต์ Xcode โดยอัตโนมัติเพื่อสร้างและอัปโหลดไฟล์สัญลักษณ์ที่เข้ากันได้กับ Crashlytics ไปยังเซิร์ฟเวอร์ Firebase สำหรับแต่ละบิลด์ คุณต้องมีข้อมูลสัญลักษณ์นี้จึงจะดู Stack Trace ที่มีสัญลักษณ์ในแดชบอร์ด Crashlytics ได้

Android

  1. (เฉพาะระหว่างการตั้งค่าครั้งแรก ไม่ใช่สำหรับการสร้างแต่ละครั้ง) ตั้งค่าบิลด์โดยทำดังนี้
    1. สร้างโฟลเดอร์ใหม่ชื่อ Builds ที่รูทของไดเรกทอรีโปรเจ็กต์ (เช่น เป็นโฟลเดอร์ที่อยู่ระดับเดียวกับไดเรกทอรี Assets) จากนั้นสร้างโฟลเดอร์ย่อยชื่อ Android
    2. ใน File > Build Settings > Player Settings > Configuration ให้ตั้งค่า Scripting Backend เป็น IL2CPP
      • โดยทั่วไปแล้ว IL2CPP จะทำให้บิลด์มีขนาดเล็กลงและมีประสิทธิภาพดีขึ้น
      • นอกจากนี้ IL2CPP ยังเป็นตัวเลือกเดียวที่ใช้ได้ใน iOS และการเลือกตัวเลือกนี้ที่นี่จะช่วยให้ทั้ง 2 แพลตฟอร์มมีความเท่าเทียมกันมากขึ้น และทำให้การแก้ไขข้อบกพร่องที่แตกต่างกันระหว่าง 2 แพลตฟอร์ม (หากคุณเลือกสร้างทั้ง 2 แพลตฟอร์ม) ง่ายขึ้น
  2. สร้างแอป ในไฟล์ > การตั้งค่าการสร้าง ให้ทำดังนี้
    1. ตรวจสอบว่าได้เลือก Create symbols.zip แล้ว (หรือหากมีเมนูแบบเลื่อนลง ให้เลือกการแก้ไขข้อบกพร่อง)
    2. สร้าง APK จาก Unity Editor โดยตรงไปยังโฟลเดอร์ย่อย Builds/Android ที่คุณเพิ่งสร้าง
  3. เมื่อบิลด์เสร็จสมบูรณ์แล้ว คุณต้องสร้างไฟล์สัญลักษณ์ที่เข้ากันได้กับ Crashlytics และอัปโหลดไปยังเซิร์ฟเวอร์ Firebase คุณต้องระบุข้อมูลสัญลักษณ์นี้เพื่อดูสแต็กเทรซที่แทนที่ด้วยสัญลักษณ์สำหรับข้อขัดข้องของไลบรารีเนทีฟในแดชบอร์ด Crashlytics

    สร้างและอัปโหลดไฟล์สัญลักษณ์นี้โดยเรียกใช้คำสั่ง Firebase CLI ต่อไปนี้
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
    • FIREBASE_APP_ID: รหัสแอป Android ของ Firebase (ไม่ใช่ชื่อแพ็กเกจ) ค้นหาค่านี้ในไฟล์ 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 โดยอัตโนมัติเพื่ออัปโหลดไฟล์สัญลักษณ์
    • Android: เรียกใช้คำสั่ง crashlytics:symbols:upload ของ Firebase CLI เพื่ออัปโหลดไฟล์สัญลักษณ์
  3. เรียกใช้แอป เมื่อแอปทํางานแล้ว ให้ดูบันทึกของอุปกรณ์และรอให้เกิดข้อยกเว้นจาก CrashlyticsTester
    • iOS: ดูบันทึกในบานหน้าต่างด้านล่างของ Xcode
    • Android: ดูบันทึกโดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล: adb logcat
  4. ไปที่แดชบอร์ด Crashlytics เพื่อดูข้อยกเว้น คุณจะเห็นปัญหาในตารางปัญหาที่ด้านล่างของแดชบอร์ด คุณจะได้ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีสำรวจรายงานเหล่านี้ใน Codelab ในภายหลัง
  5. เมื่อยืนยันว่าอัปโหลดเหตุการณ์ไปยัง Crashlytics แล้ว ให้เลือก EmptyObject GameObject ที่คุณแนบเหตุการณ์ไว้ นำเฉพาะคอมโพเนนต์ CrashlyticsTester ออก แล้วบันทึกฉากเพื่อคืนค่าให้เป็นสภาพเดิม

5. เปิดใช้และทำความเข้าใจเมนูแก้ไขข้อบกพร่อง

ตอนนี้คุณได้เพิ่ม Crashlytics ลงในโปรเจ็กต์ Unity, ตั้งค่าเสร็จสมบูรณ์ และยืนยันว่า Crashlytics SDK อัปโหลดเหตุการณ์ไปยัง Firebase แล้ว ตอนนี้คุณจะสร้างเมนูในโปรเจ็กต์ Unity ซึ่งจะแสดงวิธีใช้ฟังก์ชันการทำงานของ Crashlytics ขั้นสูงเพิ่มเติมในเกม โปรเจ็กต์ Unity Level Up with Firebase มีเมนูแก้ไขที่ซ่อนอยู่แล้ว ซึ่งคุณจะทำให้มองเห็นได้และเขียนฟังก์ชันการทำงานสำหรับเมนูนี้

เปิดใช้เมนูแก้ไขข้อบกพร่อง

ปุ่มเข้าถึงเมนูแก้ไขข้อบกพร่องมีอยู่ในโปรเจ็กต์ Unity แต่ยังไม่ได้เปิดใช้ในขณะนี้ คุณต้องเปิดใช้ปุ่มเพื่อเข้าถึงจาก MainMenu Prefab โดยทำดังนี้

  1. ใน Unity Editor ให้เปิด Prefab ที่ชื่อ MainMenu4148538cbe9f36c5.png
  2. ในลำดับชั้นของ Prefab ให้ค้นหาออบเจ็กต์ย่อยที่ปิดใช้อยู่ชื่อ DebugMenuButton แล้วเลือก816f8f9366280f6c.png
  3. เปิดใช้ DebugMenuButton โดยเลือกช่องที่มุมซ้ายบนทางด้านซ้ายของช่องข้อความที่มี DebugMenuButton8a8089d2b4886da2.png
  4. บันทึก Prefab
  5. เรียกใช้เกมในเอดิเตอร์หรือบนอุปกรณ์ ตอนนี้คุณควรเข้าถึงเมนูได้แล้ว

ดูตัวอย่างและทำความเข้าใจเนื้อหาของเมธอดสำหรับเมนูแก้ไขข้อบกพร่อง

ใน Codelab นี้ คุณจะได้เขียนเนื้อหาของเมธอดสำหรับเมธอด Crashlytics สำหรับการแก้ไขข้อบกพร่องที่กำหนดค่าไว้ล่วงหน้าบางรายการ อย่างไรก็ตาม ในโปรเจ็กต์ Unity ของ Level Up with Firebase จะมีการกําหนดและเรียกใช้เมธอดจาก DebugMenu.cs

แม้ว่าบางวิธีเหล่านี้จะเรียกใช้เมธอด Crashlytics และแสดงข้อผิดพลาด แต่ความสามารถของ Crashlytics ในการตรวจจับข้อผิดพลาดเหล่านี้ไม่ได้ขึ้นอยู่กับการเรียกใช้เมธอดเหล่านั้นก่อน แต่ข้อมูลที่เพิ่มโดยวิธีเหล่านี้จะช่วยปรับปรุงรายงานข้อขัดข้องที่สร้างขึ้นจากการตรวจหาข้อผิดพลาดโดยอัตโนมัติ

เปิด DebugMenu.cs แล้วค้นหาวิธีการต่อไปนี้

วิธีการสร้างและใส่คำอธิบายประกอบปัญหาของ Crashlytics

  • CrashNow
  • LogNonfatalError
  • LogStringsAndCrashNow
  • SetAndOverwriteCustomKeyThenCrash
  • SetLogsAndKeysBeforeANR

วิธีการบันทึกเหตุการณ์ Analytics เพื่อช่วยในการแก้ไขข้อบกพร่อง

  • LogProgressEventWithStringLiterals
  • LogIntScoreWithBuiltInEventAndParams

ในขั้นตอนต่อๆ ไปของโค้ดแล็บนี้ คุณจะได้ใช้เมธอดเหล่านี้และเรียนรู้ว่าเมธอดเหล่านี้ช่วยรับมือกับสถานการณ์เฉพาะที่อาจเกิดขึ้นในการพัฒนาเกมได้อย่างไร

6. ตรวจสอบว่ามีการส่งรายงานข้อขัดข้องในระหว่างการพัฒนา

ก่อนที่จะเริ่มใช้เมธอดการแก้ไขข้อบกพร่องเหล่านี้และดูว่าเมธอดเหล่านี้ส่งผลต่อรายงานข้อขัดข้องอย่างไร โปรดตรวจสอบว่าคุณเข้าใจวิธีรายงานเหตุการณ์ไปยัง Crashlytics

สำหรับโปรเจ็กต์ Unity ระบบจะเขียนเหตุการณ์ข้อขัดข้องและข้อยกเว้นในเกมลงในดิสก์ทันที สําหรับข้อยกเว้นที่ไม่ได้จัดการซึ่งไม่ทําให้เกมขัดข้อง (เช่น ข้อยกเว้น C# ที่ไม่ได้จัดการในตรรกะของเกม) คุณสามารถให้ SDK ของ Crashlytics รายงานเป็นเหตุการณ์ร้ายแรงได้โดยตั้งค่าพร็อพเพอร์ตี้ Crashlytics.ReportUncaughtExceptionsAsFatal เป็น true เมื่อเริ่มต้น Crashlytics ในโปรเจ็กต์ Unity ระบบจะรายงานเหตุการณ์เหล่านี้ไปยัง Crashlytics แบบเรียลไทม์โดยที่ผู้ใช้ปลายทางไม่ต้องรีสตาร์ทเกม โปรดทราบว่าระบบจะรายงานข้อขัดข้องที่เกิดจากโค้ดเนทีฟเป็นเหตุการณ์ร้ายแรงเสมอ และจะส่งไปพร้อมกันเมื่อผู้ใช้ปลายทางรีสตาร์ทเกม

นอกจากนี้ โปรดทราบถึงความแตกต่างเล็กๆ น้อยๆ แต่มีความสำคัญต่อไปนี้เกี่ยวกับวิธีที่สภาพแวดล้อมรันไทม์ต่างๆ ส่งข้อมูล Crashlytics ไปยัง Firebase

โปรแกรมจำลอง iOS:

  • ระบบจะรายงานข้อมูล Crashlytics ก็ต่อเมื่อคุณยกเลิกการเชื่อมต่อ Xcode จากเครื่องจำลองเท่านั้น หาก Xcode แนบอยู่ Xcode จะตรวจจับข้อผิดพลาดที่ต้นทาง ซึ่งจะป้องกันการส่งข้อมูล

อุปกรณ์จริงบนอุปกรณ์เคลื่อนที่ (Android และ iOS):

  • เฉพาะ Android: ระบบจะรายงาน ANR ใน Android 11 ขึ้นไปเท่านั้น และจะรายงาน ANR และเหตุการณ์ที่ไม่ร้ายแรงในการเรียกใช้ครั้งถัดไป

Unity Editor:

ทดสอบการขัดข้องของเกมได้ง่ายๆ เพียงกดปุ่มใน CrashNow()

หลังจากตั้งค่า Crashlytics ในเกมแล้ว SDK ของ Crashlytics จะบันทึกข้อขัดข้องและข้อยกเว้นที่ไม่ได้จัดการโดยอัตโนมัติ แล้วอัปโหลดไปยัง Firebase เพื่อทำการวิเคราะห์ และรายงานจะแสดงในแดชบอร์ด Crashlytics ในคอนโซล Firebase

  1. หากต้องการแสดงให้เห็นว่าการดำเนินการนี้เป็นแบบอัตโนมัติจริง ให้เปิด DebugMenu.cs แล้วเขียนทับเมธอด CrashNow() ดังนี้
    void CrashNow()
{
    TestCrash();
}
  2. สร้างแอป
  3. (Android เท่านั้น) อัปโหลดสัญลักษณ์โดยเรียกใช้คำสั่ง Firebase CLI ต่อไปนี้
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  4. แตะปุ่มขัดข้องตอนนี้ แล้วไปที่ขั้นตอนถัดไปของ Codelab นี้เพื่อดูวิธีดูและตีความรายงานข้อขัดข้อง

7. ทําความเข้าใจรายงานปัญหาในคอนโซล Firebase

เมื่อดูรายงานข้อขัดข้อง คุณต้องทราบข้อมูลเพิ่มเติมเล็กน้อยเกี่ยวกับวิธีใช้รายงานให้เกิดประโยชน์สูงสุด แต่ละวิธีที่คุณเขียนจะแสดงวิธีเพิ่มข้อมูลประเภทต่างๆ ลงในรายงาน Crashlytics

  1. แตะปุ่มขัดข้องตอนนี้ แล้วรีสตาร์ทแอป
  2. ไปที่แดชบอร์ด Crashlytics เลื่อนลงไปที่ตารางปัญหาที่ด้านล่างของแดชบอร์ด ซึ่ง Crashlytics จะจัดกลุ่มเหตุการณ์ที่มีสาเหตุหลักเดียวกันทั้งหมดไว้ใน "ปัญหา"
  3. คลิกปัญหาใหม่ที่แสดงในตารางปัญหา การทำเช่นนี้จะแสดงสรุปเหตุการณ์เกี่ยวกับเหตุการณ์แต่ละรายการที่ส่งไปยัง Firebase

    คุณควรเห็นลักษณะคล้ายกับภาพหน้าจอด้านล่าง สังเกตว่าสรุปเหตุการณ์จะแสดงการติดตามสแต็กของการเรียกที่ทําให้เกิดข้อขัดข้องอย่างโดดเด่น40c96abe7f90c3aa.png

ข้อมูลเมตาเพิ่มเติม

อีกแท็บที่มีประโยชน์คือแท็บข้อมูลเมตาของ Unity ส่วนนี้จะแจ้งให้คุณทราบเกี่ยวกับแอตทริบิวต์ของอุปกรณ์ที่เกิดเหตุการณ์ รวมถึงฟีเจอร์ทางกายภาพ รุ่น/ข้อมูลจำเพาะของ CPU และเมตริก GPU ทุกประเภท

ตัวอย่างที่ข้อมูลในแท็บนี้อาจมีประโยชน์มีดังนี้
สมมติว่าเกมของคุณใช้ Shader อย่างหนักเพื่อให้ได้รูปลักษณ์ที่ต้องการ แต่โทรศัพท์บางรุ่นไม่มี GPU ที่สามารถแสดงผลฟีเจอร์นี้ได้ ข้อมูลในแท็บข้อมูลเมตาของ Unity จะช่วยให้คุณทราบได้ดียิ่งขึ้นว่าแอปควรทดสอบฮาร์ดแวร์ใดเมื่อตัดสินใจว่าจะเปิดใช้ฟีเจอร์ใดโดยอัตโนมัติหรือปิดใช้ทั้งหมด

แม้ว่าข้อบกพร่องหรือการขัดข้องอาจไม่เคยเกิดขึ้นในอุปกรณ์ของคุณ แต่เนื่องจากอุปกรณ์ Android มีความหลากหลายอย่างมาก จึงช่วยให้เข้าใจ "จุดที่ร้อน" ของอุปกรณ์ของกลุ่มเป้าหมายได้ดียิ่งขึ้น

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. (Android เท่านั้น) อัปโหลดสัญลักษณ์โดยเรียกใช้คำสั่ง Firebase CLI ต่อไปนี้
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  5. แตะปุ่มบันทึกข้อผิดพลาดที่ไม่ร้ายแรง แล้วรีสตาร์ทแอป
  6. ไปที่แดชบอร์ด Crashlytics แล้วคุณจะเห็นสิ่งที่คล้ายกับที่คุณเห็นในขั้นตอนสุดท้ายของ Codelab นี้
  7. แต่คราวนี้ให้จำกัดตัวกรองประเภทเหตุการณ์เป็นไม่ร้ายแรง เพื่อให้คุณเห็นเฉพาะข้อผิดพลาดที่ไม่ร้ายแรง เช่น ข้อผิดพลาดที่คุณเพิ่งบันทึก
    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. (Android เท่านั้น) อัปโหลดสัญลักษณ์โดยเรียกใช้คำสั่ง 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. (Android เท่านั้น) อัปโหลดสัญลักษณ์โดยเรียกใช้คำสั่ง 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. (Android เท่านั้น) ใช้คีย์และบันทึกที่กำหนดเองเพื่อทำความเข้าใจและวินิจฉัย ANR

ข้อผิดพลาดแอปพลิเคชันไม่ตอบสนอง (ANR) เป็นปัญหาประเภทหนึ่งที่นักพัฒนาแอป Android แก้ไขข้อบกพร่องได้ยากที่สุด ANR จะเกิดขึ้นเมื่อแอปไม่ตอบสนองต่ออินพุตนานเกิน 5 วินาที หากเกิดกรณีนี้ขึ้น แสดงว่าแอปค้างหรือทำงานช้ามาก ระบบจะแสดงกล่องโต้ตอบต่อผู้ใช้ และผู้ใช้สามารถเลือกได้ว่าจะ "รอ" หรือ "ปิดแอป"

ANR เป็นประสบการณ์ของผู้ใช้ที่ไม่ดี และ (ดังที่กล่าวไว้ในลิงก์ ANR ด้านบน) อาจส่งผลต่อการค้นพบได้ของแอปใน Google Play Store เนื่องจากมีความซับซ้อนและมักเกิดจากโค้ดแบบมัลติเธรดที่มีลักษณะการทำงานแตกต่างกันอย่างมากในโทรศัพท์รุ่นต่างๆ การจำลอง ANR ขณะแก้ไขข้อบกพร่องจึงมักเป็นเรื่องยากมากหรือแทบเป็นไปไม่ได้ ดังนั้น การเข้าถึงปัญหาด้วยการวิเคราะห์และนิรนัยจึงมักเป็นวิธีที่ดีที่สุด

ในวิธีนี้ เราจะใช้ร่วมกันระหว่าง 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. หากดูบันทึกในแท็บบันทึกของสรุปเหตุการณ์ คุณจะเห็นว่าวิธีการสุดท้ายที่บันทึกว่าเสร็จสมบูรณ์คือ DoSevereWork
    5a4bec1cf06f6984.png

    ในทางตรงกันข้าม วิธีการสุดท้ายที่ระบุว่าเริ่มต้นคือ DoExtremeWork ซึ่งบ่งชี้ว่า ANR เกิดขึ้นระหว่างวิธีการนี้ และเกมปิดก่อนที่จะบันทึก DoExtremeWork

    89d86d5f598ecf3a.png

ทำไมต้องดำเนินการแบบนี้

  • การสร้าง ANR ซ้ำเป็นเรื่องยากมาก ดังนั้นการได้รับข้อมูลที่ครบถ้วนเกี่ยวกับพื้นที่โค้ดและเมตริกจึงมีความสำคัญอย่างยิ่งต่อการค้นหาโดยการอนุมาน
  • เมื่อมีข้อมูลที่จัดเก็บไว้ในคีย์ที่กำหนดเองแล้ว คุณจะทราบว่าเทรดแบบไม่พร้อมกันใดใช้เวลานานที่สุดในการเรียกใช้ และเทรดใดที่เสี่ยงต่อการทริกเกอร์ ANR ข้อมูลเชิงตรรกะและตัวเลขที่เกี่ยวข้องในลักษณะนี้จะแสดงให้เห็นว่าส่วนใดในโค้ดของคุณที่จำเป็นต้องเพิ่มประสิทธิภาพมากที่สุด

12. การสอดแทรกเหตุการณ์ Analytics เพื่อเพิ่มคุณค่าให้กับรายงาน

นอกจากนี้ คุณยังเรียกใช้เมธอดต่อไปนี้จากเมนูแก้ไขข้อบกพร่องได้ด้วย แต่แทนที่จะสร้างปัญหาด้วยตัวเอง เมธอดเหล่านี้จะใช้ Google Analytics เป็นแหล่งข้อมูลอีกแหล่งหนึ่งเพื่อให้เข้าใจการทำงานของเกมได้ดียิ่งขึ้น

คุณควรใช้วิธีการเหล่านี้ร่วมกับวิธีการอื่นๆ ซึ่งแตกต่างจากวิธีการอื่นๆ ที่คุณเขียนในโค้ดแล็บนี้ เรียกใช้เมธอดเหล่านี้ (โดยกดปุ่มที่เกี่ยวข้องในเมนูแก้ไขข้อบกพร่อง) ตามลำดับใดก็ได้ก่อนที่จะเรียกใช้เมธอดอื่น จากนั้นเมื่อตรวจสอบข้อมูลในปัญหา 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. (Android เท่านั้น) อัปโหลดสัญลักษณ์โดยเรียกใช้คำสั่ง Firebase CLI ต่อไปนี้
    firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
  4. กดปุ่มต่อไปนี้อย่างน้อย 1 ปุ่ม 1 ครั้งขึ้นไปเพื่อเรียกใช้ฟังก์ชันด้านบน
    • เหตุการณ์สตริงบันทึก
    • Log Int Event
  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 อย่างชัดเจน

ขั้นตอนถัดไป

ไปที่ Codelab Instrument your Unity game with Remote Config ซึ่งคุณจะได้เรียนรู้เกี่ยวกับการใช้การกำหนดค่าระยะไกลและการทดสอบ A/B ใน Unity