API Gemini Developer

Para acessar os modelos Gemini Pro e Flash, recomendamos que os desenvolvedores Android usem a API Gemini Developer com a lógica de IA do Firebase. 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 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 da Lógica de IA do Firebase 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.2.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.2.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 em vários turnos. 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

O modelo Gemini 2.5 Flash Image (também conhecido como Nano Banana) pode gerar e editar imagens usando conhecimento geral e raciocínio. 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 com o SDK do 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 recursos de geração de imagens.
Figura 1. Use o Google AI Studio para refinar seus comandos de geração de imagens

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 com um chat de 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, inicialize 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