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

1. บทนำ

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

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

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

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

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

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

สิ่งที่คุณต้องการ

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

2. ตั้งค่าสภาพแวดล้อมการพัฒนาของคุณ

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

โปรดทราบว่าตัวอย่างเกม Level Up ด้วย Firebase นี้ถูกใช้โดย Codelab อื่นๆ ของ Firebase + Unity ดังนั้นคุณอาจทำงานในส่วนนี้เสร็จสิ้นแล้ว หากเป็นเช่นนั้น คุณสามารถไปที่ขั้นตอนสุดท้ายของหน้านี้ได้โดยตรง: "เพิ่ม Firebase SDK สำหรับ 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 ที่จะใช้และแพลตฟอร์มเป้าหมายของคุณ (Android หรือ iOS)
  5. คลิกที่ชื่อโปรเจ็กต์ Level-up-with-firebase และโปรเจ็กต์จะเปิดขึ้นในตัวแก้ไข Unity
  6. หากโปรแกรมแก้ไขของคุณไม่เปิดโดยอัตโนมัติ ให้เปิด MainGameScene ใน Assets > Hamster ในแท็บ 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 สำหรับ Codelab นี้ ให้ป้อนข้อมูลต่อไปนี้:
  4. (ไม่บังคับ) ป้อนชื่อเล่นเฉพาะแพลตฟอร์มของโปรเจ็กต์ Unity
  5. คลิกลง ทะเบียนแอป จากนั้นไปที่ส่วน ดาวน์โหลดไฟล์กำหนดค่า

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

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

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

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

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

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

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

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

เริ่มต้น Crashlytics SDK

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

หุ่นยนต์

  1. (ระหว่างการตั้งค่าครั้งแรกเท่านั้น ไม่ใช่สำหรับแต่ละบิลด์) ตั้งค่าบิลด์ของคุณ:
    1. สร้างโฟลเดอร์ใหม่ชื่อ Builds ที่รากของไดเร็กทอรีโปรเจ็กต์ของคุณ (เช่น เป็นโฟลเดอร์พี่น้องของไดเร็กทอรี Assets ของคุณ) จากนั้นสร้างโฟลเดอร์ย่อยชื่อ Android
    2. ใน File > Build Settings > Player Settings > Configuration ให้ตั้งค่า Scripting Backend เป็น IL2CPP
      • โดยทั่วไป IL2CPP จะทำให้บิลด์มีขนาดเล็กลงและมีประสิทธิภาพดีขึ้น
      • นอกจากนี้ IL2CPP ยังเป็นตัวเลือกเดียวที่ใช้ได้บน iOS และการเลือกที่นี่จะทำให้ทั้งสองแพลตฟอร์มมีความเท่าเทียมกันที่ดีขึ้น และทำให้การแก้ไขจุดบกพร่องระหว่างทั้งสอง (หากคุณเลือกที่จะสร้างทั้งสองแพลตฟอร์ม) ง่ายขึ้น
  2. สร้างแอปของคุณ ใน ไฟล์ > การตั้งค่าบิวด์ ดำเนินการต่อไปนี้:
    1. ตรวจสอบให้แน่ใจว่าได้ทำ เครื่องหมายที่ Create symbols.zip แล้ว (หรือหากมีรายการแบบเลื่อนลง ให้เลือก Debugging )
    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 : รหัสแอป Firebase Android ของคุณ (ไม่ใช่ชื่อแพ็คเกจ) ค้นหาค่านี้ในไฟล์ google-services.json ที่คุณดาวน์โหลดไว้ก่อนหน้านี้ มันคือค่า mobilesdk_app_id
      ตัวอย่างรหัสแอป Android ของ Firebase: 1:567383003300:android:17104a2ced0c9b9b
    • PATH/TO/SYMBOLS : เส้นทางของไฟล์สัญลักษณ์ zip ที่สร้างขึ้นในไดเร็กทอรี Builds/Android เมื่อบิลด์ของคุณเสร็จสิ้น (เช่น Builds/Android/myapp-1.0-v100.symbols.zip )

บังคับให้การทดสอบขัดข้องเพื่อตั้งค่าให้เสร็จสิ้น

หากต้องการตั้งค่า Crashlytics ให้เสร็จสิ้นและดูข้อมูลเริ่มต้นในหน้าแดชบอร์ด Crashlytics ของคอนโซล Firebase คุณจะต้องบังคับการทดสอบข้อขัดข้อง

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

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

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

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

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

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

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

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

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

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

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

  • CrashNow
  • LogNonfatalError
  • LogStringsAndCrashNow
  • SetAndOverwriteCustomKeyThenCrash
  • SetLogsAndKeysBeforeANR

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

  • LogProgressEventWithStringLiterals
  • LogIntScoreWithBuiltInEventAndParams

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

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

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

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

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

เครื่องจำลอง iOS:

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

อุปกรณ์ทางกายภาพเคลื่อนที่ (Android และ iOS):

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

ตัวแก้ไขความสามัคคี:

ทดสอบการหยุดเกมของคุณด้วยการกดปุ่มเพียงปุ่มเดียวใน CrashNow()

หลังจากตั้งค่า Crashlytics ในเกมของคุณแล้ว Crashlytics SDK จะบันทึกข้อขัดข้องและข้อยกเว้นที่ตรวจไม่พบโดยอัตโนมัติ แล้วอัปโหลดไปยัง 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. แตะปุ่ม Crash Now จากนั้นรีสตาร์ทแอปของคุณ
  2. ไปที่ แดชบอร์ด Crashlytics เลื่อนลงไปที่ตาราง ปัญหา ที่ด้านล่างของแดชบอร์ดโดย Crashlytics จะจัดกลุ่มเหตุการณ์ที่มีสาเหตุเดียวกันทั้งหมดเป็น "ปัญหา"
  3. คลิกที่ปัญหาใหม่ที่แสดงอยู่ในตาราง ปัญหา การทำเช่นนี้จะแสดง สรุปกิจกรรม เกี่ยวกับแต่ละเหตุการณ์ที่ส่งไปยัง Firebase

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

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

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

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

แม้ว่าข้อบกพร่องหรือข้อขัดข้องอาจไม่เกิดขึ้นบนอุปกรณ์ ของคุณ แต่เนื่องจากอุปกรณ์ 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. แตะปุ่ม Log Strings และ Crash Now จากนั้นรีสตาร์ทแอปของคุณ
  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

หนึ่งในประเภทปัญหาที่ยากที่สุดในการแก้ไขสำหรับนักพัฒนา Android คือข้อผิดพลาด แอปพลิเคชันไม่ตอบสนอง (ANR) 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 เป็นแหล่งข้อมูลอื่นเพื่อทำความเข้าใจการทำงานของเกมของคุณให้ดียิ่งขึ้น

ไม่เหมือนกับวิธีอื่นๆ ที่คุณเขียนใน Codelab นี้ คุณควรใช้วิธีการเหล่านี้ร่วมกับวิธีอื่นๆ เรียกวิธีการเหล่านี้ (โดยการกดปุ่มที่เกี่ยวข้องในเมนูแก้ไขข้อบกพร่อง) ตามลำดับที่คุณต้องการก่อนที่จะเรียกใช้วิธีใดวิธีหนึ่ง จากนั้น เมื่อคุณตรวจสอบข้อมูลในปัญหา 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. กดอย่างน้อยหนึ่งปุ่มต่อไปนี้อย่างน้อยหนึ่งครั้งเพื่อเรียกใช้ฟังก์ชันข้างต้น:
    • บันทึกเหตุการณ์สตริง
    • เข้าสู่ระบบเหตุการณ์ Int
  5. กดปุ่ม Crash Now
  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 ของคุณด้วย Codelab การกำหนดค่าระยะไกล ซึ่งคุณจะได้เรียนรู้เกี่ยวกับการใช้การกำหนดค่าระยะไกลและการทดสอบ A/B ใน Unity