इस पेज का अनुवाद Cloud Translation API से किया गया है.

Firebase रिमोट कॉन्फ़िगरेशन की मदद से, अपने यूनिटी गेम को इंस्टॉल करें

1. शुरुआती जानकारी

Firebase रिमोट कॉन्फ़िगरेशन का इस्तेमाल करके, अपने ऐप्लिकेशन में कुंजी-वैल्यू पेयर तय किए जा सकते हैं. इन्हें पैरामीटर भी कहा जाता है. साथ ही, इनकी वैल्यू को क्लाउड में अपडेट किया जा सकता है. इससे, ऐप्लिकेशन को अपडेट किए बिना ही, ऐप्लिकेशन के लुक और काम करने के तरीके में बदलाव किया जा सकता है.

आपको इस नई सुविधा को एक सैंपल गेम में जोड़ना होगा. इस गेम का नाम MechaHamster: Level Up with Firebase Edition है. यह सैंपल गेम, क्लासिक Firebase गेम MechaHamster का नया वर्शन है. इसमें Firebase की ज़्यादातर सुविधाएं हटा दी गई हैं. इससे आपको उनकी जगह पर Firebase की नई सुविधाओं को लागू करने का मौका मिलता है.

यह पक्का करने के लिए कि आपका ऐप्लिकेशन उम्मीद के मुताबिक काम करे, आपको सैंपल गेम कोड में वैल्यू के लिए डिफ़ॉल्ट कॉन्फ़िगरेशन सेट करने होंगे. इन वैल्यू को, Firebase कंसोल में रिमोट कॉन्फ़िगरेशन में सेट की गई वैल्यू से बदला जा सकता है.

आपको क्या सीखने को मिलेगा

क्लाउड में Remote Config की वैल्यू सेट करने और उन्हें वापस पाने का तरीका
अपने Unity C# कोड को इस तरह से इंस्ट्रूमेंट करना कि वह फ़ेच की गई वैल्यू का अपने-आप इस्तेमाल कर सके
JSON वैल्यू के तौर पर, कंपाउंड वैल्यू/ऑब्जेक्ट को सेव करने, इंस्ट्रुमेंट करने, और बदलने का तरीका
उपयोगकर्ताओं के अलग-अलग ग्रुप को अलग-अलग वैल्यू वैरिएंट दिखाने के लिए, Remote Config की शर्तों का इस्तेमाल कैसे करें

आपको इनकी ज़रूरत होगी

iOS और/या Android के साथ काम करने वाला Unity 2019.1.0f1 या इसके बाद का वर्शन
गेम बनाने और उसे चलाने के लिए, आपके पास Android/iOS डिवाइस या सिम्युलेटर/एम्युलेटर होना चाहिए

2. डेवलपमेंट एनवायरमेंट सेट अप करना

यहां दिए गए सेक्शन में, Level Up with Firebase कोड को डाउनलोड करने, उसे Unity में खोलने, और Firebase प्रोजेक्ट जोड़ने का तरीका बताया गया है. Level Up with Firebase के इस सैंपल गेम का इस्तेमाल, Firebase + Unity के कई अन्य कोडलैब में किया जाता है. इसलिए, हो सकता है कि आपने इस सेक्शन में दिए गए टास्क पहले ही पूरे कर लिए हों. अगर ऐसा है, तो इन चरणों को छोड़कर, सैंपल गेम कोड में रिमोट कॉन्फ़िगरेशन जोड़ने के लिए, Unity के लिए Firebase SDK टूल जोड़ें.

कोड डाउनलोड करना

कमांड लाइन से, इस कोडलैब की GitHub रिपॉज़िटरी को क्लोन करें:

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

इसके अलावा, अगर आपने git इंस्टॉल नहीं किया है, तो रिपॉज़िटरी को ZIP फ़ाइल के तौर पर डाउनलोड करें.

Unity एडिटर में Level Up with Firebase खोलें

Unity Hub लॉन्च करें. इसके बाद, प्रोजेक्ट टैब में जाकर, खोलें के बगल में मौजूद ड्रॉप-डाउन ऐरो पर क्लिक करें.
डिस्क से प्रोजेक्ट जोड़ें पर क्लिक करें.
उस डायरेक्ट्री पर जाएं जिसमें कोड मौजूद है. इसके बाद, ठीक है पर क्लिक करें.
अगर आपको प्रॉम्प्ट दिखे, तो इस्तेमाल करने के लिए Unity Editor का वर्शन और टारगेट प्लैटफ़ॉर्म (Android या iOS) चुनें.
प्रोजेक्ट के नाम level-up-with-firebase पर क्लिक करें. इसके बाद, प्रोजेक्ट Unity एडिटर में खुल जाएगा.
अगर आपका एडिटर इसे अपने-आप नहीं खोलता है, तो Unity Editor के प्रोजेक्ट टैब में ऐसेट > हैम्स्टर में जाकर MainGameScene खोलें.

Unity को इंस्टॉल करने और इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, Unity में काम करना लेख पढ़ें.

3. Firebase को अपने Unity प्रोजेक्ट से जोड़ना

Firebase प्रोजेक्ट बनाना

अपने Google खाते का इस्तेमाल करके, Firebase कंसोल में साइन इन करें.
नया प्रोजेक्ट बनाने के लिए, बटन पर क्लिक करें. इसके बाद, प्रोजेक्ट का नाम डालें. उदाहरण के लिए, LevelUpWithFirebase.
इस प्रोजेक्ट के नाम का इस्तेमाल, Firebase इंटरफ़ेस में डिसप्ले नेम के तौर पर किया जाता है. साथ ही, Firebase इस प्रोजेक्ट के नाम के आधार पर, अपने-आप एक यूनीक प्रोजेक्ट आईडी बना लेता है. ध्यान दें कि अब आपके पास अपनी पसंद के प्रोजेक्ट आईडी को सेट करने के लिए, बदलाव करें आइकॉन पर क्लिक करने का विकल्प है. हालांकि, प्रोजेक्ट बनाने के बाद इस आईडी को बदला नहीं जा सकता.

अपना प्रोजेक्ट आईडी याद रखें, क्योंकि बाद में आपको Firebase CLI में अपने Firebase प्रोजेक्ट की पहचान करने के लिए इसकी ज़रूरत होगी. अगर आपको अपना आईडी याद नहीं रहता है, तो इसे बाद में प्रोजेक्ट सेटिंग में जाकर देखा जा सकता है.
जारी रखें पर क्लिक करें.
अगर आपसे कहा जाए, तो Firebase की शर्तें पढ़ें और स्वीकार करें. इसके बाद, जारी रखें पर क्लिक करें.
(ज़रूरी नहीं) Firebase कंसोल में एआई की मदद पाने की सुविधा चालू करें. इसे "Firebase में Gemini" कहा जाता है.
इस कोडलैब के लिए, आपको Firebase के प्रॉडक्ट का बेहतर तरीके से इस्तेमाल करने के लिए Google Analytics की ज़रूरत होगी. इसलिए, Google Analytics के विकल्प के लिए टॉगल चालू रखें. Google Analytics को सेट अप करने के लिए, स्क्रीन पर दिए गए निर्देशों का पालन करें.
प्रोजेक्ट बनाएं पर क्लिक करें. इसके बाद, प्रोजेक्ट के प्रोविज़न होने का इंतज़ार करें. इसके बाद, जारी रखें पर क्लिक करें.

अपने ऐप्लिकेशन को Firebase के साथ रजिस्टर करना

Firebase कंसोल खोलें. इसके बाद, प्रोजेक्ट की खास जानकारी वाले पेज के बीच में मौजूद Unity आइकॉन पर क्लिक करके, सेटअप वर्कफ़्लो लॉन्च करें. अगर आपने पहले ही अपने Firebase प्रोजेक्ट में कोई ऐप्लिकेशन जोड़ लिया है, तो प्लैटफ़ॉर्म के विकल्प दिखाने के लिए, ऐप्लिकेशन जोड़ें पर क्लिक करें.
Apple (iOS) और Android, दोनों बिल्ड टारगेट रजिस्टर करने के लिए चुनें.
अपने Unity प्रोजेक्ट के प्लैटफ़ॉर्म के हिसाब से आईडी डालें. इस कोडलैब के लिए, यह जानकारी डालें:
- Apple (iOS) के लिए - iOS बंडल आईडी फ़ील्ड में com.google.firebase.level-up डालें.
- Android के लिए - Android पैकेज का नाम फ़ील्ड में com.google.firebase.level_up डालें.
अगर चाहें, तो अपने Unity प्रोजेक्ट के प्लैटफ़ॉर्म के हिसाब से निकनेम डालें.
ऐप्लिकेशन रजिस्टर करें पर क्लिक करें और कॉन्फ़िगरेशन फ़ाइल डाउनलोड करें सेक्शन पर जाएं.
जिस बिल्ड टारगेट के लिए आपने पहली बार यह प्रोसेस नहीं की है उसके लिए इसे दोहराएं.

Firebase कॉन्फ़िगरेशन फ़ाइलें जोड़ना

ऐप्लिकेशन रजिस्टर करें पर क्लिक करने के बाद, आपको दो कॉन्फ़िगरेशन फ़ाइलें डाउनलोड करने के लिए कहा जाएगा. हर बिल्ड टारगेट के लिए एक कॉन्फ़िगरेशन फ़ाइल होती है. Firebase से कनेक्ट करने के लिए, आपके यूनिटी प्रोजेक्ट को इन फ़ाइलों में Firebase के मेटाडेटा की ज़रूरत होती है.

उपलब्ध दोनों कॉन्फ़िगरेशन फ़ाइलें डाउनलोड करें:
- Apple (iOS) के लिए: GoogleService-Info.plist डाउनलोड करें.
- Android के लिए: google-services.json डाउनलोड करें.
अपने यूनिटी प्रोजेक्ट की प्रोजेक्ट विंडो खोलें. इसके बाद, दोनों कॉन्फ़िगरेशन फ़ाइलों को ऐसेट फ़ोल्डर में ले जाएं.
अहम जानकारी: अगर आपको सिर्फ़ iOS या Android के लिए ऐप्लिकेशन बनाना है, तब भी आपको दोनों फ़ाइलें डाउनलोड करनी चाहिए और उन्हें अपने प्रोजेक्ट में जोड़ना चाहिए.
Firebase कंसोल में वापस जाकर, सेटअप वर्कफ़्लो में आगे बढ़ें पर क्लिक करें. इसके बाद, Unity के लिए Firebase SDK टूल जोड़ें.

ध्यान दें: इन फ़ाइलों को बाद में कभी भी फिर से डाउनलोड किया जा सकता है. इसके लिए, अपने प्रोजेक्ट की सामान्य सेटिंग खोलें. इसके बाद, नीचे की ओर स्क्रोल करके आपके ऐप्लिकेशन सेक्शन पर जाएं. इसके बाद, अपनी पसंद की कॉन्फ़िगरेशन फ़ाइल के लिए, डाउनलोड बटन पर क्लिक करें.

Unity के लिए Firebase SDK टूल जोड़ना

Firebase कंसोल में, Firebase यूनिटी SDK डाउनलोड करें पर क्लिक करें.
ध्यान दें: इस SDK टूल को डाउनलोड होने में थोड़ा समय लग सकता है. अगले चरणों की झलक देखें या कुछ देर का ब्रेक लें.
SDK टूल को किसी ऐसी जगह पर अनज़िप करें जहां आपको आसानी से मिल जाए.
खुले हुए Unity प्रोजेक्ट में, ऐसेट > पैकेज इंपोर्ट करें > कस्टम पैकेज पर जाएं.
इंपोर्ट पैकेज डायलॉग में, उस डायरेक्ट्री पर जाएं जिसमें अनज़िप किया गया एसडीके मौजूद है. इसके बाद, FirebaseAnalytics.unitypackage को चुनें और खोलें पर क्लिक करें.
इसके बाद, दिखने वाले यूनिटी पैकेज इंपोर्ट करें डायलॉग में, इंपोर्ट करें पर क्लिक करें.
इन दो पैकेज को इंपोर्ट करने के लिए, पिछले चरणों को दोहराएं:
- FirebaseRemoteConfig.unitypackage
- FirebaseCrashlytics.unitypackage
  Crashlytics, ऐप्लिकेशन बंद होने की रिपोर्ट देने वाला एक हल्का टूल है. यह रीयलटाइम में काम करता है. इसकी मदद से, ऐप्लिकेशन की क्वालिटी को खराब करने वाली स्थिरता की समस्याओं को ट्रैक किया जा सकता है, उन्हें प्राथमिकता दी जा सकती है, और ठीक किया जा सकता है. अगर आपने पहले कभी इसका इस्तेमाल नहीं किया है, तो Unity के लिए Crashlytics लर्निंग पाथवे को पूरा करें.
Firebase कंसोल पर वापस जाएं और सेटअप वर्कफ़्लो में, आगे बढ़ें पर क्लिक करें.

Unity प्रोजेक्ट में Firebase SDK टूल जोड़ने के बारे में ज़्यादा जानने के लिए, Unity में इंस्टॉल करने के अन्य विकल्प लेख पढ़ें.

4. Remote Config के डिफ़ॉल्ट सेट करना और नई वैल्यू फ़ेच करना

इस कोडलैब में, आपको उन ऑब्जेक्ट को अपडेट करना होगा जो कोड में तय की गई वैल्यू का इस्तेमाल करते हैं या Unity एडिटर में क्रम से लगाए जाते हैं. ऐसा इसलिए, ताकि वे Remote Config के साथ इंस्ट्रुमेंट की गई वैल्यू का इस्तेमाल कर सकें. SetDefaultsAsync का इस्तेमाल करके, हर पैरामीटर के लिए डिफ़ॉल्ट वैल्यू कॉन्फ़िगर की जाएंगी. इससे, रिमोट कॉन्फ़िगरेशन बैकएंड से कनेक्ट होने से पहले, आपका ऐप्लिकेशन उम्मीद के मुताबिक काम करेगा. आपका ऐप्लिकेशन, Remote Config से नई वैल्यू फ़ेच करके उन्हें चालू करेगा. इससे, कोड में उनका इस्तेमाल किया जा सकेगा.

रिमोट कॉन्फ़िगरेशन से नई वैल्यू फ़ेच करने के लिए, Assets/Hamster/Scripts/MainGame.cs फ़ाइल में कई ऐसे तरीके मौजूद हैं जिन्हें लागू नहीं किया गया है. इन्हें पूरा करना ज़रूरी है.

MainGame.cs में ये using स्टेटमेंट जोड़ें:
```
using Firebase.Crashlytics;
using Firebase.Extensions;
using Firebase.RemoteConfig;
```
Firebase.Extensions मॉड्यूल में, C# Tasks API के कुछ एक्सटेंशन शामिल हैं. इनसे, कॉलबैक के साथ इनिशियलाइज़ेशन प्रोसेस को मैनेज करना आसान हो जाएगा.
अपनी MainGame.cs Start() विधि में Firebase को शुरू करने की सुविधा जोड़ें. इसके लिए, 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 को वैकल्पिक कॉलबैक पास किए जा सकते हैं. उदाहरण के लिए, एक ऐसी विधि को पास करना जो नए यूज़र इंटरफ़ेस (यूआई) मेन्यू खोलती है. ये मेन्यू, 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);
      });
}
```
ध्यान दें: FetchAsync को पास की गई cacheExpiration वैल्यू से यह तय होता है कि पहले से फ़ेच की गई वैल्यू को कितने समय तक कैश मेमोरी में सेव रखना है. डेवलपमेंट के दौरान, इसे ऊपर दिखाए गए तरीके से System.TimeSpan.Zero पर सेट किया जा सकता है. इससे यह पक्का होता है कि ऐप्लिकेशन में हमेशा अप-टू-डेट वैल्यू दिखें. हालांकि, प्रोडक्शन में रिलीज़ करते समय, आपको cacheExpiration को ज़्यादा वैल्यू पर सेट करना चाहिए, ताकि थ्रॉटलिंग से बचा जा सके. डिफ़ॉल्ट समयावधि (जब FetchAsync को पैरामीटर के बिना कॉल किया जाता है) 12 घंटे होती है.

इसके बाद, ActivateRetrievedRemoteConfigValues तरीके को पूरा करें. यह पास किए गए कॉलबैक, 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. Remote Config को लोड करने की रणनीति सेट अप करना

ऐप्लिकेशन के इस्तेमाल के दौरान, किसी दूसरे समय पर वैल्यू फ़ेच और चालू करने के लिए, आपको इन फ़ंक्शन को फिर से कॉल करना होगा. साथ ही, अगर किसी ऑब्जेक्ट ने वैल्यू को कैश मेमोरी में सेव किया है, तो उसे अपडेट करने के लिए सूचना दी जानी चाहिए. रिमोट कॉन्फ़िगरेशन की वैल्यू को फिर से फ़ेच करने की रणनीति बनाने के लिए, यह तय करें कि नई वैल्यू की ज़रूरत कब है. साथ ही, नई वैल्यू को फ़ेच करने और चालू करने की प्रोसेस कब शुरू करनी है, ताकि इस्तेमाल के दौरान उनमें बदलाव न हो.

फ़िलहाल, Remote Config वैल्यू को ऐप्लिकेशन शुरू होने पर फ़ेच और चालू किया जाता है. मेन्यू में बदलाव करते समय, फ़ेच किए गए डेटा को छिपाया जा सकता है. साथ ही, ट्रांज़िशन के दौरान इंटरैक्शन को ब्लॉक किया जा सकता है. इसके अलावा, नई वैल्यू पाने के लिए यह सबसे सही समय होता है. ऐसा इसलिए, क्योंकि मेन्यू की स्थिति में बदलाव का इस्तेमाल अक्सर यह जानने के लिए किया जा सकता है कि प्लेयर "कहां" जा रहा है. साथ ही, यह अनुमान लगाया जा सकता है कि किसी वैल्यू का इस्तेमाल किया जाएगा.

Mechahamster के मेन्यू सिस्टम को देखने पर पता चलता है कि यूज़र इंटरफ़ेस (यूआई) को ब्लॉक करने वाले मेन्यू को रीफ़्रेश करने का सबसे आसान तरीका यह है कि मुख्य मेन्यू के फिर से शुरू होने से पहले इसे कॉल किया जाए. खास तौर पर, तब जब इसे किसी दूसरे मेन्यू से वापस जाकर ऐक्सेस किया जाता है. साथ ही, यूज़र इंटरफ़ेस (यूआई) को दिखाने के तरीके को onFetchAndActivateSuccessful कॉलबैक के तौर पर पास किया जाए. ऐसा ही लेवल चुनें मेन्यू के लिए भी किया जा सकता है.

ऐप्लिकेशन के शुरू होने पर, शुरुआती लोड के साथ-साथ मुख्य मेन्यू से होकर जाने वाले किसी भी मेन्यू नेविगेशन को इनमें से पहला हैंडल करेगा. वहीं, लेवल चुनें मेन्यू में फिर से जाने पर भी रीफ़्रेश होगा. लेवल चुनने के मेन्यू में शुरुआती एंट्री से कोई फ़र्क़ नहीं पड़ता, क्योंकि इसे सिर्फ़ मुख्य मेन्यू से ऐक्सेस किया जा सकता है. इसलिए, यह पहले से ही शामिल है.

ऐप्लिकेशन में इसे चालू करने के लिए, मुख्य मेन्यू और लेवल चुनने वाली फ़ाइलों में दिए गए तरीकों को पूरा करें. इससे यूज़र इंटरफ़ेस (यूआई) तब तक नहीं दिखेगा, जब तक 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 चलाकर लॉग देखें. अगर आपने एडिटर में Play बटन दबाकर Unity में कोड चलाया है, तो लॉग, Console टैब में दिखेंगे.

ऐप्लिकेशन को फिर से बनाएं और उसे चलाएं. इसके लिए, एडिटर में डिवाइस या सिम्युलेटर का इस्तेमाल करें.
गेम का मुख्य मेन्यू दिखने के बाद, गेम के लॉग आउटपुट की समीक्षा करें. इसमें FetchRemoteConfig और ActivateRetrievedRemoteConfigValues में Debug.Log से जनरेट किए गए लॉग शामिल होने चाहिए. इनमें "डेटा फ़ेच किया जा रहा है..." और "रिमोट डेटा लोड हो गया है और इस्तेमाल के लिए तैयार है" मैसेज दिखने चाहिए. इन मैसेज की शुरुआत में दिए गए टाइमस्टैंप नोट करें.
गेम में, लाइसेंस दबाएं.
ठीक है दबाएं.
गेम के मुख्य मेन्यू के दिखने का इंतज़ार करें.
अपने गेम के लॉग आउटपुट की समीक्षा करें. यह पिछले चरण में दिए गए लॉग आउटपुट जैसा होना चाहिए. हालांकि, इसमें नए टाइमस्टैंप होने चाहिए. ये टाइमस्टैंप, उस सिस्टम क्लॉक पर सेट किए गए समय से मेल खाने चाहिए जिस पर गेम चल रहा है.
गेम में, खेलें दबाएं.
शुरू करें दबाएं.
कीबोर्ड के ऐरो बटन का इस्तेमाल करके, गेंद को गोल तक पहुंचाएं. इससे लेवल पूरा होने का मेन्यू खुलेगा.
Levels दबाएं.
लेवल चुनें मेन्यू के लोड होने का इंतज़ार करें.
अपने गेम के लॉग आउटपुट की फिर से समीक्षा करें. यह पिछले चरणों के लॉग मैसेज से मेल खाना चाहिए. साथ ही, इसमें नए टाइमस्टैंप होने चाहिए. ये टाइमस्टैंप, उस सिस्टम क्लॉक से मेल खाने चाहिए जिस पर गेम चल रहा है.

अगर इनमें से कोई भी सुविधा आपके ऐप्लिकेशन में नहीं दिखती है, तो हो सकता है कि फ़ेच और चालू करने की प्रोसेस का कोई हिस्सा या आपका डिवाइस गलत तरीके से कॉन्फ़िगर किया गया हो. अगर पहला लॉग नहीं दिखता है, तो हो सकता है कि आपका गेम शुरू न हो. अपने प्रोजेक्ट/एनवायरमेंट के बारे में चेतावनियों और गड़बड़ियों के लिए, एडिटर कंसोल या डिवाइस/इमुलेटर लॉग देखें. साथ ही, उनकी जांच करें. हो सकता है कि समस्या इंटरनेट से कनेक्ट करने जैसी सामान्य हो.

अगर मेन्यू लोड करने के शुरुआती लॉग दिखते हैं, लेकिन बाद के लॉग में से कोई एक नहीं दिखता है, तो Assets/Hamster/Scripts/States/MainMenu.cs और Assets/Hamster/Scripts/States/BaseLevelSelect.cs में Resume तरीकों की जांच करें/उन्हें फिर से लागू करें.

8. अपने कोड को इंस्ट्रूमेंट करना

आपने SetDefaultsAsync() में ऐप्लिकेशन में मौजूद पैरामीटर की वैल्यू कॉन्फ़िगर कर ली हैं. साथ ही, FetchAsync() और ActivateAsync() की मदद से, सबसे नए वर्शन उपलब्ध करा दिए हैं. अब आपको कोड में उन वैल्यू का रेफ़रंस देना होगा और उनका इस्तेमाल करना होगा.

रिमोट कॉन्फ़िगरेशन बैकएंड में वैल्यू सेट करने के बाद, उन्हें फ़ेच करें और चालू करें (या दोनों काम एक साथ करें). इसके बाद, ये वैल्यू आपके ऐप्लिकेशन के लिए उपलब्ध हो जाती हैं. इन वैल्यू का इस्तेमाल करने के लिए, 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
AccelerationTile.cs के Start तरीके को बदलें:
```
private void Start() {
   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   Acceleration = (float)remoteConfig.GetValue(AccelerationTileForceKey).DoubleValue;
}
```
इस बदलाव के बाद, ऐक्सलरेशन टाइल से मिलने वाले फ़ोर्स की वैल्यू, Remote Config से मिलने वाली वैल्यू में बदल जाएगी.

MainMenu.cs के InitializeUI तरीके के मुख्य हिस्से में बदलाव करें:

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 सर्वर पर पैरामीटर और वैल्यू कॉन्फ़िगर की जा सकती हैं. इस कोडलैब में, हम Firebase कंसोल का इस्तेमाल करके इसे सेट अप करेंगे.

Firebase कंसोल में, अपना प्रोजेक्ट खोलें.
रिमोट कॉन्फ़िगरेशन डैशबोर्ड देखने के लिए, मेन्यू से Remote Config चुनें.

आपने अपने ऐप्लिकेशन में जिन पैरामीटर को तय किया है और यहां दी गई टेबल में उनकी सूची दी गई है उनमें से हर एक के लिए, पैरामीटर जोड़ें पर क्लिक करें. इसके बाद, पैरामीटर का नाम (कुंजी) चिपकाएं, टेबल में दिया गया डेटा टाइप चुनें, ऐप्लिकेशन में डिफ़ॉल्ट वैल्यू का इस्तेमाल करें को बंद करें, और नई डिफ़ॉल्ट वैल्यू चिपकाएं:

पैरामीटर का नाम (कुंजी)	डेटा टाइप	डिफ़ॉल्ट वैल्यू
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}}`

रिमोट कॉन्फ़िगरेशन पैरामीटर एडिटर में, acceleration_tile_force फ़ील्ड में वैल्यू भरी गई है

अपने बदलावों को सेव करने के लिए, सेव करें पर क्लिक करें.
नए कॉन्फ़िगरेशन को पब्लिश करने और नई वैल्यू को अपने गेम के लिए उपलब्ध कराने के लिए, पब्लिश करें पर क्लिक करें.
इन रिमोट पैरामीटर को सेट करने के बाद, अपने ऐप्लिकेशन को फिर से चलाएं और देखें कि ये ओरिजनल डिफ़ॉल्ट वैल्यू को कैसे बदल देते हैं.
अहम जानकारी: फ़िज़िक्स की वैल्यू जैसी ऐसी वैल्यू के लिए जिन्हें देखना मुश्किल होता है, कोड को अपडेट किया जा सकता है. इससे ConfigValue.Source की वैल्यू को लॉग किया जा सकता है. इससे यह पता चलता है कि वैल्यू, कॉन्फ़िगर किए गए डिफ़ॉल्ट मान हैं या उन्हें रिमोट कॉन्फ़िगरेशन सर्वर से फ़ेच किया गया है.

ध्यान दें: JsonUtility के ToJson और FromJson<T> तरीकों का इस्तेमाल करके, किसी Serializable डेटा ऑब्जेक्ट को स्ट्रिंग में और स्ट्रिंग से Serializable डेटा ऑब्जेक्ट में कोड में बदला जा सकता है. ऐसा फ़िलहाल MainMenu.cs में SubtitleOverrideDefault के इनिशियलाइज़ेशन में किया जाता है. Unity के Serializable दस्तावेज़ में, ऑब्जेक्ट को क्रम से लगाने के बारे में Unity की पाबंदियों के बारे में बताया गया है.

10. वैरिएंट दिखाने के लिए, Remote Config की शर्तों का इस्तेमाल करना

ऐसा हो सकता है कि आपको उपयोगकर्ता के ऐप्लिकेशन इस्तेमाल करने के अनुभव को उसकी भाषा, जगह, दिन के समय या इस्तेमाल किए जा रहे प्लैटफ़ॉर्म के हिसाब से बेहतर बनाना हो. Remote Config की शर्तों की मदद से, इन और अन्य एट्रिब्यूट का इस्तेमाल अलग-अलग या एक साथ किया जा सकता है. इससे उपयोगकर्ता को अलग-अलग वैल्यू (जिन्हें वैरिएंट कहा जाता है) दिखाई जा सकती हैं.

शर्तों का इस्तेमाल, iOS और Android प्लैटफ़ॉर्म के बीच कॉन्टेंट को बदलने के लिए किया जाता है. subtitle_override के लिए ऐसी शर्त लागू करने के लिए यहां दिया गया तरीका अपनाएं जिससे इस्तेमाल किए जा रहे प्लैटफ़ॉर्म के हिसाब से अलग-अलग वैल्यू दिखें.

Firebase कंसोल में, अपने प्रोजेक्ट का रिमोट कॉन्फ़िगरेशन टैब खोलें.
subtitle_override. के लिए, बदलाव करें बटन पर क्लिक करें
सबसे नीचे बाएं कोने में, नया जोड़ें पर क्लिक करें.
दिखने वाले ड्रॉप-डाउन में, शर्त के हिसाब से वैल्यू पर कर्सर घुमाएं. इसके बाद, नई शर्त बनाएं पर क्लिक करें. $रिमोट कॉन्फ़िगरेशन पैरामीटर एडिटर:\nशर्त के हिसाब से वैल्यू सेट करने का विकल्प$
अगर आपको iOS को टारगेट करना है, तो प्रॉम्प्ट मिलने पर शर्त का नाम "is iOS" रखें. अगर आपको Android को टारगेट करना है, तो शर्त का नाम "is Android" रखें. अगर आपको दोनों को टारगेट करना है, तो यहां सिर्फ़ एक को चुनें और बाकी कोडलैब के लिए इसका इस्तेमाल करें. $Remote Config की शर्त\neditor$
लागू होता है, अगर... में जाकर, चुनें... ड्रॉप-डाउन पर क्लिक करें और प्लैटफ़ॉर्म चुनें. इसके बाद, सही प्लैटफ़ॉर्म चुनें. $iOS प्लैटफ़ॉर्म चुनने के लिए, नई शर्त तय करें\nएडिटर का इस्तेमाल करना$
कंडिशन बनाने के लिए, कंडिशन बनाएं पर क्लिक करें. 'पैरामीटर में बदलाव करें' डायलॉग बॉक्स फिर से दिखता है. अब आपके पास वैल्यू सेट करने का विकल्प होता है:
- अगर आपको Android को टारगेट करना है, तो Value को इस पर सेट करें:
```
{"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 को कॉन्फ़िगर करना

Remote Config अब Remote Config टेंप्लेट में रीयल-टाइम में होने वाले अपडेट को सुन सकता है और उन्हें मैनेज कर सकता है. ऐप्लिकेशन, रीयल-टाइम में काम करने वाले नए Remote Config API की सदस्यता ले सकते हैं. इससे उन्हें कॉन्फ़िगरेशन में हुए बदलावों और अपडेट की गई वैल्यू के बारे में सूचनाएं मिलेंगी.

यह कैसे काम करता है

अपडेट सुनने के लिए, आपके ऐप्लिकेशन को एक ऐसा तरीका लागू करना होगा जो OnConfigUpdateListener इवेंट की सदस्यता लेता हो. जब एक या उससे ज़्यादा कॉन्फ़िगरेशन अपडेट लिसनर की सदस्यता ली जाती है, तब नए रिमोट कॉन्फ़िगरेशन टेंप्लेट अपने-आप फ़ेच हो जाते हैं. इसके बाद, सदस्यता लिए गए हैंडलर को कॉल किया जाता है. इनका इस्तेमाल, लॉजिक को लागू करने के लिए किया जा सकता है. जैसे, नई वैल्यू चालू करना और उन्हें ऐप्लिकेशन के बाकी हिस्सों के लिए उपलब्ध कराना.

रीयल-टाइम रिमोट कॉन्फ़िगरेशन लागू करना

गेम में यह सुविधा कैसे काम करती है, यह दिखाने के लिए अपने कोड में ये बदलाव करें.

कॉन्फ़िगरेशन अपडेट हैंडलर बनाना

कॉन्फ़िगरेशन अपडेट इवेंट का इस्तेमाल करने के लिए, सबसे पहले एक ऐसा तरीका बनाएं जो इसे सुन सके. नीचे दिए गए तरीके को 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 को चालू करने के लिए, इसे इवेंट की सदस्यता लें. Assets/Hamster/Scripts/MainGame.cs में मौजूद InitializeCommonDataAndStartGame() तरीके की जगह यह तरीका इस्तेमाल करें:

   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; पर खत्म होने वाली) से, इवेंट हैंडलर को इवेंट के लिए सदस्यता मिलती है.

हैंडलर के मालिकाना हक वाले ऑब्जेक्ट के बंद होने पर सदस्यता छोड़ें

शून्य रेफ़रंस वाली गड़बड़ियों को रोकने के लिए, इवेंट की सदस्यता लेने वाले तरीकों वाले ऑब्जेक्ट को, डिस्ट्रॉय होने पर उस तरीके की सदस्यता छोड़नी होगी. Assets/Hamster/Scripts/MainGame.cs में यह तरीका जोड़ें:

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

नई सुविधा को आज़माएं

नई सुविधा की पुष्टि करने के लिए, बनाए गए ऐप्लिकेशन को आज़माएं. इस प्रोसेस के लिए, यह ज़रूरी है कि आपके पास किसी असली डिवाइस का इस्तेमाल करके, लॉग पढ़ने और डीबग करने की सुविधा हो.

`acceleration_tile_force` में बदलाव करें और देखें

ऐप्लिकेशन शुरू करने के बाद, Firebase कंसोल के रिमोट कॉन्फ़िगरेशन सेक्शन में जाकर:

acceleration_tile_force के बगल में मौजूद, बदलाव करें बटन दबाएं.

वैल्यू को ‘120' पर सेट करें और सेव करें दबाएं.

बदलाव पब्लिश करें बटन पर क्लिक करें.

लॉग की जांच करें.
अगर आपको "Error occurred while listening" से शुरू होने वाला कोई लॉग मैसेज दिखता है, तो उसे पूरा पढ़ें. इसके बाद, उसमें दिए गए गड़बड़ी के मैसेज का इस्तेमाल करके डीबग करने की कोशिश करें.
अगर आपको "Updated keys" से शुरू होने वाला कोई लॉग दिखता है, तो इसका मतलब है कि आपके ऐप्लिकेशन को बदली गई वैल्यू मिल गई हैं.
अगर आपको इनमें से कोई भी लॉग नहीं दिखता है, तो अपने बाकी लॉग देखें. इसके बाद, कॉन्फ़िगरेशन अपडेट हैंडलर बनाना लेख में दिए गए निर्देशों को फिर से पढ़ें. इसके बाद, फिर से जांच करें और लॉग की दोबारा जांच करके देखें कि कोई गड़बड़ी तो नहीं है.

12. बधाई हो!

आपने रिमोट कॉन्फ़िगरेशन का इस्तेमाल करके, गेम में मौजूद वैल्यू को रिमोटली कंट्रोल किया है. इसके लिए, आपने अपने ऐप्लिकेशन में वैल्यू फ़ेच की हैं और अलग-अलग वैरिएंट दिखाने के लिए शर्तों का इस्तेमाल किया है!

हमने क्या-क्या कवर किया है

रिमोट कॉन्फ़िगरेशन की वैल्यू सेट और वापस पाने का तरीका
रीट्रिव की गई वैल्यू का इस्तेमाल करने के लिए, अपने Unity C# कोड को इंस्ट्रुमेंट करने का तरीका
JSON वैल्यू के तौर पर, कंपाउंड वैल्यू/ऑब्जेक्ट को सेव करने, इंस्ट्रुमेंट करने, और बदलने का तरीका
अलग-अलग वैल्यू वैरिएंट दिखाने के लिए, Remote Config की शर्तों का इस्तेमाल कैसे करें

अगले चरण

पैरामीटर वैल्यू की प्राथमिकता के बारे में पढ़ें. इससे आपको यह समझने में मदद मिलेगी कि जब कोई ऐप्लिकेशन इंस्टेंस, एक से ज़्यादा वैल्यू वाले पैरामीटर का इस्तेमाल करता है, तो उसे कौनसी वैल्यू मिलती हैं. ऐसा शर्तों या इलाके की वजह से होता है.