หน้านี้ได้รับการแปลโดย Cloud Translation API

วัดคุมเกม Unity ด้วยการกำหนดค่าระยะไกลของ Firebase

1. บทนำ

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

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

หากต้องการให้แอปทํางานตามที่ต้องการ คุณจะต้องตั้งค่าเริ่มต้นสําหรับค่าในโค้ดเกมตัวอย่าง และค่าเหล่านี้สามารถถูกลบล้างได้ด้วยค่าที่คุณตั้งค่าในการกำหนดค่าระยะไกลใน Firebase Console

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

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

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

Unity 2019.1.0f1 ขึ้นไปที่รองรับการสร้าง iOS และ/หรือ Android
อุปกรณ์ Android/iOS จริงหรือโปรแกรมจำลองเพื่อสร้างและเรียกใช้เกม

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

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

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

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

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

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

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

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

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

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

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

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

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

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

เปิดคอนโซล Firebase แล้วคลิกไอคอน Unity ตรงกลางหน้าภาพรวมโปรเจ็กต์เพื่อเปิดเวิร์กโฟลว์การตั้งค่า หรือหากเพิ่มแอปไปยังโปรเจ็กต์ Firebase แล้ว ให้คลิกเพิ่มแอปเพื่อแสดงตัวเลือกแพลตฟอร์ม
เลือกเพื่อลงทะเบียนทั้งเป้าหมายของบิลด์ Apple (iOS) และ Android
ป้อนรหัสเฉพาะแพลตฟอร์มของโปรเจ็กต์ Unity สำหรับ Codelab นี้ ให้ป้อนข้อมูลต่อไปนี้
- สำหรับ Apple (iOS) - ป้อน com.google.firebase.level-up ในช่องรหัสชุด iOS
- สำหรับ Android - ป้อน com.google.firebase.level_up ในช่องชื่อแพ็กเกจ Android
คุณจะป้อนชื่อเล่นเฉพาะแพลตฟอร์มของโปรเจ็กต์ Unity หรือไม่ก็ได้
คลิกลงทะเบียนแอป แล้วไปที่ส่วนดาวน์โหลดไฟล์การกำหนดค่า
ทำกระบวนการซ้ำสำหรับเป้าหมายการสร้างที่คุณไม่ได้ทำในครั้งแรก

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

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

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

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

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

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

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

4. ตั้งค่าเริ่มต้นของการกำหนดค่าระยะไกลและดึงค่าใหม่

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

หากต้องการดึงค่าใหม่จากการกำหนดค่าระยะไกล คุณต้องใช้วิธีการที่ยังไม่ได้ใช้หลายวิธีซึ่งมีอยู่ในไฟล์ Assets/Hamster/Scripts/MainGame.cs อยู่แล้ว

เพิ่มข้อความ using ต่อไปนี้ลงใน MainGame.cs
```
using Firebase.Crashlytics;
using Firebase.Extensions;
using Firebase.RemoteConfig;
```
โมดูล Firebase.Extensions มีส่วนขยายบางอย่างสำหรับ C# Tasks API ซึ่งจะช่วยให้การจัดการกระบวนการเริ่มต้นด้วยการเรียกกลับง่ายขึ้น
เพิ่มการเริ่มต้น Firebase ลงในเมธอด MainGame.cs Start() โดยแทนที่เมธอด InitializeCommonDataAndStartGame() ที่มีอยู่ด้วยเมธอด InitializeFirebaseAndStartGame() ที่ยังไม่ได้ใช้งานในขณะนี้
```
void Start()
{
   Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
   InitializeFirebaseAndStartGame();
}
```

ใน 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;
         SetRemoteConfigDefaults();
         } else {
         UnityEngine.Debug.LogError(
            $"Could not resolve all Firebase dependencies: {dependencyStatus}\n" +
            "Firebase Unity SDK is not safe to use here");
         }
      });
}

การเรียกใช้การเริ่มต้น Firebase SetRemoteConfigDefaults เมื่อสำเร็จเพื่อตั้งค่าเริ่มต้นในแอป แทนที่เมธอด SetRemoteConfigDefaults ที่ยังไม่ได้ใช้ด้วยเมธอดต่อไปนี้

private void SetRemoteConfigDefaults()
{
   var defaults = new System.Collections.Generic.Dictionary < string, object > ();
   defaults.Add(
      Hamster.MapObjects.AccelerationTile.AccelerationTileForceKey,
      Hamster.MapObjects.AccelerationTile.AccelerationTileForceDefault);
   defaults.Add(
      Hamster.States.MainMenu.SubtitleOverrideKey,
      Hamster.States.MainMenu.SubtitleOverrideDefault);
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   remoteConfig.SetDefaultsAsync(defaults).ContinueWithOnMainThread(
      previousTask =>
      {
         FetchRemoteConfig(InitializeCommonDataAndStartGame);
      }
   );
}

5. ดึงข้อมูลและเปิดใช้งานค่าใหม่ (หากจำเป็น)

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

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

วางโค้ดด้านล่างลงใน FetchRemoteConfig
```
public void FetchRemoteConfig(System.Action onFetchAndActivateSuccessful)
{
   if(app==null)
   {
      Debug.LogError($"Do not use Firebase until it is properly initialized by calling {nameof(InitializeFirebaseAndStartGame)}.");
      return;
   }

   Debug.Log("Fetching data...");
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   remoteConfig.FetchAsync(System.TimeSpan.Zero).ContinueWithOnMainThread(
      previousTask=>
      {
         if (!previousTask.IsCompleted)
         {
         Debug.LogError($"{nameof(remoteConfig.FetchAsync)} incomplete: Status '{previousTask.Status}'");
         return;
         }
         ActivateRetrievedRemoteConfigValues(onFetchAndActivateSuccessful);
      });
}
```
หมายเหตุ: cacheExpiration ค่าที่ส่งไปยัง FetchAsync จะกำหนดระยะเวลาที่ควรแคชค่าที่ดึงข้อมูลก่อนหน้านี้ ในระหว่างการพัฒนา คุณสามารถตั้งค่านี้เป็น System.TimeSpan.Zero ตามที่แสดงด้านบน เพื่อให้มั่นใจว่าแอปจะแสดงค่าล่าสุดอยู่เสมอ อย่างไรก็ตาม เมื่อเผยแพร่ไปยังเวอร์ชันที่ใช้งานจริง คุณควรตั้งค่า cacheExpiration ให้สูงขึ้นเพื่อหลีกเลี่ยงการจำกัดอัตรา ระยะเวลาเริ่มต้น (เมื่อเรียกใช้ FetchAsync โดยไม่มีพารามิเตอร์) คือ 12 ชั่วโมง

จากนั้นให้ทำตามActivateRetrievedRemoteConfigValues เมธอด ซึ่งรับ Callback ที่ส่งเข้ามา onFetchAndActivateSuccessful เมื่อการเปิดใช้งานเสร็จสิ้น ระบบจะเรียกใช้การเรียกกลับที่ระบุ

private void ActivateRetrievedRemoteConfigValues(System.Action onFetchAndActivateSuccessful)
{
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   var info = remoteConfig.Info;
   if(info.LastFetchStatus == LastFetchStatus.Success)
   {
      remoteConfig.ActivateAsync().ContinueWithOnMainThread(
         previousTask =>
         {
         Debug.Log($"Remote data loaded and ready (last fetch time {info.FetchTime}).");
         onFetchAndActivateSuccessful();
         });
   }
}

เมื่อ SetRemoteConfigDefaults เรียกใช้จากบริบทการเริ่มต้น ActivateRetrievedRemoteConfigValues จะเรียกจุดเริ่มต้นก่อนหน้า InitializeCommonDataAndStartGame เพื่อเริ่มเกมโดยการเปิดเมนูหลัก

6. ตั้งค่ากลยุทธ์การโหลดการกำหนดค่าระยะไกล

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

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

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

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

หากต้องการเปิดใช้ฟีเจอร์นี้ในแอป ให้ทำตามวิธีการที่เกี่ยวข้องในเมนูหลักและไฟล์การเลือกระดับ ซึ่งจะบล็อกการแสดง UI จนกว่า FetchAsync และ ActivateAsync จะเสร็จสมบูรณ์

เปิด Assets/Hamster/Scripts/States/MainMenu.cs แล้วแทนที่เมธอด Resume ที่มีอยู่ด้วยเมธอดต่อไปนี้

public override void Resume(StateExitValue results) {
   CommonData.mainGame.SelectAndPlayMusic(CommonData.prefabs.menuMusic, true);
   CommonData.mainGame.FetchRemoteConfig(InitializeUI);
}

บันทึกไฟล์
เปิด Assets/Hamster/Scripts/States/BaseLevelSelect.cs แล้วแทนที่เมธอด Resume ที่มีอยู่ด้วยเมธอดต่อไปนี้
```
public override void Resume(StateExitValue results) {
   CommonData.mainGame.FetchRemoteConfig(ShowUI);
}
```
บันทึกไฟล์

7. แก้ไขข้อบกพร่อง/ตรวจสอบลักษณะการทำงานของการดึงข้อมูล

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

ระบบจะพิมพ์ข้อมูลเป็นส่วนหนึ่งของบันทึกของโปรแกรมจำลอง อุปกรณ์ หรือเอดิเตอร์ สำหรับ iOS คุณสามารถดูบันทึกของอุปกรณ์และเครื่องจำลองได้ใน Xcode สำหรับ Android ให้ดูบันทึกโดยเรียกใช้ adb logcat หากเรียกใช้โค้ดใน Unity โดยกดเล่นในเอดิเตอร์ บันทึกจะปรากฏในแท็บคอนโซล

สร้างและเรียกใช้แอปอีกครั้ง (ในเอดิเตอร์ โดยใช้อุปกรณ์หรือโปรแกรมจำลอง)
หลังจากเมนูหลักของเกมปรากฏขึ้น ให้ตรวจสอบเอาต์พุตบันทึกของเกม ซึ่งควรมีบันทึกที่ Debug.Log สร้างขึ้นใน FetchRemoteConfig และ ActivateRetrievedRemoteConfigValues โดยควรแสดงข้อความ "กำลังดึงข้อมูล..." และ "โหลดข้อมูลระยะไกลแล้วและพร้อมใช้งาน" โปรดสังเกตการประทับเวลาที่จุดเริ่มต้นของข้อความเหล่านี้
กดใบอนุญาตในเกม
กดตกลง
รอให้เมนูหลักของเกมปรากฏขึ้น
ตรวจสอบเอาต์พุตบันทึกของเกม ซึ่งควรคล้ายกับเอาต์พุตในขั้นตอนก่อนหน้า โดยมีการประทับเวลาใหม่ (ตรงกับเวลาที่ตั้งไว้ในนาฬิการะบบที่คุณเรียกใช้เกม)
กดเล่นในเกม
กดเริ่มเลย
นำทางลูกบอลไปยังเป้าหมายโดยใช้ปุ่มลูกศรบนแป้นพิมพ์ ซึ่งจะเปิดเมนู "ผ่านด่าน"
กดระดับ
รอให้เมนูเลือกระดับโหลด
ตรวจสอบเอาต์พุตบันทึกของเกมอีกครั้ง โดยควรตรงกับข้อความบันทึกจากขั้นตอนก่อนหน้า โดยมีการประทับเวลาใหม่กว่า (ตรงกับเวลาที่ตั้งไว้ในนาฬิกาของระบบที่คุณเรียกใช้เกม)

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

หากบันทึกเริ่มต้นจากการโหลดเมนูปรากฏขึ้น แต่บันทึกใดบันทึกหนึ่งที่ตามมาไม่ปรากฏ ให้ตรวจสอบ/ติดตั้งใช้งานResumeเมธอดใน Assets/Hamster/Scripts/States/MainMenu.cs และ Assets/Hamster/Scripts/States/BaseLevelSelect.cs อีกครั้ง

8. ใช้โค้ดเป็นเครื่องมือ

ตอนนี้คุณได้กําหนดค่าพารามิเตอร์ในแอปใน SetDefaultsAsync() และทําให้เวอร์ชันล่าสุดพร้อมใช้งานกับ FetchAsync() และ ActivateAsync() แล้ว คุณจะอ้างอิงและใช้ค่าเหล่านั้นในโค้ด

หลังจากตั้งค่าในแบ็กเอนด์ของการกำหนดค่าระยะไกลแล้ว ให้ดึงข้อมูลและเปิดใช้งาน (หรือทำทั้ง 2 อย่างพร้อมกัน) ค่าเหล่านั้นจะพร้อมใช้งานในแอปของคุณ หากต้องการใช้ค่าเหล่านี้ ให้เรียกใช้ GetValue(string key) แล้วเลือกคีย์พารามิเตอร์เป็นอาร์กิวเมนต์ ซึ่งจะแสดงผล ConfigValue ที่มีพร็อพเพอร์ตี้ในการเข้าถึงค่าเป็นประเภทต่างๆ ที่รองรับ ได้แก่ string, bool, long, double ในโปรเจ็กต์นี้และกรณีการใช้งานเกมส่วนใหญ่ คุณต้องแคสต์ 2 ประเภทสุดท้ายเป็น int และ float ที่เป็นสำนวนมากกว่า เพื่อให้มั่นใจว่า Conversion เหล่านี้จะไม่ก่อให้เกิดปัญหา โปรดตรวจสอบว่าค่าเริ่มต้นที่ตั้งไว้ใน Remote Config อยู่ในช่วงที่ถูกต้องของประเภทที่คุณจะใช้ในโค้ดของแอป

นำเข้าการกำหนดค่าระยะไกลโดยเพิ่ม using Firebase.RemoteConfig; ที่ด้านบนของไฟล์ต่อไปนี้
- Assets/Hamster/Scripts/States/MainMenu.cs
- Assets/Hamster/Scripts/MapObjects/AccelerationTile.cs
แทนที่เมธอด Start ของ AccelerationTile.cs ดังนี้
```
private void Start() {
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
}
```
การเปลี่ยนแปลงนี้จะเปลี่ยนแรงที่เกิดจากไทล์การเร่งความเร็วเป็นแรงที่ได้รับจาก Remote Config

แก้ไขเนื้อหาของเมธอด InitializeUI ของ MainMenu.cs ดังนี้

private void InitializeUI() {
   if (menuComponent == null) {
      menuComponent = SpawnUI<Menus.MainMenuGUI>(StringConstants.PrefabMainMenu);
   }

   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   var subtitleOverride = JsonUtility.FromJson<Menus.MainMenuGUI.SubtitleOverride>(
      remoteConfig.GetValue(SubtitleOverrideKey).StringValue);
   // Only sets values if all fields of the override are non-default.
   if(subtitleOverride != null && subtitleOverride.IsValidOverride())
   {
      menuComponent.MenuSubtitleText.text = subtitleOverride.text;
      menuComponent.MenuSubtitleText.fontSize = subtitleOverride.fontSize;
      menuComponent.MenuSubtitleText.color = subtitleOverride.textColor;
   }
   ShowUI();
}

ในที่นี้ subtitleOverride ได้รับการตั้งค่าให้เปลี่ยนคำบรรยายแทนเสียงในหน้าจอเมนูหลัก หากฟิลด์ทั้งหมดในระบบคลาวด์ได้รับการตั้งค่าเป็นค่าอื่นที่ไม่ใช่ค่าเริ่มต้นของประเภท

9. ตั้งค่าพารามิเตอร์จากระยะไกล

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

เปิดโปรเจ็กต์ในคอนโซล Firebase
เลือกการกำหนดค่าระยะไกลจากเมนูเพื่อดูแดชบอร์ดการกำหนดค่าระยะไกล

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

ชื่อพารามิเตอร์ (คีย์)	ประเภทข้อมูล	ค่าเริ่มต้น
acceleration_tile_force	ตัวเลข	100
subtitle_override	JSON	`{"text":"We overwrote the subtitle","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}`

$โปรแกรมแก้ไขพารามิเตอร์การกำหนดค่าระยะไกลที่มี\nacceleration_tile_force$

คลิกบันทึกเพื่อบันทึกการเปลี่ยนแปลง
คลิกเผยแพร่เพื่อเผยแพร่การกำหนดค่าใหม่และทำให้ค่าใหม่พร้อมใช้งานในเกม
เรียกใช้แอปอีกครั้งหลังจากตั้งค่าพารามิเตอร์ระยะไกลเหล่านี้ แล้วสังเกตว่าพารามิเตอร์เหล่านี้ลบล้างค่าเริ่มต้นเดิมอย่างไร
เคล็ดลับ: สำหรับค่าที่สังเกตได้ยากกว่า เช่น ค่าทางฟิสิกส์ คุณสามารถอัปเดตโค้ดเพื่อบันทึกค่าของ ConfigValue.Source เพื่อพิจารณาว่าค่าเป็นค่าเริ่มต้นที่กำหนดค่าไว้หรือดึงมาจากเซิร์ฟเวอร์การกำหนดค่าระยะไกล

10. ใช้เงื่อนไขการกำหนดค่าระยะไกลเพื่อแสดงตัวแปร

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

โดยทั่วไปแล้ว เงื่อนไขมักใช้เพื่อเปลี่ยนเนื้อหาระหว่างแพลตฟอร์ม iOS และ Android ทำตามขั้นตอนด้านล่างเพื่อใช้เงื่อนไขที่แสดงค่าอื่นสำหรับ subtitle_override ขึ้นอยู่กับแพลตฟอร์มที่ใช้

เปิดแท็บการกำหนดค่าระยะไกลของโปรเจ็กต์ในคอนโซล Firebase
คลิกปุ่มแก้ไขสำหรับ subtitle_override.
คลิกเพิ่มใหม่ที่มุมซ้ายล่าง
ในเมนูแบบเลื่อนลงที่ปรากฏขึ้น ให้วางเมาส์เหนือค่าแบบมีเงื่อนไข แล้วคลิกสร้างเงื่อนไขใหม่ $เครื่องมือแก้ไขพารามิเตอร์การกำหนดค่าระยะไกล:\nตัวเลือกค่าแบบมีเงื่อนไข$
เมื่อได้รับแจ้ง ให้ตั้งชื่อเงื่อนไขว่า "เป็น iOS" หากคุณกําหนดเป้าหมายเป็น iOS หรือ "เป็น Android" หากคุณกําหนดเป้าหมายเป็น Android หากคุณกำหนดเป้าหมายทั้ง 2 อย่าง เพียงเลือกอย่างใดอย่างหนึ่งที่นี่และใช้สำหรับส่วนที่เหลือของโค้ดแล็บ
ในส่วนใช้ในกรณีที่... ให้คลิกเมนูแบบเลื่อนลงเลือก... แล้วเลือกแพลตฟอร์ม จากนั้นเลือกแพลตฟอร์มที่เหมาะสม
คลิกสร้างเงื่อนไขเพื่อสร้างเงื่อนไข กล่องโต้ตอบ "แก้ไขพารามิเตอร์" จะปรากฏขึ้นอีกครั้ง และตอนนี้คุณสามารถตั้งค่าได้แล้ว
- หากกำหนดเป้าหมายเป็น Android ให้ตั้งค่าเป็น
```
{"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
```
- หากกําหนดเป้าหมายเป็น iOS ให้ตั้งค่าค่าเป็น
```
{"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
```
คลิกบันทึกเพื่อบันทึกการเปลี่ยนแปลง
คลิกเผยแพร่เพื่อเผยแพร่การกำหนดค่าใหม่และทำให้ค่าใหม่พร้อมใช้งานในเกม

หากสร้างและเรียกใช้เกมอีกครั้ง คุณจะเห็นว่าคำบรรยายแทนเสียงของเกมถูกแทนที่ด้วยคำบรรยายแทนเสียงที่เฉพาะเจาะจงสำหรับแพลตฟอร์ม

11. กำหนดค่าการกำหนดค่าระยะไกลเพื่อรับข้อมูลอัปเดตแบบเรียลไทม์

ตอนนี้การกำหนดค่าระยะไกลสามารถรอรับและจัดการการอัปเดตเทมเพลตการกำหนดค่าระยะไกลแบบเรียลไทม์ได้แล้ว แอปสามารถสมัครใช้บริการ Remote Config API แบบเรียลไทม์ใหม่เพื่อฟังการเปลี่ยนแปลงการกำหนดค่าและค่าที่อัปเดตได้

วิธีการทำงาน

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

ติดตั้งใช้งานการกำหนดค่าระยะไกลแบบเรียลไทม์

หากต้องการแสดงให้เห็นว่าฟีเจอร์นี้ทำงานอย่างไรในเกม ให้ทำการเปลี่ยนแปลงต่อไปนี้ในโค้ด

สร้างตัวแฮนเดิลการอัปเดตการกำหนดค่า

ขั้นตอนแรกในการใช้เหตุการณ์การอัปเดตการกำหนดค่าคือการสร้างเมธอดที่สามารถรับฟังเหตุการณ์ดังกล่าวได้ วางวิธีการต่อไปนี้ใน Assets/Hamster/Scripts/MainGame.cs

   void ActivateValuesOnConfigUpdate( object sender, ConfigUpdateEventArgs args)
   {
      if (args.Error != RemoteConfigError.None) {
         Debug.Log($"Error occurred while listening: {args.Error}");
         return;
      }

      Debug.Log("Updated keys: " + string.Join(", ", args.UpdatedKeys));
      // Activate all fetched values and then logs.
      var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
      remoteConfig.ActivateAsync().ContinueWithOnMainThread(
         task => {
            Debug.Log($"Keys from {nameof(ActivateValuesOnConfigUpdate)} activated.");
         });
   }

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

หากต้องการเปิดใช้งาน ActivateValuesOnConfigUpdate เมื่อมีการเรียกใช้เหตุการณ์ ให้สมัครใช้เหตุการณ์ แทนที่เมธอด InitializeCommonDataAndStartGame() ใน Assets/Hamster/Scripts/MainGame.cs ด้วยเมธอดต่อไปนี้

   void InitializeCommonDataAndStartGame()
   {
      CommonData.prefabs = FindObjectOfType<PrefabList>();
      CommonData.mainCamera = FindObjectOfType<CameraController>();
      CommonData.mainGame = this;

      Screen.orientation = ScreenOrientation.LandscapeLeft;

      musicPlayer = CommonData.mainCamera.GetComponentInChildren<AudioSource>();

      CommonData.gameWorld = FindObjectOfType<GameWorld>();

      // Set up volume settings.
      MusicVolume = PlayerPrefs.GetInt(StringConstants.MusicVolume, MaxVolumeValue);
      // Set the music to ignore the listeners volume, which is used for sound effects.
      CommonData.mainCamera.GetComponentInChildren<AudioSource>().ignoreListenerVolume = true;
      SoundFxVolume = PlayerPrefs.GetInt(StringConstants.SoundFxVolume, MaxVolumeValue);

      // Subscribes to on config update after first initial fetch and activate
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener += ActivateValuesOnConfigUpdate;

      stateManager.PushState(new States.MainMenu());
   }

บรรทัดใหม่ (ลงท้ายด้วย += ActivateValuesOnConfigUpdate;) จะสมัครใช้บริการเครื่องจัดการเหตุการณ์กับเหตุการณ์

ยกเลิกการสมัครรับข้อมูลเมื่อออบเจ็กต์ที่เป็นเจ้าของแฮนเดิลถูกทำลาย

ออบเจ็กต์ที่มีเมธอดที่สมัครรับข้อมูลเหตุการณ์จะต้องยกเลิกการสมัครรับข้อมูลเมธอดนั้นเมื่อถูกทำลาย เพื่อป้องกันข้อผิดพลาดในการอ้างอิงค่า Null เพิ่มวิธีการต่อไปนี้ลงใน Assets/Hamster/Scripts/MainGame.cs

   private void OnDestroy() 
   {
      FirebaseRemoteConfig.DefaultInstance.OnConfigUpdateListener -= ActivateValuesOnConfigUpdate;
   }

ทดสอบฟังก์ชันการทำงานใหม่

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

เปลี่ยน `acceleration_tile_force` แล้วสังเกต

หลังจากเริ่มแอปแล้ว ให้ทำดังนี้ในส่วนการกำหนดค่าระยะไกลของคอนโซล Firebase

กดปุ่มแก้ไขข้าง acceleration_tile_force

เปลี่ยนค่าเป็น "120" แล้วกดบันทึก

คลิกปุ่มเผยแพร่การเปลี่ยนแปลง

ตรวจสอบบันทึก
หากเห็นข้อความบันทึกที่ขึ้นต้นด้วย "เกิดข้อผิดพลาดขณะฟัง" ให้อ่านข้อความที่เหลือและลองแก้ไขข้อบกพร่องด้วยข้อความแสดงข้อผิดพลาดที่พิมพ์ออกมา
หากเห็นบันทึกที่ขึ้นต้นด้วย "Updated keys" แสดงว่าแอปได้รับค่าที่เปลี่ยนแปลงแล้ว
หากไม่เห็นทั้ง 2 รายการนี้ ให้ดูบันทึกที่เหลือ จากนั้นอ่านวิธีการจากสร้างตัวแฮนเดิลการอัปเดตการกำหนดค่าอีกครั้ง ทำการทดสอบอีกครั้ง และตรวจสอบบันทึกอีกครั้งเพื่อดูว่ามีสิ่งผิดปกติหรือไม่

คำเตือน: โปรดทราบว่าการดำเนินการนี้จะไม่ดึงค่าแบบมีเงื่อนไขใหม่หากคุณเปลี่ยนการประเมินเงื่อนไข (เช่น ไม่ว่าผู้ใช้จะมีพร็อพเพอร์ตี้ผู้ใช้ Analytics ที่เฉพาะเจาะจงหรือไม่ หรือไม่ว่าผู้ใช้จะเป็นส่วนหนึ่งของกลุ่มเป้าหมาย Analytics หรือไม่) ดังนั้นในตอนนี้ โปรดโทรหา FetchRemoteConfig (ซึ่งโทรหา FetchAndActivate) ใน Assets/Hamster/Scripts/States/MainMenu.cs และ Assets/Hamster/Scripts/States/BaseLevelSelect.cs

12. ยินดีด้วย

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

สิ่งที่เราได้พูดถึงไปแล้ว

วิธีตั้งค่าและดึงค่าการกำหนดค่าระยะไกล
วิธีใช้โค้ด C# ของ Unity เพื่อใช้ค่าที่เรียกข้อมูล
วิธีจัดเก็บ ติดตั้งเครื่องมือ และลบล้างค่า/ออบเจ็กต์แบบผสมเป็นค่า JSON
วิธีใช้เงื่อนไขการกำหนดค่าระยะไกลเพื่อแสดงตัวแปรมูลค่าที่แตกต่างกัน

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

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