דף זה תורגם על ידי Cloud Translation API.

מגדירים את המשחק ב-Unity בעזרת הגדרת תצורה מרחוק ב-Firebase

1. מבוא

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

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

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

מה תלמדו

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

מה צריך להכין

Unity 2019.1.0f1 ואילך עם תמיכה ב-build ב-iOS ו/או ב-Android
מכשיר Android/iOS פיזי או סימולטור/אמולטור כדי ליצור ולהריץ את המשחק

2. הגדרת סביבת הפיתוח

בקטעים הבאים מוסבר איך להוריד את הקוד של Level Up with Firebase, לפתוח אותו ב-Unity ולהוסיף פרויקט ב-Firebase. המשחק לדוגמה הזה של Level Up עם Firebase נמצא בשימוש במספר שיעורי Lab אחרים ב-Firebase וב-Unity, כך שייתכן שכבר השלמתם את המשימות בקטע הזה. אם כן, אפשר לדלג על השלבים האלה ולהמשיך אל 'הוספת ערכות SDK של Firebase ל-Unity' כדי להוסיף את Remote Config לקוד המשחק לדוגמה.

להורדת הקוד

משכפלים את מאגר ה-GitHub של הקוד למעבדה הזו משורת הפקודה:

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

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

פתיחת שדרוג לרמה הבאה עם Firebase בעורך Unity

מפעילים את Unity Hub, ובכרטיסייה Projects לוחצים על החץ לתפריט הנפתח שליד Open.
לוחצים על Add project from disk.
עוברים לספרייה שמכילה את הקוד ולוחצים על OK.
אם מופיעה בקשה, בוחרים את גרסת עורך Unity שבה רוצים להשתמש ואת פלטפורמת היעד (Android או iOS).
לוחצים על שם הפרויקט level-up-with-firebase והפרויקט ייפתח בעורך Unity.
אם הכלי לא נפתח באופן אוטומטי, פותחים את MainGameScene בקטע נכסים > Hamster בכרטיסייה Project (פרויקט) של Unity Editor.

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

3. הוספת Firebase לפרויקט ב-Unity

יוצרים פרויקט Firebase

במסוף Firebase, לוחצים על הוספת פרויקט.
כדי ליצור פרויקט חדש, מזינים את שם הפרויקט הרצוי.
הפעולה הזו תגדיר גם את מזהה הפרויקט (שמוצג מתחת לשם הפרויקט) למשהו שמבוסס על שם הפרויקט. אם רוצים, אפשר ללחוץ על סמל העריכה במזהה הפרויקט כדי לבצע התאמה אישית נוספת.
אם תופיע בקשה, קוראים את התנאים של Firebase ומאשרים אותם.
לוחצים על המשך.
בוחרים באפשרות Enable Google Analytics for this project (הפעלת Google Analytics עבור הפרויקט הזה) ולוחצים על Continue (המשך).
בוחרים חשבון Google Analytics קיים שבו רוצים להשתמש, או בוחרים באפשרות יצירת חשבון חדש כדי ליצור חשבון חדש.
לוחצים על Create project.
אחרי השלמת היצירה, לוחצים על Continue.

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

פותחים את מסוף Firebase, ובמרכז הדף 'סקירה כללית של הפרויקט' לוחצים על סמל Unity כדי להפעיל את תהליך העבודה להגדרה. אם כבר הוספתם אפליקציה לפרויקט Firebase, לוחצים על Add app (הוספת אפליקציה) כדי להציג את אפשרויות הפלטפורמה.
יש לבחור כדי לרשום גם את יעד ה-build של Apple (iOS) וגם את יעד ה-build של Android.
מזינים את המזהים הספציפיים לפלטפורמה של פרויקט Unity. ב-Codelab הזה, מזינים את הפרטים הבאים:
- עבור Apple (iOS) – מזינים com.google.firebase.level-up בשדה iOS Bundle ID.
- ב-Android – מזינים את הערך com.google.firebase.level_up בשדה שם החבילה ל-Android.
לחלופין, אפשר להזין את הכינויים הספציפיים לפלטפורמה של פרויקט Unity.
לוחצים על Register app (רישום האפליקציה) וממשיכים לקטע Download config file (הורדת קובץ התצורה).
חוזרים על התהליך לגבי יעד ה-build שלא ביצעתם בפעם הראשונה.

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

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

מורידים את שני קובצי התצורה הזמינים:
- ל-Apple (iOS): מורידים את הקובץ GoogleService-Info.plist.
- ב-Android: מורידים את google-services.json.
פותחים את החלון Project (פרויקט) בפרויקט ב-Unity, ומעבירים את שני קובצי התצורה אל התיקייה Assets (נכסים).
חשוב: גם אם אתם מתכננים לפתח רק ל-iOS או ל-Android, כדאי להוריד את שני הקבצים ולהוסיף אותם לפרויקט.
במסוף Firebase, בתהליך ההגדרה, לוחצים על הבא וממשיכים לקטע 'הוספת ערכות Firebase SDK ל-Unity'.

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

הוספה של ערכות Firebase SDK ל-Unity

לוחצים על Download Firebase Unity SDK במסוף Firebase.
הערה: ההורדה של ה-SDK הזה עשויה להימשך זמן מה. אפשר לראות את השלבים הבאים או לצאת להפסקה קצרה.
מבטלים את האריזה של ה-SDK במקום נוח.
בפרויקט Unity הפתוח, עוברים אל Assets (נכסים) > ייבוא חבילה > חבילה מותאמת אישית.
בתיבת הדו-שיח Import package, עוברים לספרייה שמכילה את ה-SDK ללא האפסור, בוחרים באפשרות FirebaseAnalytics.unitypackage ולוחצים על Open.
בתיבת הדו-שיח ייבוא חבילת Unity שמופיעה, לוחצים על ייבוא.
חוזרים על השלבים הקודמים כדי לייבא את שתי החבילות הבאות:
- FirebaseRemoteConfig.unitypackage
- FirebaseCrashlytics.unitypackage
  Crashlytics הוא כלי קל לדיווח על קריסות בזמן אמת, שעוזר לכם לעקוב אחרי בעיות יציבות שמשפיעות על איכות האפליקציה, לתת להן עדיפות ולתקן אותן. אם לא השתמשתם ב-Crashlytics בעבר, כדאי להשלים את קורס Crashlytics ל-Unity.
חוזרים למסוף Firebase ולוחצים על הבא בתהליך ההגדרה.

מידע נוסף על הוספת ערכות SDK של Firebase לפרויקטים ב-Unity זמין במאמר אפשרויות נוספות להתקנה ב-Unity.

4. קביעת ברירות מחדל של הגדרת תצורה מרחוק ואחזור ערכים חדשים

בקודלאב הזה תלמדו לעדכן אובייקטים שמשתמשים בערכים שהוגדרו בקוד או שעברו שרשור (serialization) בעורך Unity, כך שישתמשו בערכים שנוספו באמצעות Remote Config. צריך להגדיר ערכי ברירת מחדל לכל פרמטר באמצעות SetDefaultsAsync כדי שהאפליקציה תפעל כמצופה לפני שהיא מתחברת לקצה העורפי של הגדרת התצורה מרחוק. האפליקציה תישאר מעודכנת על ידי אחזור ערכים חדשים מ'הגדרת תצורה מרחוק' והפעלה שלהם כדי שניתן יהיה להשתמש בהם בקוד.

כדי לאחזר ערכים חדשים מהגדרת התצורה מרחוק, יש בקובץ Assets/Hamster/Scripts/MainGame.cs כמה שיטות שלא הוטמעו וחובה להשלים אותן.

מוסיפים את הצהרות using הבאות לקובץ MainGame.cs:
```
using Firebase.Crashlytics;
using Firebase.Extensions;
using Firebase.RemoteConfig;
```
המודול Firebase.Extensions מכיל כמה תוספים ל-C# Tasks API, שיעזרו לנהל את תהליך האתחול עם קריאות חוזרות (callback) בקלות רבה יותר.
מוסיפים את האתחול של 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 (שאוחזרת ערכים חדשים מ-Remote Config) ו-ActivateAsync (שמפעילה את הערכים שהתקבלו כדי שהם יהיו זמינים בקוד) באמצעות פרמטר קריאה חוזרת בשם onFetchAndActivateSuccessful.

קוד ההפעלה שהוספנו בשלב הקודם קורא ל-FetchRemoteConfig עם InitializeCommonDataAndStartGame כפונקציית ה-callback שלו, כדי להפעיל את המשחק בסוף הרצף. אפשר להעביר פונקציות קריאה חוזרת חלופיות ל-FetchRemoteConfig כדי להפעיל את האחזור עם תוצאות שונות. דוגמה (שתטמיעו בהמשך) היא העברה של שיטה שפותחת תפריטי ממשק משתמש חדשים, שתלויים בערכים של Remote Config. בעקבות זאת, התפריטים ייפתחו רק אחרי שהערכים האלה יאוחזרו ויופעלו.

מדביקים את הקוד הבא ב-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);
      });
}

לאחר מכן, משלימים את השיטה 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 במורד הזרם מההקשר של האתחול, ActivateRetrievedRemoteConfigValues קורא לנקודת ההתחלה הקודמת, InitializeCommonDataAndStartGame, כדי להתחיל את המשחק על ידי פתיחת התפריט הראשי.

6. הגדרת אסטרטגיית טעינה של Remote Config

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

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

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

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

כדי להפעיל את התכונה הזו באפליקציה, צריך להשלים את השיטות הרלוונטיות בתפריט הראשי ובקבצים של בחירת הרמה. הפעולות האלה יחסמו את תצוגת ממשק המשתמש עד שהשלבים 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 ומחליפים את ה-method הקיים של Resume בשיטה הבאה:
```
public override void Resume(StateExitValue results) {
   CommonData.mainGame.FetchRemoteConfig(ShowUI);
}
```
שומרים את הקובץ.

7. ניפוי באגים/אימות התנהגויות אחזור

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

המידע יודפס כחלק מהיומנים של הסימולטור, המכשיר או העריכה. ב-iOS, אפשר להציג את יומני המכשירים והסימולטורים ב-Xcode. ב-Android, מריצים את הפקודה adb logcat כדי להציג את היומנים. אם מריצים את הקוד ב-Unity על ידי לחיצה על 'הפעלה' בעורך, היומנים מופיעים בכרטיסייה 'מסוף'.

יוצרים מחדש את האפליקציה ומפעילים אותה (ב-Editor, באמצעות מכשיר או סימולטור).
אחרי שתפריט המשחק הראשי מופיע, בודקים את הפלט של יומני המשחק, שצריך להכיל את היומנים שנוצרו על ידי Debug.Log ב-FetchRemoteConfig וב-ActivateRetrievedRemoteConfigValues. בהן אמורה להופיע ההודעה "מאחזרים נתונים..." ו"הנתונים נטענים ומוכנים מרחוק" הודעות. שימו לב לחותמות הזמן בתחילת ההודעות האלה.
במשחק, לוחצים על רישיון.
לוחצים על אישור.
ממתינים להופעת התפריט הראשי של המשחק.
עליך לבדוק את הפלט של יומן המשחק, שאמור להיות דומה לפלט בשלב הקודם, עם חותמות זמן חדשות (תואמות לשעה בשעון המערכת שבו המשחק מופעל).
במשחק, לוחצים על הפעלה.
מקישים על Let's Roll.
מנווטים בכדור אל היעד באמצעות מקשי החיצים במקלדת, לפתיחת התפריט 'השלמת שלב'.
מקישים על רמות.
ממתינים לטעינת התפריט בחירת רמה.
בודקים שוב את הפלט של יומן המשחק. הוא אמור להתאים להודעות ביומן מהשלבים הקודמים, עם חותמות זמן חדשות יותר (שתואמות לשעה שמוגדרת בשעון המערכת שבה אתם מפעילים את המשחק).

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

אם היומנים הראשוניים שמופעלים בזמן טעינת התפריט מופיעים, אבל אחד מהיומנים הבאים לא מופיע, צריך לבדוק או להטמיע מחדש את השיטות Resume ב-Assets/Hamster/Scripts/States/MainMenu.cs וב-Assets/Hamster/Scripts/States/BaseLevelSelect.cs.

8. מגדירים את הקוד

עכשיו, אחרי שהגדרתם את ערכי הפרמטרים באפליקציה ב-SetDefaultsAsync() והפכתם את הגרסאות העדכניות ביותר לזמינות באמצעות FetchAsync() ו-ActivateAsync(), תוכלו להפנות לערכים האלה בקוד ולהשתמש בהם.

אחרי שמגדירים ערכים בקצה העורפי של Remote Config, מאחזרים אותם ומפעילים אותם (או מבצעים את שתי הפעולות בבת אחת), הערכים האלה זמינים לאפליקציה. כדי להשתמש בערכים האלה, צריך להפעיל את הפונקציה GetValue(string key) ולבחור מפתח פרמטר כארגומנטים. הפונקציה מחזירה את הערך ConfigValue, שמכיל מאפיינים כדי לגשת לערך במגוון סוגים נתמכים: string, bool, long, double. בפרויקט הזה וברוב התרחישים לדוגמה בנושא משחקים, צריך להמיר את שני הסוגים האחרונים ל-int ו-float, שהם יותר רגילים. כדי לוודא שההמרות האלה לא יגרמו לבעיות, חשוב לוודא שהערכים הראשוניים שהוגדרו ב-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. הגדרת ערכי פרמטרים מרחוק

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

פותחים את הפרויקט במסוף Firebase.
בוחרים את הגדרת התצורה מרחוק מהתפריט כדי להציג את לוח הבקרה של הגדרת התצורה מרחוק.

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

שם הפרמטר (המפתח)	סוג הנתונים	ערך ברירת המחדל
acceleration_tile_force	מספר	100
Caption_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 מאוכלס$

לוחצים על Save כדי לשמור את השינויים.
לוחצים על Publish (פרסום) כדי לפרסם את ההגדרות החדשות ולהפוך את הערכים החדשים לזמינים במשחק.
מריצים את האפליקציה שוב אחרי שמגדירים את הפרמטרים מרחוק האלה, ומתבוננים באופן שבו הם מבטלים את ערכי ברירת המחדל המקוריים. $המסך הראשי של Mechahamster עם התכונה 'ניפוי באגים'\nהתפריט מופעל$
טיפ: לגבי ערכים שקשה יותר לצפות בהם, כמו ערכי פיזיקה, אפשר לעדכן את הקוד כך שיירשם ביומן הערך של ConfigValue.Source כדי לקבוע אם הערכים הם ערכי ברירת המחדל שהוגדרו או שהם אוחזו משרת Remote Config.

10. שימוש בתנאים של הגדרת תצורה מרחוק כדי להציג וריאנטים

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

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

פותחים את הכרטיסייה 'הגדרת תצורה מרחוק' של הפרויקט במסוף Firebase.
לוחצים על לחצן העריכה של subtitle_override..
בפינה הימנית התחתונה, לוחצים על הוספת איש קשר חדש.
בתפריט הנפתח שמופיע, מעבירים את העכבר מעל ערך מותנה ולוחצים על יצירת תנאי חדש. $עורך הפרמטרים של Remote Config:‏\nאפשרות ערך מותנה$
כשמופיעה בקשה, נותנים לתנאי את השם 'is iOS' (המכשיר הוא iOS) אם מטרגטים ל-iOS, או 'is Android' (המכשיר הוא Android) אם מטרגטים ל-Android. אם אתם מטרגטים את שניהם, פשוט בוחרים אחד מהם כאן ומשתמשים בו בשאר הקוד. $עורך\nהתנאי של הגדרת תצורה מרחוק$
בקטע חל אם..., לוחצים על התפריט הנפתח בחירה... ובוחרים באפשרות פלטפורמה. ואז בוחרים את הפלטפורמה המתאימה.
לוחצים על יצירת תנאי כדי ליצור את התנאי. תיבת הדו-שיח 'עריכת הפרמטר' תופיע שוב, ותוכלו להגדיר ערך:
- אם אתם מטרגטים את Android, מגדירים את Value לערך:
```
{"text":"Level Up Android Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
```
- אם מטרגטים ל-iOS, צריך להגדיר את האפשרות Value (ערך) כ:
```
{"text":"Level Up iOS Version","fontSize":8,"textColor":{"r":0.0,"g":255.0,"b":0.0,"a":255.0}}
```
לוחצים על Save כדי לשמור את השינויים.
לוחצים על Publish (פרסום) כדי לפרסם את ההגדרות החדשות ולהפוך את הערכים החדשים לזמינים במשחק.

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

11. הגדרת Remote Config לקבלת עדכונים בזמן אמת

התכונה 'הגדרת תצורה מרחוק' יכולה עכשיו להאזין לעדכונים לתבניות של הגדרת תצורה מרחוק ולטפל בהם בזמן אמת. אפליקציות יכולות להירשם למינוי לממשק ה-API החדש של Remote Config בזמן אמת כדי להאזין לשינויים בהגדרות ולערכים המעודכנים.

איך זה עובד

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

הטמעת הגדרת תצורה מרחוק בזמן אמת

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

יצירת טיפול בעדכון תצורה

השלב הראשון בשימוש באירוע Config Update הוא ליצור שיטה שיכולה להאזין לו. מוסיפים את השיטה הבאה ל-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 כשתתבצע קריאה לאירוע, צריך להירשם אליו. מחליפים את ה-method 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;) מצרפת את גורם הטיפול באירועים לאירוע.

ביטול הרשמה כשהאובייקט שמחזיק בבעלות של ה-handler מושמד

כדי למנוע שגיאות של הפניה לאפס, אובייקטים עם שיטות שנרשמו לאירועים חייבים לבטל את ההרשמה של השיטה הזו כשהם נהרסים. מוסיפים את השיטה הבאה אל Assets/Hamster/Scripts/MainGame.cs:

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

בדיקת הפונקציונליות החדשה

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

משנים את `acceleration_tile_force` ומתבוננים בתוצאה

אחרי שמפעילים את האפליקציה, בקטע 'הגדרת תצורה מרחוק' במסוף Firebase:

צריך ללחוץ על לחצן העריכה ליד acceleration_tile_force.

שינוי הערך ל-120 ומקישים על Save.

לוחצים על הלחצן Publish Changes (פרסום השינויים).

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

12. כל הכבוד!

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

מה עסקנו בו

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

השלבים הבאים

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