Inizia a utilizzare Remote Config su iOS

Seleziona la piattaforma:

iOS+ Android Web Flutter Unity C++

Puoi utilizzare Firebase Remote Config per definire i parametri nella tua app e aggiornarne i valori nel cloud, il che ti consente di modificare l'aspetto e il comportamento dell'app senza distribuire un aggiornamento. Questa guida illustra i passaggi per iniziare e fornisce alcuni esempi di codice, tutti disponibili per il clone o il download dal repository GitHub firebase/quickstart-ios.

Passaggio 1: aggiungi Remote Config alla tua app

Se non l'hai già fatto, aggiungi Firebase al tuo progetto Apple.
Per Remote Config, Google Analytics è necessario per il targeting condizionale delle istanze dell'app in base alle proprietà utente e ai segmenti di pubblico. Assicurati di attivare Google Analytics nel tuo progetto.

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

Swift

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

Objective-C

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

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

Durante lo sviluppo, è consigliabile impostare un intervallo di recupero minimo relativamente basso. Per ulteriori informazioni, consulta Limitazione.

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

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

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

Se hai già configurato i valori dei parametri del backend Remote Config, puoi scaricare un file plist generato che include tutti i valori predefiniti e salvarlo nel tuo progetto 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
```
Puoi generare un token di autenticazione Bearer eseguendo il seguente comando utilizzando la Google Cloud CLI o Cloud Shell:
```
gcloud auth print-access-token
```
Questo token ha una durata breve, quindi potrebbe essere necessario rigenerarlo se ricevi un errore di autenticazione.
Firebase console
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.

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

Swift

RemoteConfig.remoteConfig().setDefaults(fromPlist: "RemoteConfigDefaults")MigratedSnippets.swift

Objective-C

[remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];ObjCMigratedSnippets.m

Passaggio 3: recupera i valori dei parametri da utilizzare nell'app

Ora puoi recuperare i valori dei parametri dall'oggetto Remote Config. Se in un secondo momento imposti i valori nel Remote Config backend, li recuperi e li attivi, questi valori saranno disponibili per la tua app. In caso contrario, riceverai i valori dei parametri in-app configurati utilizzando setDefaults:. Per recuperare questi valori, chiama il configValueForKey: metodo, 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 di sottoscrizione 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 la configurazione con sicurezza dei tipi

Per configurazioni più complesse, puoi utilizzare il protocollo Codable di Swift per decodificare i dati strutturati da Remote Config. In questo modo, la gestione della configurazione è con sicurezza dei tipi e il lavoro con oggetti complessi è semplificato.

// 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.
Analizzare automaticamente le configurazioni JSON.
Garantire la sicurezza dei tipi quando si accede ai valori Remote Config.
Fornire codice pulito e leggibile per la gestione dei modelli di Remote Config strutturati Remote Config

Utilizza i wrapper di proprietà per la configurazione dichiarativa in SwiftUI

I wrapper di proprietà sono una potente funzionalità di Swift che ti consente di aggiungere un comportamento personalizzato alle dichiarazioni di proprietà. In SwiftUI, i wrapper di proprietà vengono utilizzati per gestire lo stato, i binding 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 di proprietà @RemoteConfigProperty quando vuoi un modo dichiarativo per accedere ai valori Remote Config in SwiftUI, con supporto integrato per i valori predefiniti e gestione della configurazione semplificata.

Passaggio 4: imposta i valori dei parametri

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

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

Se utilizzi condizioni di indicatori personalizzati, definisci gli attributi e i relativi valori. Gli esempi seguenti mostrano come definire una condizione di indicatori personalizzati.

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 fetchWithCompletionHandler: o fetchWithExpirationDuration:completionHandler: metodo. Tutti i valori impostati nel backend vengono recuperati e memorizzati nella cache nell' Remote Config oggetto.

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

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

Swift

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

Objective-C

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

Poiché questi valori dei parametri aggiornati influiscono sul comportamento e sull'aspetto di l'app, devi attivare i valori recuperati in un momento che garantisca un'esperienza fluida per l'utente, ad esempio la prossima volta che l'utente apre l'app. Per ulteriori informazioni ed esempi, consulta 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 per ascoltare gli aggiornamenti dal backend Remote Config. Real-time Remote Config segnala ai dispositivi connessi quando sono disponibili aggiornamenti e recupera automaticamente le modifiche dopo la pubblicazione di una nuova Remote Config versione.

Gli aggiornamenti in tempo reale sono supportati dall'SDK Firebase per le piattaforme Apple versione 10.7.0 e successive.

Nella tua app, chiama addOnConfigUpdateListener per iniziare ad ascoltare gli aggiornamenti e recuperare automaticamente i valori dei parametri nuovi o aggiornati. L'esempio seguente ascolta gli aggiornamenti e, quando activateWithCompletionHandler viene chiamato, 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];
        });
      }];
    }
  }];

La prossima volta che pubblichi una nuova versione del tuo Remote Config, i dispositivi che eseguono l'app e ascoltano le modifiche chiameranno l'handler di completamento.

Limitazione

Se un'app recupera 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 una finestra di 60 minuti (le versioni più recenti hanno limiti più permissivi).

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

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

Il parametro in fetch(long)
Il parametro in FIRRemoteConfigSettings.MinimumFetchInterval
Il valore predefinito di 12 ore

Inizia a utilizzare Remote Config su iOS Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Passaggio 1: aggiungi Remote Config alla tua app

Swift

Objective-C

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

REST

Firebase console

Swift

Objective-C

Passaggio 3: recupera i valori dei parametri da utilizzare nell'app

Utilizza Codable per la configurazione con sicurezza dei tipi

Utilizza i wrapper di proprietà per la configurazione dichiarativa in SwiftUI

Passaggio 4: imposta i valori dei parametri

Swift

Objective-C

Passaggio 5: recupera e attiva i valori

Swift

Objective-C

Passaggio 6: ascolta gli aggiornamenti in tempo reale

Swift

Objective-C

Limitazione

Inizia a utilizzare Remote Config su iOS