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 della tua app senza distribuire un aggiornamento. Questa guida illustra i passaggi per iniziare e fornisce un po' di codice di esempio, che è possibile clonare o scaricare dal repository GitHub firebase/quickstart-android.

Passaggio 1: aggiungi Firebase e l'SDK Remote Config alla tua app

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

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

3. Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi la dipendenza per la libreria Remote Config per Android. Ti consigliamo di utilizzare Firebase Android BoM per controllare la versione della libreria.

   Inoltre, durante la configurazione di Analytics, devi aggiungere all'app l'SDK Firebase per Google Analytics.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.6.0"))
   
       // 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")
   }
   

   Utilizzando Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase per Android.

   (Alternativa)  Aggiungi le dipendenze della libreria Firebase senza utilizzare il file BoM

   Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella relativa riga di dipendenza.

   Tieni presente che se nella tua app utilizzi più librerie Firebase, ti consigliamo vivamente di utilizzare BoM per gestire le versioni delle librerie, in modo da garantire la compatibilità di tutte le versioni.

   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:22.0.1")
       implementation("com.google.firebase:firebase-analytics:22.1.2")
   }
   

   Cerchi un modulo della libreria specifico per Kotlin? A partire da ottobre 2023 (Firebase BoM 32.5.0), sia gli sviluppatori Kotlin sia quelli Java possono fare affidamento sul modulo della libreria principale (per maggiori dettagli, consulta le Domande frequenti su questa iniziativa).

Nota: poiché l'SDK Android dipende dall'API REST Remote Config, assicurati di non disattivare questa API, che è abilitata per impostazione predefinita in un progetto tipico.

Passaggio 2: ottieni l'oggetto singleton Remote Config

Ottieni un'istanza dell'oggetto Remote Config e imposta l'intervallo di recupero minimo per consentire aggiornamenti frequenti:

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

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

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

Passaggio 3: 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 in modo 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 parametro e valori predefiniti utilizzando un oggetto Map o un file di risorse XML memorizzato nella cartella res/xml dell'app. L'app di esempio della guida rapida Remote Config utilizza un file XML per definire i nomi e i valori dei parametri predefiniti.

   Se hai già configurato i valori dei parametri di backend Remote Config, puoi scaricare un file XML generato che include tutti i valori predefiniti e salvarlo nella directory res/xml della tua app:

   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
   

   Console Firebase

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

   2. Quando richiesto, attiva .xml per Android, quindi fai clic su Scarica file.

2. Aggiungi questi valori all'oggetto Remote Config utilizzando setDefaultsAsync(int), come mostrato:

   Kotlin+KTX

   remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

   Java

   mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

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

Ora puoi recuperare i valori dei parametri dall'oggetto Remote Config. Se imposti i valori nel backend, li recuperi e li attivi, questi valori sono disponibili per la tua app. In caso contrario, ottieni i valori parametro in-app configurati utilizzando setDefaultsAsync(int). Per ottenere questi valori, chiama il metodo elencato di seguito che mappa il tipo di dati previsto dalla tua app, fornendo la chiave del parametro come argomento:

• getBoolean()
• getDouble()
• getLong()
• getString()

Passaggio 5: imposta i valori dei parametri nel backend Remote Config

Utilizzando la console Firebase o le API di backend di Remote Config, puoi creare nuovi valori predefiniti lato server che sostituiscono i valori in-app in base alla logica condizionale o al targeting per utente che preferisci. Questa sezione descrive i passaggi della 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 corrispondente) e anche valori condizionali. Per scoprire di più, consulta Parametri e condizioni Remote Config.

Passaggio 6: recupera e attiva i valori

1. Per recuperare i valori dei parametri dal backend Remote Config, chiama il metodo fetch(). Tutti i valori impostati nel backend vengono recuperati e memorizzati nell'oggetto Remote Config.

2. Per rendere disponibili i valori dei parametri recuperati per la tua app, chiama il metodo activate().

   Se vuoi recuperare e attivare i valori in una chiamata, puoi utilizzare una richiesta fetchAndActivate() per recuperare i valori dal backend Remote Config e renderli disponibili per l'app:

   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();
               }
           });

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.

Nota: se la tua app non viene compilata con Gradle, devi aggiungere manualmente la risorsa stringa google_app_id corretta all'app in modo che Remote Config possa essere inizializzata. In genere, il plug-in google-services Gradle lo aggiunge automaticamente, ma puoi trovare il valore appropriato nel file google-services.json scaricato dalla console Firebase. Per maggiori informazioni su come ottenere il valore google_app_id dal file google-services.json, consulta Elaborazione del file JSON.

Passaggio 7: 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 Android v21.3.0 e versioni successive (Firebase BoM v31.2.4 e versioni successive).

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 abilitala.

1. Nella tua app, utilizza addOnConfigUpdateListener() per iniziare a monitorare gli aggiornamenti e recuperare automaticamente i nuovi valori parametro. Implementa il callback onUpdate() per attivare la configurazione aggiornata.

   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<Boolean>() {
               @Override
               public void onComplete(@NonNull Task<Boolean> task) {
                   displayWelcomeMessage();
               }
           });
       }
       @Override
       public void onError(FirebaseRemoteConfigException error) {
           Log.w(TAG, "Config update error with code: " + error.getCode(), error);
       }
   });
   

2. La volta successiva che pubblichi una nuova versione di Remote Config, i dispositivi su cui è in esecuzione l'app e che sono in ascolto di modifiche chiameranno ConfigUpdateListener.

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 FirebaseRemoteConfigFetchThrottledException. Prima della versione SDK 17.0.0, 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 21.3.0 dell'SDK Android (Firebase BoM v31.3.0 o versioni successive), 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. Per ulteriori informazioni, vedi Ascoltare aggiornamenti in tempo reale.

Durante lo sviluppo dell'app, ti consigliamo di recuperare e attivare le configurazioni molto spesso (molte volte all'ora) per eseguire rapidamente l'iterazione durante lo sviluppo e il test dell'app. Gli aggiornamenti 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 un massimo di 10 sviluppatori, puoi impostare temporaneamente un oggetto FirebaseRemoteConfigSettings con un intervallo di recupero minimo ridotto (setMinimumFetchIntervalInSeconds) nella tua app.

L'intervallo di recupero minimo predefinito per 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 FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
3. Il valore predefinito è 12 ore

Per impostare l'intervallo di recupero minimo su un valore personalizzato, utilizza FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long).

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 a livello di 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