Best practice per l'efficienza del recupero di Remote Config

Firebase Remote Config ti offre un controllo flessibile sul comportamento e sull'aspetto della tua app. In questo modo, puoi usufruire di funzionalità come l'implementazione di funzionalità e i test A/B multipiattaforma per le tue app, il tutto senza eseguire il deployment di nuove versioni o dover gestire più aggiornamenti degli store.

Che tu stia creando un prototipo, gestendo una startup in crescita o un'applicazione aziendale su larga scala, la gestione del volume di recupero della rete è fondamentale per offrire un'esperienza utente rapida e reattiva. Una gestione efficiente delle configurazioni riduce la latenza di avvio a freddo, risparmia i dati del client e l'utilizzo della batteria e previene l'overhead di rete non necessario. Inoltre, se la tua base utenti si espande rapidamente e l'utilizzo aumenta in futuro, la semplificazione dell'integrazione di Remote Config contribuisce a garantire che l'utilizzo rimanga efficiente.

Puoi ridurre notevolmente il traffico delle richieste di rete lato client perfezionando il modo e il momento in cui le app recuperano i parametri e li attivano.

Passa al pattern "recupera per la sessione successiva"

Un pattern comune da evitare è l'utilizzo della chiamata fetchAndActivate, che recupera i nuovi valori dalla rete e li attiva, a ogni avvio dell'app, combinato con un breve periodo di scadenza della cache per i valori recuperati in precedenza (ad esempio, da 15 minuti a un'ora). Il modello mentale alla base di questo approccio è che, ogni volta che un utente apre l'app, vengono sempre recuperati e applicati i valori più recenti. Sebbene in alcuni casi sia necessario un aggiornamento immediato (ad esempio, per l'esecuzione di una campagna di vendita giornaliera o di una promozione di un gioco), è importante bilanciare questo obiettivo con l'impatto sulle prestazioni dell'app e sull'utilizzo del recupero.

Questo approccio forza nuove chiamate di rete ogni volta che la cache scade, generando un volume di recupero elevato per gli utenti che aprono l'app più volte al giorno.

Utilizza invece le chiamate fetch e activate separatamente con un intervallo di recupero minimo più elevato per adottare un modello di "recupero per la sessione successiva". Puoi comunque utilizzare fetchAndActivate con un intervallo di recupero minimo più elevato, poiché fetch esegue una richiesta di rete solo se la cache viene invalidata, ma l'utilizzo delle due chiamate separatamente aiuta a consolidare il pattern e a stabilirlo come pratica standard nel processo di sviluppo dell'applicazione. Inoltre, l'attivazione separata evita il rischio di applicare valori di configurazione a metà sessione e di interrompere l'esperienza utente.

Come funziona questo approccio

• Attiva immediatamente al lancio:applica istantaneamente le configurazioni memorizzate nella cache della sessione precedente (ritardo di rete di 0 ms).
• Recupero in background con una cache più lunga (ad esempio, più di 12 o 24 ore): richiedi le configurazioni aggiornate in modo asincrono per aggiornare la cache locale per la sessione successiva.

In che modo questo ottimizza il volume di recupero

Un intervallo di recupero minimo più lungo comporta un numero inferiore di richieste di recupero. Il recupero di nuovi valori per la sessione successiva e l'attivazione dei valori memorizzati nella cache per la sessione corrente consentono all'app di caricarsi istantaneamente dalla cache locale per un periodo di convalida più lungo, migliorando l'esperienza utente.

Ad esempio, se imposti minimumFetchInterval su 24 ore e un utente apre la tua app 5 o 10 volte in un solo giorno, l'SDK soddisfa automaticamente i lanci dal 2 al 10 direttamente dalla cache locale, riducendo il numero di richieste di rete giornaliere dell'utente da 10 o più recuperi a 1.

val remoteConfig = Firebase.remoteConfig

// Set a 24-hour minimum fetch interval (86,400 seconds)
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 86400
}
remoteConfig.setConfigSettingsAsync(configSettings)

// 1. Instantly activate values cached from the LAST session
remoteConfig.activate().addOnCompleteListener {
    applyAppConfigurations()
}

// 2. Fetch new values in the background for the NEXT session
remoteConfig.fetch().addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Optional: Activate values if needed
    }
}

let remoteConfig = RemoteConfig.remoteConfig()

// Set a 24-hour minimum fetch interval (86,400 seconds)
let settings = RemoteConfigSettings()
settings.minimumFetchInterval = 86400
remoteConfig.configSettings = settings

// 1. Instantly activate values cached from the LAST session
remoteConfig.activate { changed, error in
    guard error == nil else { return }
    DispatchQueue.main.async {
        self.applyAppConfigurations()
    }
}

// 2. Fetch new values in the background for the NEXT session
remoteConfig.fetch { status, error in
    if status == .success {
        // Optional: Activate values if needed
    }
}

import { getRemoteConfig, fetchConfig, activate } from "firebase/remote-config";

const remoteConfig = getRemoteConfig(app);

// Set a 24-hour minimum fetch interval (86,400,000 ms)
remoteConfig.settings.minimumFetchIntervalMillis = 86400000;

// 1. Instantly activate values cached from the LAST session
activate(remoteConfig).then(() => {
    applyAppConfigurations();
});

// 2. Fetch new values in the background for the NEXT session
fetchConfig(remoteConfig).then(() => {
    // Optional: Activate values if needed
});