API Gemini Live

Pour les applications qui nécessitent une prise en charge vocale en temps réel et à faible latence, telles que 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 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 23 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 Firebase AI Logic.

Configurer votre projet Android

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

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:34.12.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.5-flash-native-audio-preview-12-2025. 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 valeur par défaut est Puck.

Kotlin

// Initialize the `LiveModel`
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    }
)GeminiLive.kt

Java

// Initialize the `LiveModel`
LiveGenerativeModel model = FirebaseAI
       .getInstance(GenerativeBackend.googleAI())
       .liveModel(
              "gemini-2.5-flash-native-audio-preview-12-2025",
              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 joué par le modèle 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.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    },
    systemInstruction = systemInstruction,
)GeminiLive.kt

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.5-flash-native-audio-preview-12-2025",
              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 d'activité de l'utilisateur dans l'application).

Initialiser une session d'API Live

Une fois que vous avez créé l'instance LiveModel, 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()GeminiLive.kt

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

Dans vos conversations avec le modèle, notez qu'il ne gère pas les interruptions. De plus, l'API Live est bidirectionnelle. Vous utilisez donc la même connexion pour envoyer et recevoir du contenu.

Vous pouvez également utiliser l'API Gemini Live pour générer de l'audio à partir de différents modes d'entrée :

Envoyer une entrée de texte.
Envoyer une entrée vidéo (consultez l'application de démarrage rapide Firebase )

Appels de fonction : connecter 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.

Les appels de fonction (ou appels d'outil) sont 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'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. — **Figure 1:** Diagramme illustrant comment l'API Gemini Live permet à un modèle d'interpréter un prompt utilisateur, ce qui déclenche 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 les appels 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 une fonction addList qui ajoute une chaîne à une liste de chaînes à Gemini, commencez par créer une variable FunctionDeclaration avec un nom et une brève description en anglais simple 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")
    )
)GeminiLive.kt

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 cette FunctionDeclaration en tant qu'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.5-flash-native-audio-preview-12-2025",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voice("FENRIR"))
    },
    systemInstruction = systemInstruction,
    tools = listOf(addListTool)
)GeminiLive.kt

Java

LiveGenerativeModel model = FirebaseAI.getInstance(
    GenerativeBackend.googleAI()).liveModel(
        "gemini-2.5-flash-native-audio-preview-12-2025",
  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 lui renvoyer 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)
        }
    }
}GeminiLive.kt

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

Testez l'API Gemini Live dans l'application exemple du catalogue d'IA Android.
Pour en savoir plus sur l'API Gemini Live, consultez la documentation Firebase AI Logic.
En savoir plus sur les modèles Gemini disponibles.
En savoir plus sur les appels de fonction.
Découvrez les stratégies de conception de requêtes.

API Gemini Live Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Premiers pas

Configurer votre projet Android

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

Kotlin

Java

Kotlin

Java

Initialiser une session d'API Live

Kotlin

Java

Appels de fonction : connecter l'API Gemini Live à votre application

Kotlin

Java

Kotlin

Java

Kotlin

Java

Étapes suivantes

API Gemini Live