Plantillas de versiones con Remote Config

Swift

Como parte de la configuración de Firebase AI Logic, ya agregaste el SDK de Firebase a tu app, pero también deberás agregar Remote Config.

1. En Xcode, con el proyecto abierto, navega a Archivo > Agregar dependencias de paquetes.

2. Selecciona firebase-ios-sdk y, luego, haz clic en Agregar paquete.

3. En el navegador de proyectos, selecciona tu app > Destinos > tu app.

4. En la pestaña General, desplázate hasta Frameworks, bibliotecas y contenido incorporado.

5. Haz clic en + y elige FirebaseRemoteConfig. Luego, haz clic en Agregar.

6. Agrega la importación FirebaseRemoteConfig a tu código:

   import FirebaseRemoteConfig
   

7. Dentro de la clase adecuada para tu app, inicializa Firebase y agrega Remote Config a la lógica principal de la aplicación.

   Aquí, incluirás Remote Config y el objeto de escucha en tiempo real de Remote Config como importaciones para que la app pueda recuperar valores nuevos en tiempo real y agregar un intervalo de recuperación mínimo:

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

Kotlin

1. Agrega la dependencia de Remote Config al archivo Gradle del módulo (nivel de app) (generalmente app/build.gradle.kts o app/build.gradle):

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

2. Agrega Remote Config a la lógica principal de la aplicación. Aquí, inicializarás Remote Config y agregarás un intervalo de recuperación mínimo:

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

Java

1. Agrega la dependencia de Remote Config al archivo Gradle del módulo (nivel de app) (generalmente app/build.gradle.kts o app/build.gradle):

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

2. Agrega Remote Config a la lógica principal de la aplicación. Aquí, inicializarás Remote Config y agregarás un intervalo de recuperación mínimo:

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

Web

1. Abre tu código en un editor de texto y, luego, importa Remote Config:

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

2. Dentro de tu función principal y después de que se inicialice la app de Firebase para el SDK de Firebase AI Logic, inicializa Remote Config:

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

3. Establece un intervalo de recuperación mínimo:

   remoteConfig.settings.minimumFetchIntervalMillis = 3600000;
   

Swift

1. En la consola de Firebase, abre Remote Config.

2. En la pestaña Parameters, abre el menú y selecciona Download default values.

3. Cuando se solicite, habilita .plist para iOS y, luego, haz clic en Descargar archivo.

4. Guarda el archivo en el directorio de tu aplicación.

5. En Xcode, haz clic con el botón derecho en tu app y selecciona Agregar archivos.

6. Selecciona remote_config_defaults.plist y, luego, haz clic en Agregar.

7. Actualiza el código de tu app para hacer referencia al archivo de valores predeterminados:

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

Kotlin

1. En Firebase console, abre Remote Config.

2. En la pestaña Parameters, abre el menú y selecciona Download default values.

3. Cuando se solicite, habilita .xml para Android y haz clic en Descargar archivo.

4. Guarda el archivo en el directorio de recursos XML de tu app.

5. Actualiza tu archivo de actividad principal para agregar los valores predeterminados después del configSettings que agregaste anteriormente:

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

Java

1. En la consola de Firebase, abre Remote Config.

2. En la pestaña Parameters, abre el menú y selecciona Download default values.

3. Cuando se solicite, habilita .xml para Android y haz clic en Descargar archivo.

4. Guarda el archivo en el directorio de recursos XML de tu app.

5. Actualiza tu archivo de actividad principal para agregar los valores predeterminados después del configSettings que agregaste anteriormente:

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

Web

Puedes establecer el valor predeterminado para el nombre del modelo directamente en tu código:

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  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)")
  }
}

Esto debería actualizar el objeto de Remote Config cada vez que se publique una nueva plantilla Remote Config.

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. Agrega getValue y fetchAndActivate a tus importaciones:

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

2. Busca el código en el que especificas el valor predeterminado para el nombre del modelo. Inmediatamente después de ese bloque de código, agrega el siguiente código para recuperar y activar la configuración, y asignar el valor recuperado a la constante templateID.

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

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

De manera opcional, también puedes configurar una acción dentro de la activación de 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

De manera opcional, también puedes configurar una acción dentro de la activación de 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

Los objetos de escucha Remote Config en tiempo real no son compatibles con las apps web.

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

// ...