API Gemini Developer

A API Gemini Developer dá acesso aos modelos do Gemini do Google, permitindo que você crie recursos de IA generativa de ponta nos seus apps Android, incluindo chat de conversação, geração de imagens (com o Nano Banana) e geração de texto com base em entradas de texto, imagem, áudio e vídeo.

Para acessar os modelos Gemini Pro e Flash, use a API Gemini Developer com o Firebase AI Logic. Ele permite que você comece sem precisar de uma forma de pagamento (como um cartão de crédito) e oferece um nível sem custo financeiro generoso. Depois de validar sua integração com uma pequena base de usuários, você pode fazer upgrade para o nível pago.

Figura 1. Arquitetura de integração do Firebase AI Logic para acessar a API Gemini Developer.

Observação: se você tiver requisitos rígidos de localização de dados ou já estiver integrado ao ecossistema do Google Cloud, considere usar a API Gemini da Agent Platform (antiga Vertex AI) como seu provedor de API para o SDK da AI Logic do Firebase.

Primeiros passos

Antes de interagir com a API Gemini diretamente do seu app, você precisa fazer algumas coisas, como se familiarizar com os comandos e configurar o Firebase e seu app para usar o SDK.

Teste os comandos

Testar comandos pode ajudar você a encontrar as melhores frases, conteúdo e formato para seu app Android. O Google AI Studio é um ambiente de desenvolvimento integrado (IDE) que pode ser usado para criar protótipos e projetar comandos para os casos de uso do seu app.

Criar comandos eficazes para seu caso de uso envolve muita experimentação, que é uma parte essencial do processo. Saiba mais sobre comandos na documentação do Firebase.

Quando estiver satisfeito com o comando, clique no botão <> para receber snippets de código que podem ser adicionados ao seu código.

Configurar um projeto do Firebase e conectar seu app a ele

Quando estiver tudo pronto para chamar a API no app, siga as instruções na "Etapa 1" do guia de iniciação do Firebase AI Logic para configurar o Firebase e ativar as APIs e os serviços necessários.

Adicionar as dependências do Gradle

Adicione as seguintes dependências do Gradle ao módulo do app:

Kotlin

dependencies {
  // ... other androidx dependencies

  // Import the BoM for the Firebase platform
  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")
}

Java

dependencies {
  // Import the BoM for the Firebase platform
  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")

  // Required for one-shot operations (to use `ListenableFuture` from Guava Android)
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations (to use `Publisher` from Reactive Streams)
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

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, mas manter 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.

Confira alguns pontos importantes sobre o provedor de depuração do App Check:

• Mantenha o token e o build de depuração particulares. Não envie o token de depuração para um repositório público nem envie o token ou o build de depuração em builds de produção do app.
• Registre seu app com um provedor de atestado de produção antes de lançá-lo para os usuários finais. Você precisará registrar seu app com um provedor de atestação do App Check de produção (por exemplo, Play Integrity) para que os usuários finais possam usar seu recurso com o App Check aplicado.

Inicializar o modelo generativo

Observação: os modelos mais recentes do Gemini 3.x Flash e Flash-Lite já estão disponíveis como versões estáveis. Saiba mais sobre os modelos compatíveis com o Firebase AI Logic.

Comece instanciando um GenerativeModel e especificando o nome do modelo:

Kotlin

// Start by instantiating a GenerativeModel and specifying the model name:
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel("gemini-3.5-flash")
GeminiDeveloperApiSnippets.kt

Java

GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.5-flash");

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);
GeminiDeveloperApiSnippetsJava.java

Saiba mais sobre os modelos disponíveis para uso com a API Gemini Developer. Saiba mais sobre como configurar parâmetros de modelo.

Interagir com a API Gemini Developer no seu app

Agora que você configurou o Firebase e seu app para usar o SDK, está tudo pronto para interagir com a API Gemini Developer no seu app.

Gerar texto

Para gerar uma resposta de texto, chame generateContent() com seu comando.

Kotlin

scope.launch {
    val response = model.generateContent("Write a story about a magic backpack.")
}
GeminiDeveloperApiSnippets.kt

Java

Content prompt = new Content.Builder()
        .addText("Write a story about a magic backpack.")
        .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Gerar texto com base em imagens e outras mídias

Também é possível gerar texto com base em um comando que inclui texto, imagens ou outras mídias. Ao chamar generateContent(), é possível transmitir a mídia como dados inline.

Por exemplo, para usar um bitmap, use o tipo de conteúdo image:

Kotlin

scope.launch {
    val response = model.generateContent(
        content {
            image(bitmap)
            text("what is the object in the picture?")
        }
    )
}
GeminiDeveloperApiSnippets.kt

Java

Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("what is the object in the picture?")
        .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Para transmitir um arquivo de áudio, use o tipo de conteúdo inlineData:

Kotlin

scope.launch {
    val contentResolver = applicationContext.contentResolver
    contentResolver.openInputStream(audioUri).use { stream ->
        stream?.let {
            val bytes = it.readBytes()

            val prompt = content {
                inlineData(bytes, "audio/mpeg") // Specify the appropriate audio MIME type
                text("Transcribe this audio recording.")
            }

            val response = model.generateContent(prompt)
        }
    }
}
GeminiDeveloperApiSnippets.kt

Java

ContentResolver resolver = applicationContext.getContentResolver();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte[] audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes audio specified earlier and text
        Content prompt = new Content.Builder()
                .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
                .addText("Transcribe what's said in this audio recording.")
                .build();

        // To generate text output, call `generateContent` with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String text = result.getText();
                Log.d(TAG, (text == null) ? "" : text);
            }
            @Override
            public void onFailure(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
        }, executor);
    } else {
        Log.e(TAG, "Error getting input stream for file.");
        // Handle the error appropriately
    }
} catch (IOException e) {
    Log.e(TAG, "Failed to read the audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}
GeminiDeveloperApiSnippetsJava.java

Para fornecer um arquivo de vídeo, continue usando o tipo de conteúdo inlineData:

Kotlin

scope.launch {
    val contentResolver = applicationContext.contentResolver
    contentResolver.openInputStream(videoUri).use { stream ->
        stream?.let {
            val bytes = it.readBytes()

            val prompt = content {
                inlineData(bytes, "video/mp4") // Specify the appropriate video MIME type
                text("Describe the content of this video")
            }

            val response = model.generateContent(prompt)
        }
    }
}
GeminiDeveloperApiSnippets.kt

Java

ContentResolver resolver = applicationContext.getContentResolver();

try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes video specified earlier and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("Describe the content of this video")
                .build();

        // To generate text output, call generateContent with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String resultText = result.getText();
                System.out.println(resultText);
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, executor);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}
GeminiDeveloperApiSnippetsJava.java

Da mesma forma, também é possível transmitir documentos PDF (application/pdf) e de texto simples (text/plain) transmitindo o respectivo tipo MIME como um parâmetro.

Chat multiturno

Também é possível oferecer suporte a conversas multiturno. Inicie uma conversa com a função startChat(). Se quiser, você pode fornecer ao modelo um histórico de mensagens. Em seguida, chame a função sendMessage() para enviar mensagens de chat.

Kotlin

val chat = model.startChat(
    history = listOf(
        content(role = "user") { text("Hello, I have 2 dogs in my house.") },
        content(role = "model") { text("Great to meet you. What would you like to know?") }
    )
)

scope.launch {
    val response = chat.sendMessage("How many paws are in my house?")
}
GeminiDeveloperApiSnippets.kt

Java

Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = modelContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

// Create a new user message
Content.Builder messageBuilder = new Content.Builder();
messageBuilder.setRole("user");
messageBuilder.addText("How many paws are in my house?");

Content message = messageBuilder.build();

// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(message);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Gerar imagens no Android com o Nano Banana

Observação: o Gemini 3.1 Flash Image (gemini-3.1-flash-image, Nano Banana 2), o Gemini 3 Pro Image (gemini-3-pro-image, Nano Banana Pro) e o Gemini 3.1 Flash-Lite Image (gemini-3.1-flash-lite-image, Nano Banana 2 Lite) já estão disponíveis como versões estáveis. Saiba mais sobre os recursos do Gemini 3.1 Flash Image, Gemini 3 Pro Image e Gemini 3.1 Flash-Lite Image

Os modelos de imagem do Gemini (também conhecidos como modelos Nano Banana) podem gerar e editar imagens usando conhecimento de mundo e raciocínio. Eles geram imagens contextualmente relevantes, combinando ou intercalando saídas de texto e imagem. Eles também podem gerar recursos visuais precisos com sequências de texto longas e oferecem suporte à edição de imagens conversacional, mantendo o contexto.

Este guia descreve como usar os modelos de imagem do Gemini (os modelos Nano Banana) com o SDK Firebase AI Logic para Android. Saiba mais sobre como gerar imagens com o Gemini na documentação do Firebase.

Observação: o uso de modelos do Gemini para geração de imagens com o SDK Firebase AI Logic está em pré-lançamento. Isso significa que o recurso não está sujeito a nenhum SLA ou política de descontinuação e pode mudar de maneiras incompatíveis com versões anteriores.

Figura 2. Use o Google AI Studio para refinar os comandos de geração de imagens do Nano Banana para seu app Android

Inicializar o modelo generativo

Instancie um GenerativeModel e especifique um nome de modelo de imagem do Gemini (como gemini-3.1-flash-image). Em seguida, configure responseModalities para incluir TEXT e IMAGE para gerar texto e imagens intercalados. Se você excluir TEXT, o modelo vai retornar apenas imagens.

Kotlin

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "gemini-3.1-flash-image",
    // Configure the model to respond with images (required) and text (optional)
    generationConfig = generationConfig {
        responseModalities = listOf(
            ResponseModality.TEXT,
            ResponseModality.IMAGE
        )
    }
)
GeminiDeveloperApiSnippets.kt

Java

GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel(
        "gemini-3.1-flash-image",
        // Configure the model to respond with text and images (required)
        new GenerationConfig.Builder()
                .setResponseModalities(Arrays.asList(ResponseModality.TEXT, ResponseModality.IMAGE))
                .build()
);
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
GeminiDeveloperApiSnippetsJava.java

Gerar imagens (entrada somente de texto)

Você pode instruir um modelo do Gemini a gerar imagens fornecendo um comando somente de texto:

Kotlin

scope.launch {
    // Provide a text prompt instructing the model to generate an image
    val prompt =
        "A hyper realistic picture of a t-rex with a blue bag pack roaming a pre-historic forest."
    // To generate image output, call `generateContent` with the text input
    val generatedImageAsBitmap: Bitmap? = model.generateContent(prompt)
        .candidates.first().content.parts.filterIsInstance<ImagePart>()
        .firstOrNull()?.image
}
GeminiDeveloperApiSnippets.kt

Java

// Provide a text prompt instructing the model to generate an image
Content prompt = new Content.Builder()
        .addText("Generate an image of the Eiffel Tower with fireworks in the background.")
        .build();
// To generate an image, call `generateContent` with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        // iterate over all the parts in the first candidate in the result object
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                // The returned image as a bitmap
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Editar imagens (entrada de texto e imagem)

Você pode pedir para um modelo do Gemini editar imagens fornecendo texto e uma ou mais imagens no comando:

Kotlin

scope.launch {
    // Provide a text prompt instructing the model to edit the image
    val prompt = content {
        image(bitmap)
        text("Edit this image to make it look like a cartoon")
    }
    // To edit the image, call `generateContent` with the prompt (image and text input)
    val generatedImageAsBitmap: Bitmap? = model.generateContent(prompt)
        .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
    // Handle the generated text and image
}
GeminiDeveloperApiSnippets.kt

Java

// Provide an image for the model to edit
Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
// Provide a text prompt instructing the model to edit the image
Content promptcontent = new Content.Builder()
        .addImage(bitmap)
        .addText("Edit this image to make it look like a cartoon")
        .build();
// To edit the image, call `generateContent` with the prompt (image and text input)
ListenableFuture<GenerateContentResponse> response = model.generateContent(promptcontent);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        // iterate over all the parts in the first candidate in the result object
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Iterar e editar imagens em uma conversa multiturno

Para uma abordagem de conversa multiturno na edição de imagens, use a conversa multiturno. Isso permite que as solicitações de acompanhamento refinem as edições sem precisar reenviar a imagem original.

Primeiro, inicialize uma conversa com startChat(), fornecendo opcionalmente um histórico de mensagens. Em seguida, use sendMessage() para as mensagens seguintes:

Kotlin

scope.launch {
    // Create the initial prompt instructing the model to edit the image
    val prompt = content {
        image(bitmap)
        text("Edit this image to make it look like a cartoon")
    }
    // Initialize the chat
    val chat = model.startChat()
    // To generate an initial response, send a user message with the image and text prompt
    var response = chat.sendMessage(prompt)
    // Inspect the returned image
    var generatedImageAsBitmap: Bitmap? = response
        .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
    // Follow up requests do not need to specify the image again
    response = chat.sendMessage("But make it old-school line drawing style")
    generatedImageAsBitmap = response
        .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
}
GeminiDeveloperApiSnippets.kt

Java

// Provide an image for the model to edit
Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
// Initialize the chat
ChatFutures chat = model.startChat();
// Create the initial prompt instructing the model to edit the image
Content prompt = new Content.Builder()
        .setRole("user")
        .addImage(bitmap)
        .addText("Edit this image to make it look like a cartoon")
        .build();
// To generate an initial response, send a user message with the image and text prompt
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(prompt);
// Extract the image from the initial response
ListenableFuture<Bitmap> initialRequest = Futures.transform(response,
        result -> {
            for (Part part : result.getCandidates().get(0).getContent().getParts()) {
                if (part instanceof ImagePart) {
                    ImagePart imagePart = (ImagePart) part;
                    return imagePart.getImage();
                }
            }
            return null;
        }, executor);
// Follow up requests do not need to specify the image again
ListenableFuture<GenerateContentResponse> modelResponseFuture = Futures.transformAsync(
        initialRequest,
        generatedImage -> {
            Content followUpPrompt = new Content.Builder()
                    .addText("But make it old-school line drawing style")
                    .build();
            return chat.sendMessage(followUpPrompt);
        }, executor);
// Add a final callback to check the reworked image
Futures.addCallback(modelResponseFuture, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Considerações e limitações

Observe as seguintes considerações e limitações:

• Formato de saída: as imagens são geradas como PNGs com uma dimensão máxima de 1.024 px.
• Tipos de entrada: o modelo não aceita entradas de áudio ou vídeo para geração de imagens.
• Suporte a idiomas: para ter o melhor desempenho, use os seguintes idiomas: inglês (en), espanhol do México (es-mx), japonês (ja-jp), chinês simplificado (zh-cn) e hindi (hi-in).
• Problemas de geração:
  • A geração de imagens nem sempre é acionada, o que pode resultar em uma saída somente de texto. Peça explicitamente para gerar imagens (por exemplo, "gere uma imagem", "forneça imagens conforme avança", "atualize a imagem").
  • O modelo pode parar de gerar no meio do processo. Tente de novo ou use um comando diferente.
  • O modelo pode gerar texto como uma imagem. Tente pedir saídas de texto explicitamente (por exemplo, "gere um texto narrativo com ilustrações").

Para mais detalhes, consulte a documentação do Firebase.

Próximas etapas

Depois de configurar o app, considere as seguintes etapas:

• Confira o app de exemplo do Firebase para Android e o catálogo de exemplos de IA para Android no GitHub.
• Prepare seu app para produção, incluindo a configuração do Firebase App Check para proteger a API Gemini contra abusos de clientes não autorizados.
• Saiba mais sobre o Firebase AI Logic na documentação do Firebase.