Puoi utilizzare Firebase Remote Config per definire i parametri nella tua app e aggiornarne i valori nel cloud, consentendoti di modificare l'aspetto e il comportamento della tua app senza distribuire un aggiornamento. Questa guida ti illustra i passaggi per iniziare e fornisce alcuni codici campione, tutti disponibili per la clonazione o il download dal repository GitHub firebase/quickstart-ios.
Passaggio 1: aggiungi Remote Config alla tua app
Se non l'hai ancora 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
remoteConfig = RemoteConfig.remoteConfig() let settings = RemoteConfigSettings() settings.minimumFetchInterval = 0 remoteConfig.configSettings = settings
Objective-C
self.remoteConfig = [FIRRemoteConfig remoteConfig]; FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init]; remoteConfigSettings.minimumFetchInterval = 0; self.remoteConfig.configSettings = remoteConfigSettings;
Questo oggetto viene utilizzato per archiviare i valori dei parametri predefiniti in-app, recuperare i valori dei parametri aggiornati dal backend Remote Config e controllare quando i valori recuperati vengono resi disponibili per la tua app.
Durante lo sviluppo, ti consigliamo di impostare un intervallo di recupero minimo relativamente basso. Per saperne di più, consulta la sezione Limitazione.
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 la tua app si comporti come previsto prima di connettersi al backend Remote Config e in modo che i valori predefiniti siano disponibili se non sono impostati nel backend.
Definisci un insieme di nomi di parametri e valori predefiniti dei parametri utilizzando un oggetto
NSDictionary
o un file plist.Se hai già configurato i valori dei parametri di 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
Console Firebase
Nella scheda Parametri, apri il menu e seleziona Scarica valori predefiniti.
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.setDefaults(fromPlist: "RemoteConfigDefaults")
Objective-C
[self.remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];
Passaggio 3: ottieni i valori dei parametri da utilizzare nell'app
Ora puoi ottenere i valori dei parametri dall'oggetto Remote Config. Se in un secondo momento
imposti i valori nel backend Remote Config, li recuperi e li attivi,
questi valori sono disponibili per la tua app. In caso contrario, ottieni 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 conveniente per accedere a questi valori in Swift è tramite la notazione di indice 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
Utilizzare Codable per la configurazione con controllo del tipo
Per configurazioni più complesse, puoi utilizzare il protocollo Codable
di Swift per
decodificare i dati strutturati da Remote Config. Ciò fornisce una gestione della configurazione
sicura per i tipi e semplifica 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:
- Definisci strutture di configurazione complesse.
- Analizza automaticamente le configurazioni JSON.
- Garantisci la sicurezza dei tipi quando accedi ai valori di Remote Config.
- Fornisci un codice pulito e leggibile per la gestione dei modelli strutturati Remote Config.
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 di proprietà. In SwiftUI, i property wrapper vengono utilizzati per gestire lo stato, i binding e altri comportamenti delle proprietà. Per saperne di più, 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 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 eseguono l'override dei valori in-app in base alla logica condizionale o al targeting degli utenti che preferisci. Questa sezione ti guida nella procedura della console Firebase per creare questi valori.
- Nella console Firebase, apri il tuo progetto.
- Seleziona Remote Config dal menu per visualizzare la dashboard Remote Config.
- Definisci i parametri con gli stessi nomi dei parametri definiti nella tua 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. I seguenti esempi mostrano come definire una condizione di segnale personalizzata.
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 nel backend vengono recuperati e
memorizzati nella cache nell'oggetto Remote Config.
Per i casi in cui 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 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() }
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); } }];
Poiché questi valori dei parametri 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 la tua 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 in tempo reale per ascoltare gli aggiornamenti dal backend Remote Config. Remote Config in tempo reale 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 v10.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 è in attesa di aggiornamenti e, quando viene chiamatoactivateWithCompletionHandler
, 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 di Remote Config, i dispositivi che eseguono la tua app e rilevano le modifiche chiameranno il gestore 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 un periodo 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 iterare rapidamente durante lo sviluppo
e il test dell'app. Gli aggiornamenti di Remote Config in tempo reale bypassano 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
proprietà FIRRemoteConfigSettings
con un intervallo di recupero minimo basso
(MinimumFetchInterval
) nella tua app.
L'intervallo di recupero della 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 un periodo di 12 ore, indipendentemente dal numero di chiamate di recupero effettuate. Nello specifico, 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
Passaggi successivi
Se non l'hai ancora fatto, esplora i Remote Config casi d'uso e dai un'occhiata ad alcuni dei concetti chiave e alla documentazione sulle strategie avanzate, tra cui: