Firebase रिमोट कॉन्फ़िगरेशन का इस्तेमाल शुरू करना


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

पहला चरण: अपने ऐप्लिकेशन में Firebase और रिमोट कॉन्फ़िगरेशन SDK टूल जोड़ना

  1. अगर आपने पहले से Firebase को नहीं जोड़ा है, तो अपने Android प्रोजेक्ट में Firebase जोड़ें.

  2. रिमोट कॉन्फ़िगरेशन के लिए, उपयोगकर्ता प्रॉपर्टी और ऑडियंस के लिए ऐप्लिकेशन इंस्टेंस की शर्त के साथ टारगेटिंग के लिए Google Analytics की ज़रूरत होती है. पक्का करें कि आपने अपने प्रोजेक्ट में Google Analytics चालू किया हो.

  3. अपने मॉड्यूल (ऐप्लिकेशन-लेवल) की Gradle फ़ाइल (आम तौर पर, <project>/<app-module>/build.gradle.kts या <project>/<app-module>/build.gradle) में, Android के लिए रिमोट कॉन्फ़िगरेशन लाइब्रेरी के लिए डिपेंडेंसी जोड़ें. लाइब्रेरी के वर्शन को कंट्रोल करने के लिए, हम Firebase Android BoM का इस्तेमाल करने का सुझाव देते हैं.

    साथ ही, Analytics सेट अप करने के दौरान, आपको अपने ऐप्लिकेशन में Google Analytics के लिए Firebase SDK टूल जोड़ना होगा.

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.0"))

    // Add the dependencies for the Remote Config and Analytics libraries
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-config")
    implementation("com.google.firebase:firebase-analytics")
}

    Firebase Android BoM का इस्तेमाल करने पर, आपका ऐप्लिकेशन हमेशा Firebase की Android लाइब्रेरी के साथ काम करने वाले वर्शन का इस्तेमाल करेगा.

    (वैकल्पिक) BoM का इस्तेमाल किए बिना Firebase लाइब्रेरी डिपेंडेंसी जोड़ें

    अगर आप Firebase BoM का इस्तेमाल नहीं करना चाहते हैं, तो आपको उसकी डिपेंडेंसी लाइन में Firebase लाइब्रेरी के हर वर्शन की जानकारी देनी होगी.

    ध्यान दें कि अगर आप अपने ऐप्लिकेशन में कई Firebase लाइब्रेरी का इस्तेमाल करते हैं, तो हमारा सुझाव है कि लाइब्रेरी के वर्शन मैनेज करने के लिए, BoM का इस्तेमाल करें. इससे यह पक्का होता है कि ऐप्लिकेशन के सभी वर्शन काम करते हैं. 

    dependencies {
    // Add the dependencies for the Remote Config and Analytics libraries
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-config:22.0.0")
    implementation("com.google.firebase:firebase-analytics:22.0.1")
}
    क्या आपको Kotlin से जुड़े लाइब्रेरी मॉड्यूल की तलाश है? अक्टूबर 2023 (Firebase BoM 32.5.0) से, Kotlin और Java डेवलपर, दोनों मुख्य लाइब्रेरी मॉड्यूल पर निर्भर कर सकते हैं. ज़्यादा जानकारी के लिए, इस इनिशिएटिव के बारे में अक्सर पूछे जाने वाले सवाल देखें.

दूसरा चरण: रिमोट कॉन्फ़िगरेशन सिंगलटन ऑब्जेक्ट पाना

एक रिमोट कॉन्फ़िगरेशन ऑब्जेक्ट इंस्टेंस पाएं और नियमित रूप से रीफ़्रेश की अनुमति देने के लिए कम से कम फे़च करने का इंटरवल सेट करें:

Kotlin+KTX 

val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)
MainActivity.kt

Java 

FirebaseRemoteConfig mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
        .setMinimumFetchIntervalInSeconds(3600)
        .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);
MainActivity.java

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

डेवलपमेंट के दौरान, यह सुझाव दिया जाता है कि फ़ेच का कम से कम इंटरवल सेट करें. ज़्यादा जानकारी के लिए, थ्रॉटलिंग देखें.

तीसरा चरण: ऐप्लिकेशन में डिफ़ॉल्ट पैरामीटर वैल्यू को सेट करना

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

  1. पैरामीटर के नाम और डिफ़ॉल्ट पैरामीटर वैल्यू का एक सेट तय करें. इसके लिए, अपने ऐप्लिकेशन के res/xml फ़ोल्डर में सेव किए गए Maps ऑब्जेक्ट या एक्सएमएल रिसॉर्स फ़ाइल का इस्तेमाल करें. रिमोट कॉन्फ़िगरेशन के क्विकस्टार्ट सैंपल ऐप्लिकेशन में, डिफ़ॉल्ट पैरामीटर के नाम और वैल्यू तय करने के लिए एक्सएमएल फ़ाइल का इस्तेमाल किया जाता है.

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

    REST

    curl --compressed -D headers -H "Authorization: Bearer token" -X GET https://firebaseremoteconfig.googleapis.com/v1/projects/my-project-id/remoteConfig:downloadDefaults?format=XML -o remote_config_defaults.xml

    Firebase कंसोल

    1. पैरामीटर टैब में जाकर, मेन्यू खोलें और डिफ़ॉल्ट वैल्यू डाउनलोड करें को चुनें.

    2. जब कहा जाए, तब Android के लिए .xml चालू करें. इसके बाद, फ़ाइल डाउनलोड करें पर क्लिक करें.

  2. setDefaultsAsync(int) का इस्तेमाल करके, रिमोट कॉन्फ़िगरेशन ऑब्जेक्ट में ये वैल्यू जोड़ें, जैसा कि यहां दिखाया गया है:

    Kotlin+KTX 

    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java 

    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

चौथा चरण: अपने ऐप्लिकेशन में इस्तेमाल करने के लिए पैरामीटर वैल्यू पाना

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

पांचवां चरण: रिमोट कॉन्फ़िगरेशन बैकएंड में पैरामीटर वैल्यू सेट करना

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

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

छठा चरण: वैल्यू फ़ेच और चालू करना

  1. रिमोट कॉन्फ़िगरेशन बैकएंड से पैरामीटर की वैल्यू फ़ेच करने के लिए, fetch() तरीके को कॉल करें. बैकएंड में सेट की गई कोई भी वैल्यू, फ़ेच की जाती है और रिमोट कॉन्फ़िगरेशन ऑब्जेक्ट में सेव की जाती है.

  2. अपने ऐप्लिकेशन में फ़ेच की गई पैरामीटर वैल्यू उपलब्ध कराने के लिए, activate() तरीके को कॉल करें.

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

    Kotlin+KTX 

    remoteConfig.fetchAndActivate()
    .addOnCompleteListener(this) { task ->
        if (task.isSuccessful) {
            val updated = task.result
            Log.d(TAG, "Config params updated: $updated")
            Toast.makeText(
                this,
                "Fetch and activate succeeded",
                Toast.LENGTH_SHORT,
            ).show()
        } else {
            Toast.makeText(
                this,
                "Fetch failed",
                Toast.LENGTH_SHORT,
            ).show()
        }
        displayWelcomeMessage()
    }

    Java 

    mFirebaseRemoteConfig.fetchAndActivate()
        .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
            @Override
            public void onComplete(@NonNull Task<Boolean> task) {
                if (task.isSuccessful()) {
                    boolean updated = task.getResult();
                    Log.d(TAG, "Config params updated: " + updated);
                    Toast.makeText(MainActivity.this, "Fetch and activate succeeded",
                            Toast.LENGTH_SHORT).show();

                } else {
                    Toast.makeText(MainActivity.this, "Fetch failed",
                            Toast.LENGTH_SHORT).show();
                }
                displayWelcomeMessage();
            }
        });

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

सातवां चरण: रीयल टाइम में अपडेट सुनना

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

रीयल-टाइम अपडेट, Android v21.3.0+ (Firebase BoM v31.2.4+) के लिए Firebase SDK टूल पर काम करते हैं.

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

    Kotlin+KTX 

    remoteConfig.addOnConfigUpdateListener(object : ConfigUpdateListener {
    override fun onUpdate(configUpdate : ConfigUpdate) {
       Log.d(TAG, "Updated keys: " + configUpdate.updatedKeys);

       if (configUpdate.updatedKeys.contains("welcome_message")) {
           remoteConfig.activate().addOnCompleteListener {
               displayWelcomeMessage()
           }
       }
    }

    override fun onError(error : FirebaseRemoteConfigException) {
        Log.w(TAG, "Config update error with code: " + error.code, error)
    }
})

    Java 

    mFirebaseRemoteConfig.addOnConfigUpdateListener(new ConfigUpdateListener() {
    @Override
    public void onUpdate(ConfigUpdate configUpdate) {
        Log.d(TAG, "Updated keys: " + configUpdate.getUpdatedKeys());

        mFirebaseRemoteConfig.activate().addOnCompleteListener(new OnCompleteListener() {
            @Override
            public void onComplete(@NonNull Task task) {
                displayWelcomeMessage();
            }
        });
    }

    @Override
    public void onError(FirebaseRemoteConfigException error) {
        Log.w(TAG, "Config update error with code: " + error.getCode(), error);
    }
});

  2. अगली बार अपने रिमोट कॉन्फ़िगरेशन का नया वर्शन पब्लिश करने पर, ऐसे डिवाइस ConfigUpdateListener कॉल करेंगे जो आपका ऐप्लिकेशन चला रहे हैं और बदलावों को सुन रहे हैं.

थ्रॉटलिंग

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

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

रिमोट कॉन्फ़िगरेशन के लिए डिफ़ॉल्ट रूप से, फ़ेच करने का कम से कम इंटरवल 12 घंटे का होता है. इसका मतलब है कि 12 घंटे की विंडो में, बैकएंड से एक से ज़्यादा बार कॉन्फ़िगरेशन फ़ेच नहीं किए जा सकेंगे. भले ही, असल में कितने भी फ़ेच कॉल किए गए हों. खास तौर पर, फ़ेच करने का कम से कम इंटरवल इस क्रम में तय किया जाता है:

  1. fetch(long) में मौजूद पैरामीटर
  2. FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long) में मौजूद पैरामीटर
  3. 12 घंटे की डिफ़ॉल्ट वैल्यू

डेटा फ़ेच करने के लिए तय किया गया कम से कम इंटरवल, कस्टम वैल्यू पर सेट करने के लिए FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long) का इस्तेमाल करें.

अगले चरण

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