API Gemini Developer

A API Gemini para desenvolvedores dá acesso aos modelos do Gemini do Google, permitindo criar 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, recomendamos que os desenvolvedores Android usem a API Gemini Developer com o Firebase AI Logic. Ele permite que você comece sem precisar de 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 escalonar mudando para o nível pago.

Ilustração de um app Android que contém um SDK do Firebase para Android. Uma seta aponta do SDK para o Firebase em um ambiente de nuvem. Do Firebase, outra seta aponta para a API Gemini Developer, que está conectada ao Gemini Pro e ao Gemini Flash, também no Cloud.
Figura 1. Arquitetura de integração do Firebase AI Logic para acessar a API Gemini Developer.

Primeiros passos

Antes de interagir com a API Gemini diretamente no seu app, você precisa fazer algumas coisas primeiro, incluindo 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 a melhor fraseologia, o conteúdo e o formato para seu app Android. O Google AI Studio é um ambiente de desenvolvimento integrado que pode ser usado para criar protótipos e comandos de design para os casos de uso do seu app.

Criar o comando certo para seu caso de uso é mais arte do que ciência, o que torna a experimentação essencial. Saiba mais sobre solicitações na documentação do Firebase.

Quando o comando estiver adequado, 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 do seu app, siga as instruções da "Etapa 1" do guia de primeiros passos do Firebase AI Logic para configurar o Firebase e o SDK no seu app.

Adicionar a dependência do Gradle

Adicione a seguinte dependência 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:34.4.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")
}

Java

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

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

Inicializar o modelo generativo

Comece instanciando um GenerativeModel e especificando o nome do modelo:

Kotlin

val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")

Java

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

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);

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

Interagir com a API Gemini Developer no seu app

Agora que você configurou o Firebase e o app para usar o SDK, já pode 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.")
}

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

Gerar texto com base em imagens e outras mídias

Você também pode gerar texto com base em um comando que inclua texto e imagens ou outras mídias. Ao chamar generateContent(), você pode 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?")
    }
  )
}

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

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

Kotlin

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

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

        val response = model.generateContent(prompt)
    }
}

Java

ContentResolver resolver = getApplicationContext().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);
}

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

Kotlin

val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.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)
  }
}

Java

ContentResolver resolver = getApplicationContext().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();
}

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

Chat multiturno

Você também pode oferecer suporte a conversas multiturno. Inicialize uma conversa com a função startChat(). Você também 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?")
}

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 = userContentBuilder.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);

Gerar imagens no Android com o Nano Banana

O modelo Gemini 2.5 Flash Image (também conhecido como Nano Banana) pode gerar e editar imagens usando conhecimento e raciocínio sobre o mundo. Ele gera imagens contextualmente relevantes, combinando ou intercalando texto e imagens. Ele também pode gerar recursos visuais precisos com sequências de texto longas e oferece suporte à edição de imagens por conversa, mantendo o contexto.

Como alternativa ao Gemini, você pode usar os modelos do Imagen, principalmente para geração de imagens de alta qualidade que exigem fotorrealismo, detalhes artísticos ou estilos específicos. No entanto, para a maioria dos casos de uso do lado do cliente para apps Android, o Gemini será mais do que suficiente.

Neste guia, descrevemos como usar o modelo de imagem Gemini 2.5 Flash (Nano Banana) com o SDK Firebase AI Logic para Android. Para mais detalhes sobre como gerar imagens com o Gemini, consulte a documentação Gerar imagens com o Gemini no Firebase. Se você quiser usar os modelos do Imagen, consulte a documentação.

O Google AI Studio mostrando a geração de imagens do Nano Banana para Android.
Figura 1. Use o Google AI Studio para refinar seus comandos de geração de imagens do Nano Banana para Android

Inicializar o modelo generativo

Instancie um GenerativeModel e especifique o nome do modelo gemini-2.5-flash-image-preview. Verifique se você configurou responseModalities para incluir TEXT e IMAGE.

Kotlin

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

Java

GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel(
    "gemini-2.5-flash-image-preview",
    // 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);

Gerar imagens (entrada somente de texto)

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

Kotlin

// 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 = model.generateContent(prompt)
.candidates.first().content.parts.filterIsInstance<ImagePart>()
.firstOrNull()?.image

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

Editar imagens (entrada de texto e imagem)

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

Kotlin

// Provide an image for the model to edit
val bitmap = BitmapFactory.decodeResource(context.resources, R.drawable.scones)
// 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 = model.generateContent(prompt)
    .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
// Handle the generated text and image

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

Iterar e editar imagens em um chat com várias interações

Para uma abordagem de edição de imagens por conversa, use o chat em várias etapas. Isso permite fazer solicitações de acompanhamento para refinar as edições sem precisar reenviar a imagem original.

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

Kotlin

// Provide an image for the model to edit
val bitmap = BitmapFactory.decodeResource(context.resources, R.drawable.scones)
// 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 = 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

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

Práticas recomendadas e limitações

  • Formato de saída: as imagens são geradas como PNGs com uma dimensão máxima de 1024 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 a melhor performance, use os seguintes idiomas: inglês (en), espanhol mexicano (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, às vezes resultando em uma saída apenas de texto. Peça imagens explicitamente (por exemplo, "gere uma imagem", "forneça imagens ao longo do processo", "atualize a imagem").
    • O modelo pode parar de gerar no meio da resposta. Tente de novo ou use um comando diferente.
    • O modelo pode gerar texto como uma imagem. Peça explicitamente saídas de texto (por exemplo, "gerar texto narrativo com ilustrações").

Consulte a documentação do Firebase para mais detalhes.

Próximas etapas