Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

API Gemini Live

Pour les applications qui nécessitent une assistance vocale en temps réel et à faible latence, telles que les chatbots ou les interactions avec des agents, l'API Gemini Live offre un moyen optimisé de diffuser 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 bibliothèque Firebase AI Logic et les dépendances App Check au fichier build.gradle.kts ou build.gradle au niveau de votre application. 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.15.0"))

  // Add the dependencies for the Firebase AI Logic and App Check libraries
  // When using the BoM, you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
  implementation("com.google.firebase:firebase-appcheck-debug")
}

Après avoir ajouté les dépendances, synchronisez votre projet Android avec Gradle.

Configurer le fournisseur de débogage App Check pour le développement local

À partir de début juillet 2026, dans le cadre du workflow de configuration guidée pour AI Logic dans la console Firebase, Firebase App Check sera automatiquement appliqué pour protéger l'API Gemini. Pour le développement local, vous devez configurer le fournisseur de débogage App Check afin de contourner l'attestation tout en maintenant l'application d'App Check.

Dans votre build de débogage, configurez App Check pour qu'il utilise la fabrique de fournisseurs de débogage :

Kotlin

Firebase.initialize(context = this)
Firebase.appCheck.installAppCheckProviderFactory(
    DebugAppCheckProviderFactory.getInstance(),
)

Java

FirebaseApp.initializeApp(/*context=*/ this);
FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
firebaseAppCheck.installAppCheckProviderFactory(
        DebugAppCheckProviderFactory.getInstance());

Obtenez votre jeton de débogage :
1. Exécutez votre application dans l'émulateur ou sur votre appareil de test.
2. Recherchez le jeton de débogage App Check dans vos journaux. Exemple :
```
D DebugAppCheckProvider: Enter this debug secret into the allow list
in the Firebase Console for your project: 123a4567-b89c-12d3-e456-789012345678
```
3. Copiez le jeton (par exemple, 123a4567-b89c-12d3-e456-789012345678).
Enregistrez votre jeton de débogage auprès d'App Check :
1. Dans la console Firebase, accédez à l' onglet Applications dans Sécurité > App Check.
2. Recherchez votre application, cliquez sur le menu à développer (), puis sélectionnez Gérer les jetons de débogage.
3. Suivez les instructions à l'écran pour enregistrer votre jeton de débogage.

Pour en savoir plus sur le fournisseur de débogage (y compris sur la façon d'obtenir un nouveau jeton de débogage), consultez la documentation officielle d'App Check.

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 backend de l'API Gemini Developer et accédez à LiveModel. Utilisez un modèle compatible avec l'API Live, tel que gemini-2.5-flash-native-audio-preview-12-2025. Consultez la documentation Firebase pour connaître les modèles d'API Live disponibles.

Pour spécifier une voix, définissez le nom de la voix dans l' speechConfig objet dans le cadre 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 des activités des utilisateurs 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 :

Envoyez des entrées texte et audio.
Envoyez des entrées 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:** Schéma illustrant comment l'API Gemini Live permet à un modèle d'interpréter une requête 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 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.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

Configurer le fournisseur de débogage App Check pour le développement local

Kotlin

Java

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