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


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

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

  1. अगर आपने पहले से ऐसा नहीं किया है, तो अपने 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:32.8.1"))

    // 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:21.6.3")
    implementation("com.google.firebase:firebase-analytics:21.6.2")
}
    क्या आपको 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. Maps ऑब्जेक्ट या अपने ऐप्लिकेशन के res/xml फ़ोल्डर में सेव की गई एक्सएमएल रिसॉर्स फ़ाइल का इस्तेमाल करके, पैरामीटर के नाम और डिफ़ॉल्ट पैरामीटर वैल्यू का एक सेट तय करें. रिमोट कॉन्फ़िगरेशन का क्विकस्टार्ट सैंपल ऐप्लिकेशन, डिफ़ॉल्ट पैरामीटर के नाम और वैल्यू तय करने के लिए, एक्सएमएल फ़ाइल का इस्तेमाल करता है.

    अगर आपने रिमोट कॉन्फ़िगरेशन बैकएंड पैरामीटर वैल्यू को पहले ही कॉन्फ़िगर किया हुआ है, तो जनरेट की गई एक्सएमएल फ़ाइल डाउनलोड की जा सकती है. इसमें सभी डिफ़ॉल्ट वैल्यू शामिल होती हैं और उसे ऐप्लिकेशन की 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 के लिए Firebase SDK टूल v21.3.0+ (Firebase BoM v31.2.4+) पर काम करते हैं.

  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 डेवलपर वाले प्रोजेक्ट पर तेज़ी से दोहराए जाने के लिए, आपके पास कुछ समय के लिए अपने ऐप्लिकेशन में कम से कम फ़ेच इंटरवल (setMinimumFetchIntervalInSeconds) वाला FirebaseRemoteConfigSettings ऑब्जेक्ट सेट करने का विकल्प होता है.

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

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

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

अगले चरण

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