Inizia a utilizzare Firebase Remote Config


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 l'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. 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.4.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 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.2")
}
    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).

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 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 predefiniti dei parametri in-app

Puoi impostare i valori parametro predefiniti in-app nell'Remote Config in modo che l'app si comporti come previsto prima di connettersi backend Remote Config e in modo che siano disponibili valori predefiniti se non lo sono nel backend.

  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 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 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:

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 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 per la tua app i valori dei parametri recuperati, 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();
            }
        });

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.

Passaggio 7: ascolta gli aggiornamenti in tempo reale

Dopo aver recuperato i valori dei parametri, puoi utilizzare Remote Config in tempo reale per resta in ascolto degli 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).

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

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, che indica che le configurazioni non saranno recuperate dal backend più di una volta in 12 ore finestra di dialogo, 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 di 12 ore

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

Passaggi successivi

Se non l'hai ancora fatto, esplora il Remote Config casi d'uso e dare un'occhiata ad alcuni dei sulla documentazione sui concetti chiave e sulle strategie avanzate, tra cui: