Inizia a utilizzare Firebase Remote Config


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 illustra 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 l'SDK Remote Config alla tua app

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

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

  3. Nel file Gradle (a livello di app) del modulo (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 della libreria.

    Inoltre, nell'ambito della 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:34.0.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 la Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

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

    Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo vivamente di utilizzare la 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:23.0.0")
    implementation("com.google.firebase:firebase-analytics:23.0.0")
}

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:

KotlinJava 
val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)
MainActivity.kt
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 dei parametri predefiniti in-app, recuperare i valori dei parametri aggiornati dal backend 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 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 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.

  1. Definisci un insieme di nomi di parametri e valori predefiniti dei parametri utilizzando un oggetto Map o un file di risorse XML archiviato 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 Console Firebase 
    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

    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:

    KotlinJava 
    remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)
    mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Passaggio 4: ottieni i valori dei parametri da utilizzare nell'app

Ora puoi ottenere 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 esegue il mapping del 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 degli utenti che preferisci. 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 nella tua app. Per ogni parametro, puoi impostare un valore predefinito (che alla fine sostituirà il valore predefinito corrispondente nell'app) e puoi anche impostare valori condizionali. Per saperne di più, consulta Parametri e condizioni.Remote Config

  4. Se utilizzi condizioni di indicatori personalizzati, definisci gli attributi e i relativi valori. I seguenti esempi mostrano come definire una condizione di segnale personalizzata.

    KotlinJava 
        val customSignals = customSignals {
        put("city", "Tokyo")
        put("preferred_event_category", "sports")
    }

    remoteConfig.setCustomSignals(customSignals)
        CustomSignals customSignals = new CustomSignals.Builder()
        .put("city", "Tokyo")
        .put("preferred_event_category", "sports")
        .build();

    mFirebaseRemoteConfig.setCustomSignals(customSignals);

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 archiviati nell'oggetto Remote Config.

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

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

    KotlinJava 
    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()
    }
    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. Per ulteriori informazioni ed esempi, consulta 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 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 Android v21.3.0+ (Firebase BoM v31.2.4+).

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

    KotlinJava 
    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)
    }
})
    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 pubblichi una nuova versione di Remote Config, i dispositivi che eseguono la tua app e rilevano le modifiche chiameranno ConfigUpdateListener.

Limitazione

Se un'app esegue troppi recuperi 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 un periodo di 60 minuti (le versioni più recenti hanno limiti più permissivi).

Durante lo sviluppo dell'app, potresti voler recuperare e attivare le configurazioni molto frequentemente (molte volte all'ora) per poter iterare rapidamente durante lo sviluppo e il test dell'app. Gli aggiornamenti in tempo reale di Remote Config 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 è 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:

  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 i Remote Config casi d'uso e dai un'occhiata ad alcuni dei concetti chiave e alla documentazione sulle strategie avanzate, tra cui: