Inizia a utilizzare Firebase Remote Config

iOS+ Android Web Flutter Unity C++

Importante: questa sezione descrive i passaggi per configurare Remote Config con i client web e mobile. Per gli ambienti server, consulta Utilizzare Remote Config in ambienti server.

Puoi utilizzare Firebase Remote Config per definire i parametri nella tua app e aggiornarne i valori nel cloud, in modo da modificare l'aspetto e il comportamento dell'app senza distribuire un aggiornamento. Questa guida illustra i passaggi per iniziare e fornisce del codice di esempio, che è possibile clonare o scaricare dal repository GitHub firebase/quickstart-ios.

Passaggio 1: aggiungi Remote Config all'app

1. Se non lo hai già fatto, aggiungi Firebase al tuo progetto Apple.

2. Per Remote Config, è necessario Google Analytics per il targeting condizionale delle istanze dell'app per le proprietà utente e i segmenti di pubblico. Assicurati di attivare Google Analytics nel tuo progetto.

3. Crea l'oggetto singleton Remote Config, come mostrato nell'esempio seguente:

   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

Questo oggetto viene utilizzato per memorizzare i valori predefiniti dei parametri in-app, recuperare i valori dei parametri aggiornati dal backend Remote Config e controllare quando i valori recuperati vengono resi disponibili per l'app.

Durante lo sviluppo, è consigliabile impostare un intervallo di recupero minimo relativamente basso. Per saperne di più, consulta la sezione Ritardo.

Passaggio 2: imposta i valori predefiniti dei parametri in-app

Puoi impostare i valori dei parametri predefiniti in-app nell'oggetto Remote Config, in modo che l'app si comporti come previsto prima di connettersi al backend Remote Config e che i valori predefiniti siano disponibili se non sono impostati nel backend.

Importante: non memorizzare dati riservati nelle chiavi o nei valori dei parametri Remote Config. I dati Remote Config vengono criptati in transito, ma gli utenti finali possono accedere a qualsiasi parametro Remote Config predefinito o recuperato disponibile per la loro istanza dell'app client.

1. Definisci un insieme di nomi di parametri e valori predefiniti utilizzando un oggetto NSDictionary o un file plist.

   Se hai già configurato i valori dei parametri di backend Remote Config, puoi scaricare un file Remote Config generato che include tutti i valori predefiniti e salvarlo nel tuo progetto Xcode.plist

   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
   

   Console Firebase

   1. Nella scheda Parametri, apri il menu e seleziona Scarica valori predefiniti.

   2. Quando richiesto, attiva .plist per iOS, quindi fai clic su Scarica file.

2. Aggiungi questi valori all'oggetto Remote Config utilizzando setDefaults:. L'esempio seguente imposta i valori predefiniti in-app da un file plist:

   Swift

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

   Objective-C

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

Nota: questi snippet di codice fanno riferimento al file RemoteConfigDefaults.plist del progetto di esempio quickstart-ios. Se utilizzi il file predefinito scaricato, usa remote_config_defaults.

Passaggio 3: ottieni i valori parametro da utilizzare nell'app

Ora puoi recuperare i valori dei parametri dall'oggetto Remote Config. Se in un secondo momento imposta i valori nel backend Remote Config, recuperali e poi attivali, questi valori saranno disponibili per la tua app. In caso contrario, otterrai i valori parametro in-app configurati utilizzando setDefaults:. Per ottenere questi valori, chiama il metodo configValueForKey: fornendo la chiave del parametro come argomento.

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

Un modo più leggibile e pratico per accedere a questi valori in Swift è tramite la notazione in pedice di Swift:

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

Utilizza Codable per una configurazione sicura in base al tipo

Per configurazioni più complesse, puoi utilizzare il protocollo Codable di Swift per decodificare i dati strutturati da Remote Config. In questo modo, viene garantita una gestione della configurazione sicura e semplificata l'utilizzo di oggetti complessi.

// 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)")
    }
  }
}

Questo metodo ti consente di:

• Definire strutture di configurazione complesse.
• Analizza automaticamente le configurazioni JSON.
• Assicurati la sicurezza del tipo quando accedi ai valori Remote Config.
• Fornisci un codice pulito e leggibile per la gestione dei modelli Remote Config strutturati.

Utilizzare i wrapper delle proprietà per la configurazione dichiarativa in SwiftUI

I wrapper delle proprietà sono una potente funzionalità di Swift che ti consente di aggiungere un comportamento personalizzato alle dichiarazioni delle proprietà. In SwiftUI, i wrapper delle proprietà vengono utilizzati per gestire lo stato, le associazioni e altri comportamenti delle proprietà. Per ulteriori informazioni, consulta la Guida al linguaggio 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()
    }
  }
}

Utilizza il wrapper delle proprietà @RemoteConfigProperty quando vuoi un modo dichiarativo per accedere ai valori Remote Config in SwiftUI, con il supporto integrato per i valori predefiniti e la gestione semplificata della configurazione.

Passaggio 4: imposta i valori dei parametri

Utilizzando la console Firebase o le API di backend Remote Config, puoi creare nuovi valori predefiniti di backend che sostituiscono i valori in-app in base alla logica condizionale o al targeting per utente che preferisci. Questa sezione illustra la procedura da seguire nella console Firebase per creare questi valori.

1. Nella console Firebase, apri il progetto.
2. Seleziona Remote Config dal menu per visualizzare la dashboard Remote Config.
3. Definisci i parametri con gli stessi nomi di quelli definiti nella tua app. Per ogni parametro, puoi impostare un valore predefinito (che alla fine sostituirà il valore predefinito in-app) e anche valori condizionali. Per saperne di più, consulta Remote Config Parametri e condizioni.

4. Se utilizzi le condizioni per gli indicatori personalizzati, definisci gli attributi e i relativi valori. Gli esempi riportati di seguito mostrano come definire una condizione di indicatore personalizzato.

   Swift

     Task {
         let customSignals: [String: CustomSignalValue?] = [
         "city": .string("Tokyo"),
         "preferred_event_category": .string("sports")
       ]
   
       do {
         try await remoteConfig.setCustomSignals(customSignals)
         print("Custom signals set successfully!")
         } catch {
             print("Error setting custom signals: \(error)")
         }
   }

   Objective-C

     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       NSDictionary *customSignals = @{
         @"city": @"Tokyo",
         @"preferred_event_category": @"sports"
       };
   
       [self.remoteConfig setCustomSignals:customSignals withCompletion:^(NSError * _Nullable error) {
           if (error) {
               NSLog(@"Error setting custom signals: %@", error);
           } else {
               NSLog(@"Custom signals set successfully!");
           }
     }];
   });

Passaggio 5: recupera e attiva i valori

Per recuperare i valori dei parametri da Remote Config, chiama il metodo fetchWithCompletionHandler: o fetchWithExpirationDuration:completionHandler:. Tutti i valori impostati sul backend vengono recuperati e memorizzati nella cache nell'oggetto Remote Config.

Se vuoi recuperare e attivare i valori in una chiamata, utilizza fetchAndActivateWithCompletionHandler:.

Questo esempio recupera i valori dal backend Remote Config (valori non memorizzati nella cache) e chiama activateWithCompletionHandler: per renderli disponibili all'app:

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

Poiché questi valori parametro aggiornati influiscono sul comportamento e sull'aspetto della tua app, devi attivare i valori recuperati in un momento che garantisca un'esperienza fluida per l'utente, ad esempio la volta successiva che l'utente apre l'app. Per ulteriori informazioni ed esempi, consulta le strategie di caricamento di Remote Config.

Passaggio 6: ascolta gli aggiornamenti in tempo reale

Dopo aver recuperato i valori dei parametri, puoi utilizzare Remote Config in tempo reale per monitorare gli aggiornamenti dal backend Remote Config. Remote Config in tempo reale segnala ai dispositivi connessi quando sono disponibili aggiornamenti e recupera automaticamente le modifiche dopo la pubblicazione di una nuova versione di Remote Config.

Gli aggiornamenti in tempo reale sono supportati dall'SDK Firebase per le piattaforme Apple a partire dalla versione 10.7.0.

Importante: la funzionalità Remote Config in tempo reale richiede anche l'API Firebase Remote Config in tempo reale, che dovrebbe essere già attivata. Per verificare, apri la console Google Cloud, seleziona il tuo progetto e apri la pagina API e servizi. L'API dovrebbe essere visualizzata come abilitata. Se non è presente o non è abilitata, fai clic su Abilita API e servizi, cerca Firebase Remote Config API in tempo reale e poi abilitala.

1. Nell'app, chiama addOnConfigUpdateListener per iniziare a monitorare gli aggiornamenti e recuperare automaticamente i valori dei parametri nuovi o aggiornati. L'esempio seguente ascolta gli aggiornamenti e, quando viene chiamato activateWithCompletionHandler, utilizza i valori appena recuperati per visualizzare un messaggio di benvenuto aggiornato.

   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. La volta successiva che pubblichi una nuova versione di Remote Config, i dispositivi su cui è in esecuzione la tua app e che sono in ascolto di modifiche chiameranno l'handler di completamento.

Limitazione

Se un'app esegue il recupero troppe volte in un breve periodo di tempo, le chiamate di recupero vengono limitate e l'SDK restituisce FIRRemoteConfigFetchStatusThrottled. Prima della versione 6.3.0 dell'SDK, il limite era di 5 richieste di recupero in un intervallo di 60 minuti (le versioni più recenti hanno limiti più permissivi).

Suggerimento: a partire dalla versione 10.7.0 o successive dell'SDK per le piattaforme Apple, puoi utilizzare Remote Config in tempo reale per recuperare automaticamente i valori dei parametri aggiornati dal backend di Remote Config non appena vengono pubblicati, ignorando qualsiasi impostazione minima dell'intervallo di recupero. Puoi utilizzare gli aggiornamenti in tempo reale anziché eseguire il recupero frequentemente per aggiornare la cache. Per ulteriori informazioni, vedi Ascoltare aggiornamenti in tempo reale.

Durante lo sviluppo dell'app,ti consigliamo di eseguire il recupero più spesso per aggiornare la cache molto di frequente (molte volte all'ora) in modo da poter eseguire rapidamente l'iterazione durante lo sviluppo e il test dell'app. Gli aggiornamenti di Remote Config in tempo reale aggirano automaticamente la cache quando la configurazione viene aggiornata sul server. Per eseguire rapidamente l'iterazione su un progetto con numerosi sviluppatori, puoi aggiungere temporaneamente una proprietà FIRRemoteConfigSettings con un intervallo di recupero minimo ridotto (MinimumFetchInterval) nella tua app.

L'intervallo di recupero predefinito e consigliato per la produzione di Remote Config è di 12 ore, il che significa che le configurazioni non verranno recuperate dal backend più di una volta in un intervallo di 12 ore, indipendentemente dal numero di chiamate di recupero effettivamente effettuate. Nello specifico, l'intervallo di recupero minimo viene determinato nel seguente ordine:

1. Il parametro in fetch(long)
2. Il parametro in FIRRemoteConfigSettings.MinimumFetchInterval
3. Il valore predefinito è 12 ore

Tieni presente che questa impostazione deve essere utilizzata solo per lo sviluppo, non per un'app in esecuzione in produzione. Se stai solo testando la tua app con un piccolo team di sviluppo di 10 persone, è improbabile che tu raggiunga i limiti di quota orario lato servizio. Tuttavia, se hai distribuito la tua app a migliaia di utenti di test con un intervallo di recupero minimo molto basso, probabilmente l'app raggiungerà questa quota.

Passaggi successivi

Se non l'hai ancora fatto, consulta i Remote Config casi d'uso e dai un'occhiata ad alcuni dei concetti chiave e della documentazione sulle strategie avanzate, tra cui:

• Gestire le versioni dei modelli Remote Config
• Strategie di caricamento della configurazione