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.

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 à votre fichier build.gradle.kts ou build.gradle au niveau de l'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.19.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.

  1. Dans votre version 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());

  2. 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).

  3. Enregistrez votre jeton de débogage auprès d'App Check :

    1. Dans la console Firebase, accédez à Sécurité > App Check > onglet 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 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"))
    }
)

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

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é 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 que le modèle ne gère pas les interruptions dans vos conversations. 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 :

Appels 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.

Schéma illustrant la façon dont 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 : Diagramme illustrant comment l'API Gemini Live permet à un modèle d'interpréter un prompt 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 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 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.5-flash-native-audio-preview-12-2025",
    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.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 gestion 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