Inizia a utilizzare Remote Config su Android

Seleziona la piattaforma:

iOS+ Android Web Flutter Unity 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 dell'app senza distribuire un aggiornamento dell'app. Questa guida illustra i pass101aggi per iniziare e fornisce alcuni esempi di codice campione, tutti disponibili per il clone o il download dal101firebase/quickstart-android101 repository GitHub.

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

Se non l'hai già fatto, aggiungi Firebase al tuo progetto Android project.
Per Remote Config, Google Analytics è necessario utilizzare in modo da applicare il targeting condizionale per scegliere le proprietà utente e i segmenti di pubblico come target delle istanze dell'app. Assicurati di attivare Google Analytics nel tuo progetto.
Nel tuo file Gradle del modulo (a livello di app) (in genere <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi le dipendenze per le librerie Remote Config e Analytics per Android. Ti consigliamo di utilizzare la Firebase Android BoM per controllare il controllo delle versioni delle librerie.

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.12.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 la Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase per Android.
(Alternativa) Aggiungi le dipendenze della libreria Firebase senza utilizzare la BoM

Se scegli di non utilizzare la Firebase BoM, devi specificare la versione di ogni libreria Firebase nella riga di 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 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:23.0.1")
    implementation("com.google.firebase:firebase-analytics:23.2.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:

Kotlin

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

Passaggio 3: imposta i valori dei parametri predefiniti in-app

Puoi impostare i valori dei parametri predefiniti in-app nell'Remote Config oggetto, in modo che l'app si comporti come previsto prima di connettersi al Remote Config backend e che i valori predefiniti siano disponibili se non ne sono impostati nel backend.

Definisci un insieme di nomi e valori dei parametri predefiniti utilizzando un oggetto Map o un file di risorse XML archiviato nella cartella res/xml dell'app. L'Remote Configapp di esempio della guida rapstart rapida utilizza un file XML per definire i nomi e i valori dei parametri predefiniti.

Se hai già configurato i valori dei parametri del backend Remote Config, puoi scaricare un file XML generato che include tutti i valori predefiniti e salvarlo 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
```
Puoi generare un token di autenticazione eseguendo il seguente comando utilizzando Google Cloud CLI o Cloud Shell:
```
gcloud auth print-access-token
```
Questo token ha una durata limitata, quindi potrebbe essere necessario rigenerarlo se ricevi un errore di autenticazione.
Firebase console
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.

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

Kotlin

remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

Java

mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Passaggio 4: ottieni valori parametro da usare 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 dei parametri in-app configurati utilizzando setDefaultsAsync(int). Per ottenere questi valori, chiama il metodo elencato nel seguente codice che esegue il mapping 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 Firebase console o le Remote Config backend API, puoi creare nuovi valori predefiniti lato server che sostituiscono i valori in-app in base alla logica condizionale o al targeting utente desiderati. Questa sezione descrive i Firebase passaggi della console per creare questi valori.

Nella Firebase console, apri il progetto.
Seleziona Remote Config dal menu per visualizzare la Remote Config dashboard.
Definisci i parametri con gli stessi nomi dei parametri definiti nell'app. Per ogni parametro, puoi impostare un valore predefinito (che alla fine sostituirà il valore predefinito in-app corrispondente) e puoi anche impostare valori condizionali. Per saperne di più, consulta Remote Config Parametri e condizioni.

Se utilizzi condizioni di segnale personalizzate, definisci gli attributi e i relativi valori. Gli esempi seguenti mostrano come definire una condizione di segnale personalizzata.

Kotlin

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

        remoteConfig.setCustomSignals(customSignals)

Java

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

        mFirebaseRemoteConfig.setCustomSignals(customSignals);

Passaggio 6: recupera e attiva i valori

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.

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

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

Kotlin

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 di l'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 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 per ascoltare gli aggiornamenti dal backend Remote Config. Real-time Remote Config segnala ai dispositivi connessi quando sono disponibili aggiornamenti e recupera automaticamente le modifiche dopo aver pubblicato una nuova Remote Config versione.

Gli aggiornamenti in tempo reale sono supportati dall'Firebase SDK per Android v21.3.0+ ( Firebase BoM v31.2.4+).

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

Kotlin

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

La volta successiva che pubblichi una nuova versione del tuo Remote Config, i dispositivi che eseguono la tua app e ascoltano le modifiche chiameranno il 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 un intervallo di 60 minuti (le versioni più recenti hanno limiti più permissivi).

Durante lo sviluppo dell'app, potresti voler recuperare e attivare le configurazioni molto spesso (molte volte all'ora) per poter eseguire rapidamente l'iterazione durante lo sviluppo e il test dell'app. Gli aggiornamenti di Remote Config 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 è 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 effettuate. In particolare, l'intervallo di recupero minimo viene determinato nel seguente ordine:

Il parametro in fetch(long)
Il parametro in FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
Il valore predefinito di 12 ore

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

Inizia a utilizzare Remote Config su Android Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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

Passaggio 2: ottieni l'oggetto singleton Remote Config

Kotlin

Java

Passaggio 3: imposta i valori dei parametri predefiniti in-app

REST

Firebase console

Kotlin

Java

Passaggio 4: ottieni valori parametro da usare nell'app

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

Kotlin

Java

Passaggio 6: recupera e attiva i valori

Kotlin

Java

Passaggio 7: ascolta gli aggiornamenti in tempo reale

Kotlin

Java

Limitazione

Inizia a utilizzare Remote Config su Android