Inizia con la configurazione remota di Firebase

iOS+ Android Web Flutter Unità C++

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 dell'app. Questa guida ti guida attraverso i passaggi per iniziare e fornisce alcuni esempi di codice, tutti disponibili per la clonazione o il download dal repository GitHub firebase/quickstart-android .

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

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

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

3. Nel file Gradle del tuo modulo (a livello di app) (di solito <project>/<app-module>/build.gradle ), aggiungi la dipendenza per la libreria Android Remote Config. Ti consigliamo di utilizzare la distinta base Android di Firebase per controllare il controllo delle versioni della libreria.

   Inoltre, come parte della configurazione di Analytics, devi aggiungere l'SDK Firebase per Google Analytics alla tua app.

   Kotlin+KTX

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.1.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-ktx'
       implementation 'com.google.firebase:firebase-analytics-ktx'
   }
   

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

   (Alternativa) Aggiungi le dipendenze della libreria Firebase senza utilizzare la distinta base

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

   Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo vivamente di utilizzare la distinta base per gestire le versioni della libreria, che garantisce che tutte le versioni siano compatibili.

   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-ktx:21.4.0'
       implementation 'com.google.firebase:firebase-analytics-ktx:21.3.0'
   }
   

   Java

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.1.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 Android.

   (Alternativa) Aggiungi le dipendenze della libreria Firebase senza utilizzare la distinta base

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

   Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo vivamente di utilizzare la distinta base per gestire le versioni della libreria, che garantisce che tutte le versioni siano compatibili.

   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:21.4.0'
       implementation 'com.google.firebase:firebase-analytics:21.3.0'
   }
   

Nota: poiché Android SDK ha una dipendenza dall'API REST Remote Config, assicurati di non disabilitare tale API, che è abilitata per impostazione predefinita in un progetto tipico.

Passaggio 2: ottenere 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 archiviare i valori dei parametri predefiniti in-app, recuperare i valori dei parametri aggiornati dal back-end e controllare quando i valori recuperati vengono resi disponibili per la tua app.

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

Passaggio 3: imposta i valori dei parametri predefiniti 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 back-end Remote Config e in modo che i valori predefiniti siano disponibili se nessuno è impostato nel back-end.

1. Definisci un set di nomi di parametro e valori di parametro predefiniti utilizzando un oggetto Map o un file di risorse XML archiviato nella cartella res/xml della tua app. L'app di esempio di avvio rapido Remote Config usa un file XML per definire i nomi e i valori dei parametri predefiniti.

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

   RIPOSO

   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, abilita .xml per Android , quindi fai clic su Scarica file .

2. Aggiungi questi valori all'oggetto Remote Config usando 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 dei parametri da utilizzare nella tua app

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

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

Passaggio 5: impostare i valori dei parametri nel back-end Remote Config

Utilizzando la console Firebase o le API di back-end Remote Config , puoi creare nuovi valori predefiniti lato server che sovrascrivono i valori in-app in base alla logica condizionale o al targeting utente desiderati. Questa sezione descrive i passaggi della console Firebase per creare questi valori.

1. Nella console Firebase , apri il tuo progetto.
2. Seleziona Remote Config dal menu per visualizzare la dashboard di Remote Config.
3. Definisci i parametri con gli stessi nomi dei parametri che hai definito nella tua app. Per ogni parametro, puoi impostare un valore predefinito (che alla fine sostituirà il corrispondente valore predefinito in-app) e puoi anche impostare valori condizionali. Per ulteriori informazioni, consulta Parametri e condizioni di configurazione remota .

Passaggio 6: recuperare e attivare i valori

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

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

   Per i casi in cui desideri recuperare e attivare i valori in una chiamata, puoi utilizzare una richiesta fetchAndActivate() per recuperare i valori dal back-end 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 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. Vedere Strategie di caricamento della configurazione remota per ulteriori informazioni ed esempi.

Nota: se la tua app non viene compilata con Gradle, devi aggiungere manualmente la risorsa di stringa google_app_id corretta alla tua app in modo che Remote Config possa essere inizializzato. Il plug-in Gradle google-services normalmente lo aggiunge automaticamente, ma puoi trovare il valore appropriato nel file google-services.json che scarichi dalla console di Firebase. Per ulteriori 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 ascoltare gli aggiornamenti dal back-end di 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+ (Firebase BoM v31.2.4+).

Importante: Real-time Remote Config richiede anche l'API Firebase Remote Config Realtime, che dovrebbe essere già abilitata per te. Per verificare, apri Google Cloud Console , seleziona il tuo progetto e apri la pagina API e servizi . L'API dovrebbe apparire come abilitata. Se manca o non è abilitato, fai clic su Abilita API e servizi , cerca Firebase Remote Config Realtime API e abilitalo.

1. Nella tua app, usa addOnConfigUpdateListener() per iniziare ad ascoltare gli aggiornamenti e recuperare automaticamente i nuovi valori dei parametri. 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() {
               @Override
               public void onComplete(@NonNull Task task) {
                   displayWelcomeMessage();
               }
           });
       }
   
       @Override
       public void onError(FirebaseRemoteConfigException error) {
           Log.w(TAG, "Config update error with code: " + error.getCode(), error);
       }
   });
   

2. La prossima volta che pubblichi una nuova versione di Remote Config, i dispositivi che eseguono la tua app e ascoltano le modifiche chiameranno ConfigUpdateListener .

Limitazione

Se un'app recupera troppe volte in un breve periodo di tempo, le chiamate di recupero vengono limitate e l'SDK restituisce FirebaseRemoteConfigFetchThrottledException . Prima della versione 17.0.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).

Suggerimento: a partire da Android SDK v21.3.0+ (Firebase BoM v31.3.0+), puoi utilizzare Remote Config in tempo reale per recuperare automaticamente i valori dei parametri aggiornati dal back-end Remote Config non appena vengono pubblicati, ignorando qualsiasi recupero minimo impostazione dell'intervallo. Per ulteriori informazioni, vedere Ascoltare gli aggiornamenti in tempo reale .

Durante lo sviluppo dell'app, potresti voler recuperare e attivare le configurazioni molto frequentemente (più volte all'ora) per consentirti di eseguire rapidamente l'iterazione durante lo sviluppo e il test dell'app. Gli aggiornamenti della configurazione remota in tempo reale ignorano automaticamente la cache quando la configurazione viene aggiornata sul server. Per consentire un'iterazione rapida su un progetto con un massimo di 10 sviluppatori, puoi impostare temporaneamente un oggetto FirebaseRemoteConfigSettings con un intervallo di recupero minimo basso ( setMinimumFetchIntervalInSeconds ) nella tua app.

L'intervallo di recupero minimo predefinito per Remote Config è 12 ore, il che significa che le configurazioni non verranno recuperate dal back-end più di una volta in una finestra di 12 ore, indipendentemente dal numero di chiamate di recupero effettivamente effettuate. Nello specifico, l'intervallo di recupero minimo è determinato nel seguente ordine:

1. Il parametro in fetch(long)
2. Il parametro in FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
3. Il valore predefinito di 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 oraria lato servizio. Ma se distribuissi la tua app a migliaia di utenti di test con un intervallo di recupero minimo molto basso, la tua app probabilmente raggiungerebbe questa quota.

Prossimi passi

Se non l'hai già fatto, esplora i casi d'uso di Remote Config e dai un'occhiata ad alcuni dei concetti chiave e alla documentazione delle strategie avanzate, tra cui:

• Gestisci le versioni del modello Remote Config
• Strategie di caricamento della configurazione