Versionen mit Remote Config konfigurieren

Swift

Im Rahmen der Firebase AI Logic Einrichtung haben Sie Ihrer App bereits das Firebase SDK hinzugefügt. Sie müssen aber auch Remote Config hinzufügen.

1. Öffnen Sie das Projekt in Xcode und rufen Sie File > Add Package Dependencies (Datei > Paketabhängigkeiten hinzufügen) auf.

2. Wählen Sie firebase-ios-sdk aus und klicken Sie dann auf Add package (Paket hinzufügen).

3. Wählen Sie im Projektnavigator Ihre App > Targets (Ziele) > Ihre App aus.

4. Scrollen Sie auf dem Tab General (Allgemein) zu Frameworks, Libraries, and Embedded Content (Frameworks, Bibliotheken und eingebettete Inhalte).

5. Klicken Sie auf + und wählen Sie FirebaseRemoteConfig aus. Klicken Sie dann auf Add (Hinzufügen).

6. Fügen Sie den Import FirebaseRemoteConfig in Ihren Code ein:

   import FirebaseRemoteConfig
   

7. Initialisieren Sie Firebase in der entsprechenden Klasse für Ihre App und fügen Sie Remote Config der Hauptanwendungslogik hinzu.

   Hier fügen Sie Remote Config und den Remote Config Echtzeit-Listener als Importe hinzu, damit die App neue Werte in Echtzeit abrufen kann. Außerdem fügen Sie ein Mindestabrufintervall hinzu:

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

Kotlin

1. Fügen Sie die Remote Config Abhängigkeit der Gradle Datei des Moduls (auf Anwendungsebene, in der Regel app/build.gradle.kts oder app/build.gradle) hinzu:

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

2. Fügen Sie Remote Config der Hauptanwendungslogik hinzu. Hier initialisieren Sie Remote Config und fügen ein Mindestabrufintervall hinzu:

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

Java

1. Fügen Sie die Remote Config Abhängigkeit der Gradle Datei des Moduls (auf Anwendungsebene, in der Regel app/build.gradle.kts oder app/build.gradle) hinzu:

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

2. Fügen Sie Remote Config der Hauptanwendungslogik hinzu. Hier initialisieren Sie Remote Config und fügen ein Mindestabrufintervall hinzu:

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

Web

1. Öffnen Sie Ihren Code in einem Texteditor und importieren Sie Remote Config:

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

2. Initialisieren Sie Remote Config in der Hauptfunktion und nachdem die Firebase-App für das Firebase AI Logic SDK initialisiert wurde:

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

3. Legen Sie ein Mindestabrufintervall fest:

   remoteConfig.settings.minimumFetchIntervalMillis = 3600000;
   

Dart

1. Installieren und fügen Sie Remote Config über den folgenden Befehl aus Ihrem Flutter-Projektverzeichnis hinzu:

   flutter pub add firebase_remote_config
   

2. Öffnen Sie ./lib/main.dart und fügen Sie den Import nach den anderen Importen hinzu, die Sie zur Unterstützung von Firebase AI Logic hinzugefügt haben:

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

3. Fügen Sie Ihrer App die Variable _modelName hinzu, damit Sie sie später verwenden können:

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

4. Erstellen Sie eine Remote Config Objektinstanz und legen Sie das Mindestabruf intervall fest, um häufige Aktualisierungen zu ermöglichen. Fügen Sie dies nach der Initialisierung von Firebase hinzu.

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

Einheit

1. Fügen Sie Remote Config Ihrem Unity-Projekt hinzu. Folgen Sie dazu diesen Anweisungen.

2. Erstellen Sie eine Remote Config Objektinstanz und legen Sie das Mindestabruf intervall fest, um häufige Aktualisierungen zu ermöglichen. Fügen Sie dies nach der Initialisierung von Firebase hinzu.

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

Swift

1. Rufen Sie in der Firebase Konsole die DevOps & Engagement > Remote Config > Parameters Seite auf.

2. Öffnen Sie das more_vert Menü und wählen Sie Download default values (Standardwerte herunterladen) aus.

3. Aktivieren Sie bei Aufforderung .plist for iOS und klicken Sie dann auf Download file (Datei herunterladen).

4. Speichern Sie die Datei im Anwendungsverzeichnis.

5. Klicken Sie in Xcode mit der rechten Maustaste auf Ihre App und wählen Sie Add Files (Dateien hinzufügen) aus.

6. Wählen Sie remote_config_defaults.plist aus und klicken Sie dann auf Add (Hinzufügen).

7. Aktualisieren Sie Ihren App-Code, um auf die Standarddatei zu verweisen:

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

Kotlin

1. Rufen Sie in der Firebase Konsole die DevOps & Engagement > Remote Config > Parameters Seite auf.

2. Öffnen Sie das more_vert Menü und wählen Sie Download default values (Standardwerte herunterladen) aus.

3. Aktivieren Sie bei Aufforderung .xml for Android und klicken Sie dann auf Download file.

4. Speichern Sie die Datei im XML-Ressourcenverzeichnis Ihrer App.

5. Aktualisieren Sie die Hauptaktivitätsdatei, um die Standardwerte nach den zuvor hinzugefügten configSettings hinzuzufügen:

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

Java

1. Rufen Sie in der Firebase Konsole die DevOps & Engagement > Remote Config > Parameters Seite auf.

2. Öffnen Sie das more_vert Menü und wählen Sie Download default values (Standardwerte herunterladen) aus.

3. Aktivieren Sie bei Aufforderung .xml for Android und klicken Sie dann auf Download file.

4. Speichern Sie die Datei im XML-Ressourcenverzeichnis Ihrer App.

5. Aktualisieren Sie die Hauptaktivitätsdatei, um die Standardwerte nach den zuvor hinzugefügten configSettings hinzuzufügen:

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

Web

Sie können den Standardwert für den Modellnamen direkt in Ihrem Code festlegen:

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  template_id: 'my-first-template-v1-0-0',
};

Dart

Sie können den Standardwert für den Modellnamen direkt in Ihrem Code festlegen:

// Set default values for Remote Config parameters.
remoteConfig.setDefaults(const {
  "template_id": "my-first-template-v1-0-0"
});

Einheit

Sie können den Standardwert für den Modellnamen direkt in Ihrem Code festlegen:

// Set default values for Remote Config parameters.
await remoteConfig.SetDefaultsAsync(
  new System.Collections.Generic.Dictionary<string, object>() {
    { "template_id", "my-first-template-v1-0-0" }
  }
);

Swift

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

Dadurch wird das Remote Config Objekt immer dann aktualisiert, wenn eine neue Remote Config Vorlage veröffentlicht wird.

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. Fügen Sie getValue und fetchAndActivate zu Ihren Importen hinzu:

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

2. Suchen Sie den Code, in dem Sie den Standardwert für den Modellnamen angeben. Fügen Sie direkt nach diesem Codeblock den folgenden Code hinzu, um die Konfiguration abzurufen und zu aktivieren und den abgerufenen Wert der Konstanten templateID zuzuweisen:

   // 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 templateID = getValue(remoteConfig, 'template_id').asString();
   

Dart

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

// Assign Remote Config values.
String? _templateID = remoteConfig.getString("template_id");

Einheit

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

Optional können Sie auch eine Aktion in der Aktivierung addOnCompleteListener konfigurieren:

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

Optional können Sie auch eine Aktion in der Aktivierung addOnCompleteListener konfigurieren:

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

Einheit

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

let templateID = remoteConfig.configValue(forKey: "template_id").stringValue
let model = FirebaseAI.firebaseAI(backend: .googleAI()).templateGenerativeModel()
let customerName = "Jane"

// When making the `generateContent` call, source the template ID value from Remote Config
let response = try await model.generateContent(
  templateID: templateID,
  // Provide the values for any input variables required by your template.
  inputs: [
    "customerName": customerName
  ]
)

// ...

Kotlin

// ...

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).templateGenerativeModel()
val customerName = "Jane"

// When making the `generateContent` call, source the template ID value from Remote Config
val response = model.generateContent(
  remoteConfig.getString("template_id"),
  // Provide the values for any input variables required by your template.
  mapOf(
    "customerName" to customerName
  )
)

val text = response.text
println(text)

Java

// ...

TemplateGenerativeModel ai = FirebaseAI.getInstance()
    .templateGenerativeModel(null /* Request Options */);

TemplateGenerativeModelFutures model = TemplateGenerativeModelFutures.from(ai);
String customerName = "Jane";

// When making the `generateContent` call, source the template ID value from Remote Config
Future<GenerateContentResponse> response = model.generateContent(
    remoteConfig.getString("template_id"),
    // Provide the values for any input variables required by your template.
    mapOf("customerName", customerName)

);
addCallback(response,
      new FutureCallback<GenerateContentResponse>() {
          public void onSuccess(GenerateContentResponse result) {
            System.out.println(result.getText());
          }
          public void onFailure(Throwable t) {
            reportError(t);
          }
    }
executor);

// ...

Web

// ...

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

const model = getTemplateGenerativeModel(ai);
const templateID = getValue(remoteConfig, 'template_id').asString();
const customerName = 'Jane';

// When making the `generateContent` call, source the template ID value from Remote Config
const result = await model.generateContent(
  templateID,
  // Provide the values for any input variables required by your template
  {
    customerName: customerName,
  }
);

// ...

Dart

// ...

final model = FirebaseAI.googleAI().templateGenerativeModel();

final templateID = remoteConfig.getString("template_id");
final customerName = 'Jane';

// When making the `generateContent` call, source the template ID value from Remote Config
var response = await model.generateContent(
  templateID,
  // Provide the values for any input variables required by your template
  inputs: {
    'customerName': customerName,
  },
);

// ...

Einheit

// ...

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

var templateID = remoteConfig.GetValue("template_id").StringValue;
var model = ai.GetTemplateGenerativeModel();
var customerName = "Jane";

try
{
    // When making the `generateContent` call, source the template ID value from Remote Config
    var response = await model.GenerateContentAsync(
        templateID,
        // Provide the values for any input variables required by your template
        new Dictionary<string, object>
        {
            { "customerName", customerName },
        }
    );
    Debug.Log($"Response Text: {response.Text}");
}
catch (Exception e)
{
    Debug.LogError($"An error occurred: {e.Message}");
}

// ...