API Gemini Live

Pour les applications qui nécessitent une assistance vocale en temps réel et à faible latence, comme les chatbots ou les interactions agentiques, l'API Gemini Live offre un moyen optimisé de diffuser en streaming les entrées et les sorties d'un modèle Gemini. En utilisant Firebase AI Logic, vous pouvez appeler l'API Gemini Live directement depuis votre application Android sans avoir besoin d'une intégration de backend. Ce guide vous explique comment utiliser l'API Gemini Live dans votre application Android avec Firebase AI Logic.

Premiers pas

Avant de commencer, assurez-vous que votre application cible le niveau d'API 21 ou supérieur.

Si ce n'est pas déjà fait, configurez un projet Firebase et associez votre application à Firebase. Pour en savoir plus, consultez la documentation sur la logique d'IA de Firebase.

Configurer votre projet Android

Ajoutez la dépendance de la bibliothèque Firebase AI Logic au fichier build.gradle.kts ou build.gradle au niveau de votre application. Utilisez la nomenclature Firebase Android pour gérer les versions des bibliothèques.

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:34.1.0"))
  // Add the dependency for the Firebase AI Logic library
  // When using the BoM, you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
}

Après avoir ajouté la dépendance, synchronisez votre projet Android avec Gradle.

Intégrer Firebase AI Logic et initialiser un modèle génératif

Ajoutez l'autorisation RECORD_AUDIO au fichier AndroidManifest.xml de votre application :

<uses-permission android:name="android.permission.RECORD_AUDIO" />

Initialisez le service de backend de l'API Gemini Developer et accédez à LiveModel. Utilisez un modèle compatible avec l'API Live, comme gemini-2.0-flash-live-preview-04-09. Consultez la documentation Firebase pour connaître les modèles disponibles.

Pour spécifier une voix, définissez le nom de la voix dans l'objet speechConfig lors de la configuration du modèle. Si vous ne spécifiez pas de voix, la voix par défaut est Puck.

Kotlin

// Initialize the `LiveModel`
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
       modelName = "gemini-2.0-flash-live-preview-04-09",
       generationConfig = liveGenerationConfig {
          responseModality = ResponseModality.AUDIO
          speechConfig = SpeechConfig(voice= Voice("FENRIR"))
       })

Java

// Initialize the `LiveModel`
LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-2.0-flash-live-preview-04-09",
              new LiveGenerationConfig.Builder()
                     .setResponseModality(ResponseModality.AUDIO)
                     .setSpeechConfig(new SpeechConfig(new Voice("FENRIR"))
              ).build(),
        null,
        null
);

Vous pouvez éventuellement définir un persona ou un rôle que le modèle joue en définissant une instruction système :

Kotlin

val systemInstruction = content {
            text("You are a helpful assistant, you main role is [...]")}

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
       modelName = "gemini-2.0-flash-live-preview-04-09",
       generationConfig = liveGenerationConfig {
          responseModality = ResponseModality.AUDIO
          speechConfig = SpeechConfig(voice= Voice("FENRIR"))
       },
       systemInstruction = systemInstruction,
)

Java

Content systemInstruction = new Content.Builder()
       .addText("You are a helpful assistant, you main role is [...]")
       .build();

LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-2.0-flash-live-preview-04-09",
              new LiveGenerationConfig.Builder()
                     .setResponseModality(ResponseModality.AUDIO)
                     .setSpeechConfig(new SpeechConfig(new Voice("FENRIR"))
              ).build(),
        tools, // null if you don't want to use function calling
        systemInstruction
);

Vous pouvez spécialiser davantage la conversation avec le modèle en utilisant des instructions système pour fournir un contexte spécifique à votre application (par exemple, l'historique des activités des utilisateurs dans l'application).

Initialiser une session de l'API Live

Une fois l'instance LiveModel créée, appelez model.connect() pour créer un objet LiveSession et établir une connexion persistante avec le modèle avec un streaming à faible latence. LiveSession vous permet d'interagir avec le modèle en démarrant et en arrêtant la session vocale, ainsi qu'en envoyant et en recevant du texte.

Vous pouvez ensuite appeler startAudioConversation() pour démarrer la conversation avec le modèle :

Kotlin

val session = model.connect()
session.startAudioConversation()

Java

LiveModelFutures model = LiveModelFutures.from(liveModel);
ListenableFuture<LiveSession> sessionFuture =  model.connect();

Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
         LiveSessionFutures session = LiveSessionFutures.from(ses);
        session.startAudioConversation();
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Notez également que le modèle ne gère pas les interruptions dans vos conversations. Nous prévoyons d'ajouter cette fonctionnalité à l'avenir.

Vous pouvez également utiliser l'API Gemini Live pour générer du contenu audio en streaming à partir de texte et générer du texte à partir de contenu audio en streaming. Notez que l'API Live est bidirectionnelle. Vous utilisez donc la même connexion pour envoyer et recevoir du contenu. À terme, vous pourrez également envoyer des images et un flux vidéo en direct au modèle.

Appel de fonction : connectez l'API Gemini Live à votre application

Pour aller plus loin, vous pouvez également permettre au modèle d'interagir directement avec la logique de votre application à l'aide des appels de fonction.

L'appel de fonction (ou d'outil) est une fonctionnalité des implémentations d'IA générative qui permet au modèle d'appeler des fonctions de sa propre initiative pour effectuer des actions. Si la fonction a une sortie, le modèle l'ajoute à son contexte et l'utilise pour les générations suivantes.

Diagramme illustrant la façon dont l&#39;API Gemini Live permet à une requête utilisateur d&#39;être interprétée par un modèle, déclenchant une fonction prédéfinie avec des arguments pertinents dans une application Android, qui reçoit ensuite une réponse de confirmation du modèle.
Figure 1 : Schéma illustrant comment l'API Gemini Live permet à une requête utilisateur d'être interprétée par un modèle, déclenchant une fonction prédéfinie avec des arguments pertinents dans une application Android, qui reçoit ensuite une réponse de confirmation du modèle.

Pour implémenter l'appel de fonction dans votre application, commencez par créer un objet FunctionDeclaration pour chaque fonction que vous souhaitez exposer au modèle.

Par exemple, pour exposer à Gemini une fonction addList qui ajoute une chaîne à une liste de chaînes, commencez par créer une variable FunctionDeclaration avec un nom et une brève description en anglais clair de la fonction et de son paramètre :

Kotlin

val itemList = mutableListOf<String>()

fun addList(item: String){
   itemList.add(item)
}

val addListFunctionDeclaration = FunctionDeclaration(
        name = "addList",
        description = "Function adding an item the list",
        parameters = mapOf("item" to Schema.string("A short string
            describing the item to add to the list"))
        )

Java

HashMap<String, Schema> addListParams = new HashMap<String, Schema>(1);

addListParams.put("item", Schema.str("A short string describing the item
    to add to the list"));

FunctionDeclaration addListFunctionDeclaration = new FunctionDeclaration(
    "addList",
    "Function adding an item the list",
    addListParams,
    Collections.emptyList()
);

Transmettez ensuite ce FunctionDeclaration en tant que Tool au modèle lorsque vous l'instanciez :

Kotlin

val addListTool = Tool.functionDeclarations(listOf(addListFunctionDeclaration))

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
       modelName = "gemini-2.0-flash-live-preview-04-09",
       generationConfig = liveGenerationConfig {
          responseModality = ResponseModality.AUDIO
          speechConfig = SpeechConfig(voice= Voice("FENRIR"))
       },
       systemInstruction = systemInstruction,
       tools = listOf(addListTool)
)

Java

LiveGenerativeModel model = FirebaseAI.getInstance(
    GenerativeBackend.googleAI()).liveModel(
        "gemini-2.0-flash-live-preview-04-09",
  new LiveGenerationConfig.Builder()
        .setResponseModalities(ResponseModality.AUDIO)
        .setSpeechConfig(new SpeechConfig(new Voice("FENRIR")))
        .build(),
  List.of(Tool.functionDeclarations(List.of(addListFunctionDeclaration))),
               null,
               systemInstruction
        );

Enfin, implémentez une fonction de gestionnaire pour gérer l'appel d'outil effectué par le modèle et renvoyez-lui la réponse. Cette fonction de gestionnaire fournie à LiveSession lorsque vous appelez startAudioConversation, prend un paramètre FunctionCallPart et renvoie FunctionResponsePart :

Kotlin

session.startAudioConversation(::functionCallHandler)

// ...

fun functionCallHandler(functionCall: FunctionCallPart): FunctionResponsePart {
    return when (functionCall.name) {
        "addList" -> {
            // Extract function parameter from functionCallPart
            val itemName = functionCall.args["item"]!!.jsonPrimitive.content
            // Call function with parameter
            addList(itemName)
            // Confirm the function call to the model
            val response = JsonObject(
                mapOf(
                    "success" to JsonPrimitive(true),
                    "message" to JsonPrimitive("Item $itemName added to the todo list")
                )
            )
            FunctionResponsePart(functionCall.name, response)
        }
        else -> {
            val response = JsonObject(
                mapOf(
                    "error" to JsonPrimitive("Unknown function: ${functionCall.name}")
                )
            )
            FunctionResponsePart(functionCall.name, response)
        }
    }
}

Java

Futures.addCallback(sessionFuture, new FutureCallback<LiveSessionFutures>() {

    @RequiresPermission(Manifest.permission.RECORD_AUDIO)
    @Override
    @OptIn(markerClass = PublicPreviewAPI.class)
    public void onSuccess(LiveSessionFutures ses) {
        ses.startAudioConversation(::handleFunctionCallFuture);
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

// ...

ListenableFuture<JsonObject> handleFunctionCallFuture = Futures.transform(response, result -> {
    for (FunctionCallPart functionCall : result.getFunctionCalls()) {
        if (functionCall.getName().equals("addList")) {
            Map<String, JsonElement> args = functionCall.getArgs();
            String item =
                    JsonElementKt.getContentOrNull(
                            JsonElementKt.getJsonPrimitive(
                                    locationJsonObject.get("item")));
            return addList(item);
        }
    }
    return null;
}, Executors.newSingleThreadExecutor());

Étapes suivantes