Modificare da remoto il nome del modello nell'app

Swift

Nell'ambito della configurazione di Firebase AI Logic setup, hai già aggiunto l'SDK Firebase alla tua app, ma dovrai aggiungere anche Remote Config.

1. In Xcode, con il progetto aperto, vai a File > Add Package Dependencies (File > Aggiungi dipendenze pacchetto).

2. Seleziona firebase-ios-sdk e poi fai clic su Add package (Aggiungi pacchetto).

3. Nel navigatore del progetto, seleziona la tua app > Targets (Obiettivi) > la tua app.

4. Nella scheda General (Generali), scorri fino a Frameworks, Libraries, and Embedded Content (Framework, librerie e contenuti incorporati).

5. Fai clic su + e scegli FirebaseRemoteConfig, poi fai clic su Add (Aggiungi).

6. Aggiungi l'importazione FirebaseRemoteConfig al codice:

   import FirebaseRemoteConfig
   

7. All'interno della classe appropriata per la tua app, inizializza Firebase e aggiungi Remote Config alla logica dell'applicazione principale.

   Qui includerai Remote Config e il Remote Config listener in tempo reale come importazioni in modo che l'app possa recuperare nuovi valori in tempo reale e aggiungere un intervallo di recupero minimo:

   let remoteConfig = RemoteConfig.remoteConfig()
   let settings = RemoteConfigSettings()
   settings.minimumFetchInterval = 3600
   remoteConfig.configSettings = settings
   

Kotlin

1. Aggiungi la dipendenza Remote Config al file Gradle (a livello di app) del modulo (solitamente app/build.gradle.kts o app/build.gradle):

   dependencies {
       implementation(platform("com.google.firebase:firebase-bom:34.12.0"))
       implementation("com.google.firebase:firebase-ai")
       implementation("com.google.firebase:firebase-config")
       // ... other dependencies
   }
   

2. Aggiungi Remote Config alla logica dell'applicazione principale. Qui inizializzerai Remote Config e aggiungerai un intervallo di recupero minimo:

   val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
   val configSettings = remoteConfigSettings {
   minimumFetchIntervalInSeconds = 3600
   }
   remoteConfig.setConfigSettingsAsync(configSettings)
   

Java

1. Aggiungi la dipendenza Remote Config al file Gradle (a livello di app) del modulo (solitamente app/build.gradle.kts o app/build.gradle):

   dependencies {
       implementation(platform("com.google.firebase:firebase-bom:34.12.0"))
       implementation("com.google.firebase:firebase-ai")
       implementation("com.google.firebase:firebase-config")
       // ... other dependencies
   }
   

2. Aggiungi Remote Config alla logica dell'applicazione principale. Qui inizializzerai Remote Config e aggiungerai un intervallo di recupero minimo:

   FirebaseRemoteConfig mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
   FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
       .setMinimumFetchIntervalInSeconds(3600)
       .build();
   mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);
   

Web

1. Apri il codice in un editor di testo e importa Remote Config:

   import { getRemoteConfig } from 'firebase/remote-config';
   

2. All'interno della funzione principale e dopo l'inizializzazione dell'app Firebase per Firebase AI Logic SDK, inizializza Remote Config:

     // Initialize Remote Config and get a reference to the service
     const remoteConfig = getRemoteConfig(app);
   

3. Imposta un intervallo di recupero minimo:

   remoteConfig.settings.minimumFetchIntervalMillis = 3600000;
   

Dart

1. Dalla directory del progetto Flutter, installa e aggiungi Remote Config utilizzando il seguente comando:

   flutter pub add firebase_remote_config
   

2. Apri ./lib/main.dart e aggiungi l'importazione dopo le altre importazioni che hai aggiunto per supportare Firebase AI Logic:

   import 'package:firebase_vertexai/firebase_ai.dart';
   import 'package:firebase_core/firebase_core.dart';
   import 'package:firebase_remote_config/firebase_remote_config.dart';
   

3. Aggiungi la variabile _modelName alla tua app in modo da poterla utilizzare in un secondo momento:

   late final String _modelName;
   late final String _systemInstructions;
   late final String _prompt;
   

4. Ottieni l'istanza dell'oggetto Remote Config e imposta l'intervallo di recupero minimo per consentire aggiornamenti frequenti. Assicurati di aggiungere questo codice dopo l'inizializzazione di Firebase.

     final remoteConfig = FirebaseRemoteConfig.instance;
     await remoteConfig.setConfigSettings(RemoteConfigSettings(
       fetchTimeout: const Duration(seconds: 3600),
       minimumFetchInterval: const Duration(seconds: 3600),
     ));
   

Unity

1. Aggiungi Remote Config al tuo progetto Unity seguendo queste istruzioni.

2. Ottieni l'istanza dell'oggetto Remote Config e imposta l'intervallo di recupero minimo per consentire aggiornamenti frequenti. Assicurati di aggiungere questo codice dopo l'inizializzazione di Firebase.

   var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
   const int MillisecondsPerSecond = 1000;
   await remoteConfig.SetConfigSettingsAsync(new ConfigSettings() {
     FetchTimeoutInMilliseconds = 3600 * MillisecondsPerSecond,
     MinimumFetchIntervalInMilliseconds = 3600 * MillisecondsPerSecond
   });
   

Swift

1. Nella console Firebase, apri Remote Config.

2. Nella scheda Parameters (Parametri), apri il Menu e seleziona Download default values (Scarica valori predefiniti).

3. Quando ti viene richiesto, attiva .plist for iOS (File .plist per iOS), poi fai clic su Download file (Scarica file).

4. Salva il file nella directory dell'applicazione.

5. In Xcode, fai clic con il tasto destro del mouse sulla tua app e seleziona Add Files (Aggiungi file).

6. Seleziona remote_config_defaults.plist, poi fai clic su Add (Aggiungi).

7. Aggiorna il codice dell'app in modo che faccia riferimento al file predefinito:

   // Set default values for Remote Config parameters.
   remoteConfig.setDefaults(fromPlist: "remote_config_defaults")
   

Kotlin

1. Dalla console Firebase, apri Remote Config.

2. Nella scheda Parameters (Parametri), apri il Menu e seleziona Download default values (Scarica valori predefiniti).

3. Quando ti viene richiesto, attiva .xml for Android (File .xml per Android), poi fai clic su Download file (Scarica file).

4. Salva il file nella directory delle risorse XML della tua app.

5. Aggiorna il file dell'attività principale per aggiungere i valori predefiniti dopo configSettings che hai aggiunto in precedenza:

   // Set default values for Remote Config parameters.
   remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)
   

Java

1. Nella console Firebase, apri Remote Config.

2. Nella scheda Parameters (Parametri), apri il Menu e seleziona Download default values (Scarica valori predefiniti).

3. Quando ti viene richiesto, attiva .xml for Android (File .xml per Android), poi fai clic su Download file (Scarica file).

4. Salva il file nella directory delle risorse XML della tua app.

5. Aggiorna il file dell'attività principale per aggiungere i valori predefiniti dopo configSettings che hai aggiunto in precedenza:

   // Set default values for Remote Config parameters.
   mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);
   

Web

Puoi impostare il valore predefinito per il nome del modello direttamente nel codice:

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  model_name: 'gemini-2.5-flash',
};

Dart

Puoi impostare il valore predefinito per il nome del modello direttamente nel codice:

// Set default values for Remote Config parameters.
remoteConfig.setDefaults(const {
  "model_name": "gemini-2.5-flash"
});

Unity

Puoi impostare il valore predefinito per il nome del modello direttamente nel codice:

// Set default values for Remote Config parameters.
await remoteConfig.SetDefaultsAsync(
  new System.Collections.Generic.Dictionary<string, object>() {
    { "model_name", "gemini-2.5-flash" }
  }
);

Swift

// Fetch and activate Remote Config values
remoteConfig.fetchAndActivate { status, error in
  if let error = error {
    print("Error fetching Remote Config: \(error.localizedDescription)")
  }
}

In questo modo, l'oggetto Remote Config viene aggiornato ogni volta che viene pubblicato un nuovo Remote Config modello.

Kotlin

// Fetch and activate Remote Config values
remoteConfig.fetchAndActivate()
      .addOnCompleteListener(this) { task ->
          if (task.isSuccessful) {
              val updated = task.result
              Log.d(TAG, "Remote Config values fetched and activated: $updated")
          } else {
              Log.e(TAG, "Error fetching Remote Config", task.exception)
          }
      }

Java

  // Fetch and activate Remote Config values
  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);
            } else {
                Log.e(TAG, "Error fetching Remote Config", task.exception)
            }
          }
    });

Web

1. Aggiungi getValue e fetchAndActivate alle importazioni:

   import { getValue, fetchAndActivate } from 'firebase/remote-config';
   

2. Individua il codice in cui specifichi il valore predefinito per il nome del modello. Subito dopo il blocco di codice, aggiungi il seguente codice per recuperare e attivare la configurazione e assegnare il valore recuperato alla costante modelName.

   // Fetch and activate Remote Config.
   try {
     await fetchAndActivate(remoteConfig);
   } catch(err) {
     console.error('Remote Config fetch failed', err);
   }
   
   console.log('Remote Config fetched.');
   
   // Assign Remote Config values.
   const modelName = getValue(remoteConfig, 'model_name').asString();
   

Dart

// Fetch and activate Remote Config.
remoteConfig.fetchAndActivate();

// Assign Remote Config values.
String? _modelName = remoteConfig.getString("model_name");

Unity

// Fetch and activate Remote Config values.
await remoteConfig.FetchAndActivateAsync();

Swift

// Add real-time Remote Config
remoteConfig.addOnConfigUpdateListener { configUpdate, error in
  guard let configUpdate = configUpdate, error == nil else {
    print("Error listening for config updates: \(error?.localizedDescription ?? "No error available")")
    return
  }

  print("Updated keys: \(configUpdate.updatedKeys)")
  remoteConfig.activate { changed, error in
    guard error == nil else {
      print("Error activating config: \(error?.localizedDescription ?? "No error available")")
      return
    }
    print("Activated config successfully")
  }
}

Kotlin

(Facoltativo) Puoi anche configurare un'azione all'interno dell'attivazione addOnCompleteListener:

      // Add a real-time Remote Config listener
      remoteConfig.addOnConfigUpdateListener(object : ConfigUpdateListener {
          override fun onUpdate(configUpdate : ConfigUpdate) {
              Log.d(ContentValues.TAG, "Updated keys: " + configUpdate.updatedKeys);
              remoteConfig.activate().addOnCompleteListener {
                  // Optionally, add an action to perform on update here.
              }
          }

          override fun onError(error : FirebaseRemoteConfigException) {
              Log.w(ContentValues.TAG, "Config update error with code: " + error.code, error)
          }
      }

Java

(Facoltativo) Puoi anche configurare un'azione all'interno dell'attivazione addOnCompleteListener:

  // Add a real-time Remote Config listener
  remoteConfig.addOnConfigUpdateListener(new ConfigUpdateListener() {
      @Override
      public void onUpdate(ConfigUpdate configUpdate) {
          Log.d(ContentValues.TAG, "Updated keys: " + configUpdate.getUpdatedKeys());
                remoteConfig.activate().addOnCompleteListener(new OnCompleteListener<Boolean>() {
                  @Override
                  public void onComplete(@NonNull Task<Boolean> task) {
                      // Optionally, add an action to perform on update here.
                  }
              });
          }

      @Override
      public void onError(FirebaseRemoteConfigException error) {
          Log.w(ContentValues.TAG, "Config update error with code: " + error.getCode(), error);
      }
  });

Web

 // Add a real-time Remote Config listener
 onConfigUpdate(remoteConfig, {
   next: (configUpdate) => {
      console.log("Updated keys:", configUpdate.getUpdatedKeys());
      if (configUpdate.getUpdatedKeys().has("welcome_message")) {
         activate(remoteConfig).then(() => {
         showWelcomeMessage();
         });
      }
   },
   error: (error) => {
      console.log("Config update error:", error);
   },
   complete: () => {
      console.log("Listening stopped.");
   }
});

Dart

// Add a real-time Remote Config listener
remoteConfig.onConfigUpdated.listen((event) async {
  await remoteConfig.activate();
});

Unity

// Add a real-time Remote Config listener to automatically update whenever
// a new template is published.
// Note: the parameters can be anonymous as they are unused.

remoteConfig.OnConfigUpdateListener += (_, _) => {
  remoteConfig.ActivateAsync();
};

Swift

import FirebaseAI

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
let modelName = remoteConfig.configValue(forKey: "model_name").stringValue
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: modelName
)

// ...

Kotlin

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = remoteConfig.getString("model_name")
)

// ...

Java

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .generativeModel(
      /* modelName */ remoteConfig.getString("model_name"),
      /* generationConfig (optional) */ null,
      /* safetySettings (optional) */ null,
      /* requestOptions (optional) */ new RequestOptions(),
      /* tools (optional) */ null,
      /* toolsConfig (optional) */ null,
      /* systemInstruction (optional) */ null,
    );

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// ...

Web

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
const model = getGenerativeModel(ai, {
  model: modelName
});

// ...

Dart

// ...

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
final model = FirebaseAI.googleAI().generativeModel(
  model: _modelName,
);

// ...

Unity

// ...

var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
var modelName = remoteConfig.GetValue("model_name").StringValue;
var model = ai.GetGenerativeModel(
  modelName: modelName
);

// ...