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 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, faça o upgrade para o nível pago e aumente a escala.

Ilustração que mostra um app Android usando o SDK do Firebase para Android e enviando solicitações ao back-end do Firebase na nuvem. As solicitações são encaminhadas para a API Gemini Developer, que pode usar os modelos Gemini Pro e Flash.
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 do seu app, é necessário fazer algumas coisas primeiro, incluindo se familiarizar com os comandos e configurar o Firebase e o 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 (IDE) que pode ser usado para criar protótipos e comandos de design 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 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 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:34.19.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:34.19.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 o AI Logic no console do Firebase, o Firebase App Check será aplicado automaticamente para proteger a API Gemini. Para desenvolvimento local, configure o provedor de depuração do App Check para ignorar o atestado, mas ainda manter a aplicação do App Check.

  1. No 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 seu 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 seus 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 seu 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 seu token de depuração.

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

Inicializar o modelo generativo

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

Java

GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.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 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

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

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

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

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

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

Gerar imagens no Android com o Nano Banana

Os modelos de imagem do Gemini (também conhecidos como Os modelos Nano Banana) podem gerar e editar imagens usando conhecimento de mundo e raciocínio. Elas geram imagens contextualmente relevantes, mesclando ou intercalando texto e imagens. 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 (modelos Nano Banana) com o SDK Firebase AI Logic para Android. Confira mais detalhes sobre gerar imagens com o Gemini na documentação do Firebase.

Interface do Google AI Studio mostrando um campo de entrada de texto com o comando &quot;Uma imagem hiper-realista de um t-rex com uma mochila azul vagando por uma floresta pré-histórica&quot; e uma imagem gerada de um t-rex em uma floresta com uma mochila azul.
Figura 2. Use o Google AI Studio para refinar seus comandos de geração de imagens do Nano Banana no 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
        )
    }
)

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

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
}

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

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
}

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 uma conversa multiturno

Para uma abordagem conversacional da edição de imagens, use a conversa multiturno. 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 as mensagens subsequentes:

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
}

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

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 1024 px.
  • Tipos de entrada: o modelo não aceita entradas de áudio ou vídeo para geração de imagens.
  • Idiomas disponíveis: 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 saídas 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 saídas de texto de forma explícita (por exemplo, "gere texto narrativo com ilustrações").

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

Próximas etapas

Depois de configurar o app, considere as próximas etapas: