Inizia a utilizzare Firebase Remote Config

iOS e versioni successive Android Web Fluttere Unity C++

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

Puoi utilizzare Firebase Remote Config per definire i parametri nella tua app e aggiornarli i propri valori nel cloud, consentendo di modificare l'aspetto e il comportamento la 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 all'app

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

2. Per Remote Config, il campo Google Analytics è obbligatorio per targeting condizionale di istanze di app alle proprietà utente e ai segmenti di pubblico. Accertati che abiliti 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 il controllo delle versioni delle librerie.

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

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

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

   (alternativa) Aggiungi dipendenze della libreria Firebase senza utilizzare il BoM

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

   Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo consiglia di utilizzare BoM per gestire le versioni della libreria, in modo da garantire 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:22.0.0")
       implementation("com.google.firebase:firebase-analytics:22.1.0")
   }

   Cerchi un modulo della libreria specifico per Kotlin? A partire da Ottobre 2023 (Firebase BoM 32.5.0), gli sviluppatori Kotlin e Java possono dipendono dal modulo principale della libreria (per i dettagli, consulta Domande frequenti su questa iniziativa).

di Gemini Advanced.

Nota: perché l'SDK Android ha una dipendenza dal REST Remote Config Assicurati di non disabilitare questa API, che è abilitata per impostazione predefinita. in un progetto tipico.

Passaggio 2: recupera l'oggetto singleton Remote Config

Ottieni un'istanza dell'oggetto Remote Config e imposta 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 parametro predefiniti in-app, recuperare i valori dei parametri aggiornati dal backend e controllo quando vengono recuperati reso disponibile per la tua app.

Durante lo sviluppo, consigliamo di impostare un recupero minimo relativamente basso intervallo di tempo. Vedi 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 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 di Remote Config sono criptati in transito, ma gli utenti finali possono accedervi qualsiasi parametro Remote Config predefinito o recuperato a disposizione dell'utente di app client.

1. Definisci un insieme di nomi e valori dei parametri predefiniti utilizzando un un oggetto Map o un oggetto File di risorse XML archiviati nella cartella res/xml dell'app. Guida rapida di Remote Config l'app di esempio utilizza File XML per definire i nomi e i valori predefiniti dei parametri.

   Se hai già configurato Remote Config valori parametro di backend, puoi scaricare un file XML generato che include tutti i valori predefiniti e salvalo nella directory res/xml dell'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 sezione Parametri aprire la scheda 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: recupera i valori dei parametri da utilizzare nell'app

Ora puoi ottenere i valori dei parametri dall'oggetto Remote Config. Se imposti nel backend, recuperarli e attivarli, questi valori sono disponibili per la tua app. Altrimenti, otterrai lo strumento ai valori dei parametri configurati setDefaultsAsync(int) Per ottenere questi valori, chiama il metodo elencato di seguito mappato al 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

Utilizzi la console Firebase o Remote Config API di backend, puoi creare nuovi valori predefiniti lato server che sostituiscono i valori in-app in base alla logica condizionale o al targeting degli utenti 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 Remote Config.
3. Definisci i parametri con gli stessi nomi di quelli definiti in la tua app. Per ogni parametro puoi impostare un valore predefinito (che alla fine sostituire il valore predefinito in-app corrispondente) e puoi anche impostare valori condizionali. Per saperne di più, vedi Parametri di Remote Config e Condizioni.

Passaggio 6: recupera e attiva i valori

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

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

   Per i casi in cui desideri recuperare e attivare i valori in una sola chiamata, puoi utilizzare una richiesta fetchAndActivate() per recuperare valori dal Remote Config e rendili disponibili all'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();
               }
           });

Perché questi valori dei parametri aggiornati influiscono sul comportamento e sull'aspetto dell'app, devi attivare i valori recuperati in un momento in modo da garantire fluida per l'utente, ad esempio la prossima volta che apre dell'app. Vedi Strategie di caricamento di Remote Config per ulteriori informazioni ed esempi.

Nota: se la tua app non crea con Gradle, devi aggiungere manualmente l'app google_app_id di risorse di stringa alla tua app in modo che Remote Config possa vengono inizializzate. Normalmente, il plug-in Gradle google-services aggiunge questa impostazione automaticamente, ma puoi trovare il valore appropriato nei google-services.json file scaricati dalla console Firebase. Per ulteriori informazioni su come ottenere il valore google_app_id dal google-services.json file, vedi 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. In tempo reale Remote Config segnala ai dispositivi connessi quando sono disponibili aggiornamenti e recupera automaticamente le modifiche dopo la pubblicazione di un nuovo Remote Config completamente gestita.

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: i Remote Config in tempo reale richiedono anche Firebase Remote Config API Realtime, che dovrebbe già essere abilitata. Per eseguire la verifica, apri il Console Google Cloud, seleziona il tuo progetto e apri la pagina API e servizi. L'API deve appaiono come attivate. 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, usa addOnConfigUpdateListener() per iniziare ad ascoltare gli aggiornamenti e recuperano automaticamente tutti 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 prossima volta che pubblicherai una nuova versione di Remote Config, i dispositivi che eseguono la tua app e ascoltano le modifiche richiamano ConfigUpdateListener.

Limitazione

Se un'app viene recuperata troppe volte in un breve periodo di tempo, le chiamate di recupero vengono limitato e l'SDK restituisce FirebaseRemoteConfigFetchThrottledException. Prima della versione 17.0.0 dell'SDK, il parametro il limite era di 5 richieste di recupero in 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 Ascolta per aggiornamenti in tempo reale.

Durante lo sviluppo dell'app, potresti voler recuperare e attivare le configurazioni spesso (molte volte all'ora) per consentire di eseguire rapidamente l'iterazione durante lo sviluppo testare l'app. Gli aggiornamenti in tempo reale di Remote Config ignorano automaticamente Cache quando la configurazione viene aggiornata sul server. Per supportare l'iterazione rapida su un progetto con un massimo di 10 sviluppatori, puoi impostare FirebaseRemoteConfigSettings oggetto con un intervallo di recupero minimo basso (setMinimumFetchIntervalInSeconds) nell'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. In particolare, 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 produzione. Se testare la tua app con un piccolo team di sviluppo di 10 persone, che probabilmente non raggiungeranno i limiti di quota oraria sul lato servizio. Ma se hai inviato la tua app migliaia di utenti di test con un intervallo minimo di recupero molto basso, la tua app raggiungerà probabilmente 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:

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