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 entrada e saída para um modelo do Gemini. Ao usar o Firebase AI Logic, é possível 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 segmenta o nível 23 ou mais recente da API.

Se você ainda não tiver feito 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 biblioteca Firebase AI Logic e as dependências do App Check ao arquivo build.gradle.kts ou build.gradle no nível do app. Use a BoM do Firebase para Android para gerenciar as versões das bibliotecas.

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")
}

Depois de adicionar as dependências, sincronize seu projeto do Android com o Gradle.

Configurar o provedor de depuração do App Check para desenvolvimento local

A partir do início de julho de 2026, como parte do fluxo de trabalho de configuração guiada para a AI Logic no console do Firebase, o Firebase App Check será aplicado automaticamente para proteger a API Gemini. Para o desenvolvimento local, é necessário configurar o provedor de depuração do App Check para ignorar o atestado, mantendo a aplicação do App Check.

  1. No seu build de depuração, configure o App Check para usar a fábrica do provedor de depuração:

    Kotlin

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

    Java

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

  2. Receba o token de depuração:

    1. Execute o app no emulador ou no dispositivo de teste.

    2. Procure o token de depuração do App Check nos registros. Exemplo:

      D DebugAppCheckProvider: Enter this debug secret into the allow list
in the Firebase Console for your project: 123a4567-b89c-12d3-e456-789012345678

    3. Copie o token (por exemplo, 123a4567-b89c-12d3-e456-789012345678).

  3. Registre o token de depuração com o App Check:

    1. No console do Firebase, acesse a guia Segurança > App Check > Apps.

    2. Encontre seu app, clique no menu flutuante () e selecione Gerenciar tokens de depuração.

    3. Siga as instruções na tela para registrar o token de depuração.

Para saber mais sobre o provedor de depuração (incluindo como receber um novo token de depuração), confira a documentação oficial do App Check.

Integrar o Firebase AI Logic e inicializar um modelo generativo

Adicione a permissão RECORD_AUDIO ao arquivo AndroidManifest.xml do seu 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 compatível com a API Live, como gemini-2.5-flash-native-audio-preview-12-2025. Consulte a documentação do Firebase para ver os modelos disponíveis da API Live.

Para especificar uma voz, defina o nome da voz no objeto speechConfig 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
);

Se quiser, defina um perfil ou papel para o modelo 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
);

É possível especializar ainda mais a conversa com o modelo usando instruções do sistema para fornecer contexto específico ao 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. Com o LiveSession, é possível interagir com o modelo iniciando e interrompendo a sessão de voz, além de enviar e receber textos.

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 suas conversas com o modelo, observe que ele não lida com interrupções. Além disso, a API Live é bidirecional, ou seja, 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: conecte a API Gemini Live ao seu app

Para ir 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 iniciativa própria para realizar ações. Se a função tiver uma saída, o modelo vai adicioná-la ao contexto e usá-la para as gerações seguintes.

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 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 ao Gemini uma função addList que anexa uma string a uma lista de strings, comece criando uma variável FunctionDeclaration com um nome e uma breve descrição 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"));

FunctionDeclaration addListFunctionDeclaration = new FunctionDeclaration(
    "addList",
    "Function adding an item the list",
    addListParams,
    Collections.emptyList()
);

Em seguida, transmita esse FunctionDeclaration como um 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()
        .setResponseModality(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 gerenciador para processar a chamada de ferramenta que o modelo faz e transmita a resposta de volta. Essa função de gerenciador 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