Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

API Gemini Live

Pour les applications qui nécessitent une compatibilité 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 à la fois 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.

Commencer

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 l'application. Utilisez la nomenclature Firebase Android pour gérer les versions de la bibliothèque.

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:35.1.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 d'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 version de débogage, configurez App Check pour qu'il utilise la fabrique du fournisseur 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 Sécurité > App Check > Applications.
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 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 d'API Live 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 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.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 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()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érentes modalités d'entrée :

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

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 de l'appel de fonction.

L'appel de fonction (ou appel 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 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. — **Figure 1** : Schéma illustrant comment l'API Gemini Live permet à un modèle d'interpréter une requête utilisateur, 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 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()
);

Ensuite, transmettez 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.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()
        .setResponseModality(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 accepte 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 Android AI Catalog.
Pour en savoir plus sur l'API Gemini Live, consultez la documentation Firebase AI Logic.
En savoir plus sur les modèles Gemini disponibles.
Apprenez-en plus sur l'appel de fonction.
Découvrez les stratégies de conception de prompts.

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

Commencer

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 de l'API Live

Kotlin

Java

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

Kotlin

Java

Kotlin

Java

Kotlin

Java

Étapes suivantes

API Gemini Live