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


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

पहला चरण: अपने ऐप्लिकेशन में Remote Config जोड़ना

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

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

  3. सिंगलटन Remote Config ऑब्जेक्ट बनाएं, जैसा कि इस उदाहरण में दिखाया गया है:

    Swift

    remoteConfig = RemoteConfig.remoteConfig()
let settings = RemoteConfigSettings()
settings.minimumFetchInterval = 0
remoteConfig.configSettings = settings
    ViewController.swift

    Objective-C

    self.remoteConfig = [FIRRemoteConfig remoteConfig];
FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
remoteConfigSettings.minimumFetchInterval = 0;
self.remoteConfig.configSettings = remoteConfigSettings;
    ViewController.m

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

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

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

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

  1. NSDictionary ऑब्जेक्ट या plist फ़ाइल का इस्तेमाल करके, पैरामीटर के नामों और पैरामीटर की डिफ़ॉल्ट वैल्यू का सेट तय करें.

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

    REST

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

    Firebase कंसोल

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

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

  2. setDefaults: का इस्तेमाल करके, इन वैल्यू को Remote Config ऑब्जेक्ट में जोड़ें. यहां दिए गए उदाहरण में, plist फ़ाइल से ऐप्लिकेशन में डिफ़ॉल्ट वैल्यू सेट की गई हैं:

    Swift

    remoteConfig.setDefaults(fromPlist: "RemoteConfigDefaults")
    ViewController.swift

    Objective-C

    [self.remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];
    ViewController.m

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

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

let remoteConfig = RemoteConfig.remoteConfig()

// Retrieve a parameter value using configValueForKey
let welcomeMessageValue = remoteConfig.configValue(forKey: "welcome_message")
let welcomeMessage = welcomeMessageValue.stringValue

let featureFlagValue = remoteConfig.configValue(forKey: "new_feature_flag")
let isFeatureEnabled = featureFlagValue.boolValue

Swift में इन वैल्यू को ऐक्सेस करने का एक ज़्यादा आसान तरीका है, वह है subscript notation:

let remoteConfig = RemoteConfig.remoteConfig()

// Retrieve a string parameter value
let welcomeMessage = remoteConfig["welcome_message"].stringValue

// Retrieve a boolean parameter value
let isFeatureEnabled = remoteConfig["new_feature_flag"].boolValue

// Retrieve a number parameter value
let maxItemCount = remoteConfig["max_items"].numberValue.intValue

टाइप-सेफ़ कॉन्फ़िगरेशन के लिए, Codable का इस्तेमाल करना

ज़्यादा जटिल कॉन्फ़िगरेशन के लिए, Remote Config से स्ट्रक्चर्ड डेटा को डिकोड करने के लिए, Swift के Codable प्रोटोकॉल का इस्तेमाल किया जा सकता है. इससे, कॉन्फ़िगरेशन को सुरक्षित तरीके से मैनेज किया जा सकता है. साथ ही, कॉम्प्लेक्स ऑब्जेक्ट के साथ काम करना आसान हो जाता है.

// Define a Codable struct for your configuration
struct AppFeatureConfig: Codable {
  let isNewFeatureEnabled: Bool
  let maxUploadSize: Int
  let themeColors: [String: String]
}

// Fetch and decode the configuration
func configureAppFeatures() {
  let remoteConfig = RemoteConfig.remoteConfig()
  remoteConfig.fetchAndActivate { status, error in
    guard error == nil else { return }

    do {
      let featureConfig = try remoteConfig["app_feature_config"].decoded(asType: AppFeatureConfig.self)
      configureApp(with: featureConfig)
    } catch {
      // Handle decoding errors
      print("Failed to decode configuration: \(error)")
    }
  }
}

इस तरीके से, ये काम किए जा सकते हैं:

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

SwiftUI में, एलान वाले कॉन्फ़िगरेशन के लिए प्रॉपर्टी रैपर का इस्तेमाल करना

प्रॉपर्टी रैपर, Swift की एक बेहतरीन सुविधा है. इसकी मदद से, प्रॉपर्टी के एलान में कस्टम व्यवहार जोड़ा जा सकता है. SwiftUI में, प्रॉपर्टी रैपर का इस्तेमाल, स्टेटस, बाइंडिंग, और प्रॉपर्टी के अन्य व्यवहारों को मैनेज करने के लिए किया जाता है. ज़्यादा जानकारी के लिए, Swift भाषा की गाइड देखें.

struct ContentView: View {
  @RemoteConfigProperty(key: "cardColor", fallback: "#f05138")
  var cardColor

  var body: some View {
    VStack {
      Text("Dynamic Configuration")
        .background(Color(hex: cardColor))
    }
    .onAppear {
      RemoteConfig.remoteConfig().fetchAndActivate()
    }
  }
}

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

चौथा चरण: पैरामीटर वैल्यू सेट करना

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

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

पांचवां चरण: वैल्यू फ़ेच करना और उन्हें चालू करना

Remote Config से पैरामीटर वैल्यू फ़ेच करने के लिए, fetchWithCompletionHandler: या fetchWithExpirationDuration:completionHandler: तरीके को कॉल करें. बैकएंड पर सेट की गई सभी वैल्यू, Remote Config ऑब्जेक्ट में फ़ेच और कैश मेमोरी में सेव की जाती हैं.

जिन मामलों में आपको एक कॉल में वैल्यू फ़ेच और चालू करनी है उनके लिए, fetchAndActivateWithCompletionHandler: का इस्तेमाल करें.

यह उदाहरण, Remote Config बैकएंड से वैल्यू फ़ेच करता है (कैश मेमोरी में सेव की गई वैल्यू नहीं) और उन्हें ऐप्लिकेशन के लिए उपलब्ध कराने के लिए activateWithCompletionHandler: को कॉल करता है:

Swift

remoteConfig.fetch { (status, error) -> Void in
  if status == .success {
    print("Config fetched!")
    self.remoteConfig.activate { changed, error in
      // ...
    }
  } else {
    print("Config not fetched")
    print("Error: \(error?.localizedDescription ?? "No error available.")")
  }
  self.displayWelcome()
}
ViewController.swift

Objective-C

[self.remoteConfig fetchWithCompletionHandler:^(FIRRemoteConfigFetchStatus status, NSError *error) {
    if (status == FIRRemoteConfigFetchStatusSuccess) {
        NSLog(@"Config fetched!");
      [self.remoteConfig activateWithCompletion:^(BOOL changed, NSError * _Nullable error) {
        if (error != nil) {
          NSLog(@"Activate error: %@", error.localizedDescription);
        } else {
          dispatch_async(dispatch_get_main_queue(), ^{
            [self displayWelcome];
          });
        }
      }];
    } else {
        NSLog(@"Config not fetched");
        NSLog(@"Error %@", error.localizedDescription);
    }
}];
ViewController.m

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

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

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

Apple प्लैटफ़ॉर्म के लिए Firebase SDK टूल के 10.7.0 और उसके बाद के वर्शन पर, रीयल-टाइम अपडेट की सुविधा काम करती है.

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

    Swift

    remoteConfig.addOnConfigUpdateListener { configUpdate, error in
  guard let configUpdate, error == nil else {
    print("Error listening for config updates: \(error)")
  }

  print("Updated keys: \(configUpdate.updatedKeys)")

  self.remoteConfig.activate { changed, error in
    guard error == nil else { return self.displayError(error) }
    DispatchQueue.main.async {
      self.displayWelcome()
    }
  }
}

    Objective-C

    __weak __typeof__(self) weakSelf = self;
[self.remoteConfig addOnConfigUpdateListener:^(FIRRemoteConfigUpdate * _Nonnull configUpdate, NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error listening for config updates %@", error.localizedDescription);
  } else {
    NSLog(@"Updated keys: %@", configUpdate.updatedKeys);

    __typeof__(self) strongSelf = weakSelf;
    [strongSelf.remoteConfig activateWithCompletion:^(BOOL changed, NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Activate error %@", error.localizedDescription);
      }

      dispatch_async(dispatch_get_main_queue(), ^{
        [strongSelf displayWelcome];
      });
    }];
  }
}];

  2. अगली बार जब आप Remote Config का नया वर्शन पब्लिश करेंगे, तो आपके ऐप्लिकेशन को चला रहे और बदलावों को सुनने वाले डिवाइस, 'पूरा होने पर कॉल करने वाला फ़ंक्शन' को कॉल करेंगे.

थ्रॉटलिंग

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

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

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

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

अगले चरण

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