API Gemini Live

Para aplicativos que exigem suporte de voz em tempo real e com baixa latência, como chatbots ou interações agênticas, a API Gemini Live oferece uma maneira otimizada de transmitir a entrada e a saída de um modelo Gemini. Ao usar o Firebase AI Logic, você pode chamar a API Gemini Live diretamente do seu app Android sem precisar de uma integração de back-end. Este guia mostra como usar a API Gemini Live no seu app Android com o Firebase AI Logic.

Primeiros passos

Antes de começar, verifique se o app é destinado ao nível 23 da API ou mais recente.

Se ainda não fez isso, configure um projeto do Firebase e conecte seu app a ele. Para mais detalhes, consulte a documentação do Firebase AI Logic.

Configurar seu projeto do Android

Adicione a dependência da biblioteca do Firebase AI Logic ao arquivo do nível do app build.gradle.kts ou build.gradle. Use um BoM do Firebase para Android para gerenciar as versões das bibliotecas.

dependencies {
  // Import the Firebase BoM
  implementation(platform("com.google.firebase:firebase-bom:34.11.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")
}

Depois de adicionar a dependência, sincronize seu projeto do Android com o Gradle.

Integrar o Firebase AI Logic e inicializar um modelo generativo

Adicione a permissão RECORD_AUDIO ao arquivo AndroidManifest.xml do aplicativo:

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

Inicialize o serviço de back-end da API Gemini Developer e acesse o LiveModel. Use um modelo que ofereça suporte à API Live, como gemini-2.5-flash-native-audio-preview-12-2025. Consulte a documentação do Firebase para ver os modelos disponíveis.

Para especificar uma voz, defina o nome da voz dentro do speechConfig objeto como parte da configuração do modelo. Se você não especificar uma voz, o padrão será 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
);

Você também pode definir um perfil ou papel que o modelo desempenha definindo uma instrução do sistema:

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

Você pode especializar ainda mais a conversa com o modelo usando instruções do sistema para fornecer contexto específico do seu app (por exemplo, histórico de atividades do usuário no app).

Inicializar uma sessão da API Live

Depois de criar a instância LiveModel, chame model.connect() para criar um objeto LiveSession e estabelecer uma conexão persistente com o modelo com streaming de baixa latência. LiveSession permite interagir com o modelo iniciando e interrompendo a sessão de voz e também enviando e recebendo texto.

Em seguida, chame startAudioConversation() para iniciar a conversa com o modelo:

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

Nas conversas com o modelo, observe que ele não processa interrupções. Além disso, a API Live é bidirecional , então você usa a mesma conexão para enviar e receber conteúdo.

Você também pode usar a API Gemini Live para gerar áudio de diferentes modalidades de entrada:

Chamada de função: conectar a API Gemini Live ao seu app

Para ir um passo além, você também pode permitir que o modelo interaja diretamente com a lógica do seu app usando a chamada de função.

A chamada de função (ou chamada de ferramenta) é um recurso de implementações de IA generativa que permite que o modelo chame funções por conta própria para realizar ações. Se a função tiver uma saída, o modelo a adicionará ao contexto e a usará para gerações subsequentes.

Diagrama que ilustra como a API Gemini Live permite que um comando do usuário seja interpretado por um modelo, acionando uma função predefinida com argumentos relevantes em um app Android, que recebe uma resposta de confirmação do modelo.
Figura 1: diagrama que ilustra como a API Gemini Live permite que um comando do usuário seja interpretado por um modelo, acionando uma função predefinida com argumentos relevantes em um app Android, que então recebe uma resposta de confirmação do modelo.

Para implementar a chamada de função no seu app, comece criando um objeto FunctionDeclaration para cada função que você quer expor ao modelo.

Por exemplo, para expor uma função addList que anexa uma string a uma lista de strings ao Gemini, comece criando uma variável FunctionDeclaration com um nome e uma descrição curta em inglês simples da função e do parâmetro dela:

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

Em seguida, transmita essa FunctionDeclaration como uma Tool para o modelo ao instanciá-lo:

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()
        .setResponseModalities(ResponseModality.AUDIO)
        .setSpeechConfig(new SpeechConfig(new Voice("FENRIR")))
        .build(),
  List.of(Tool.functionDeclarations(List.of(addListFunctionDeclaration))),
               null,
               systemInstruction
        );

Por fim, implemente uma função de handler para processar a chamada de ferramenta feita pelo modelo e transmitir a resposta de volta. Essa função de handler fornecida ao LiveSession quando você chama startAudioConversation, usa um parâmetro FunctionCallPart e retorna 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());

Próximas etapas