Android com Gemini: trabalhando com textos e imagens na IA

Configuração do Gemini - Apresentação

Boas-vindas a este conteúdo da Alura sobre Android com Inteligência Artificial! Meu nome é Junior Martins e serei seu instrutor nesta jornada.

Audiodescrição: Junior é um homem de pele clara, com cabelos loiro-escuro, longos e presos. Seus olhos são verdes, e ele usa óculos redondos de armação preta. Além disso, possui aparelho dental e veste uma camiseta azul-marinho. Ao fundo, há uma parede com um degradê de tons de azul, roxo e rosa.

Durante nosso aprendizado sobre o Gemini, a Inteligência Artificial do Google, utilizaremos o aplicativo Sabiá, que nos permitirá gerar temas de estudo a partir de imagens. Por exemplo, podemos enviar a foto de um gato e solicitar que o aplicativo a analise. O Gemini processará a imagem e poderá sugerir temas como "animais".

O aplicativo contará com telas exibindo conteúdos gerados pelo Gemini, que poderão ser corrigidos com base nas seleções feitas nas telas iniciais. Assim, poderemos indicar se o conteúdo está correto ou não. Em algumas etapas, o Gemini sugerirá um tema para que enviemos uma imagem correspondente. Após o envio, ele analisará a imagem e decidirá se está de acordo com o tema solicitado, fornecendo uma explicação.

Nosso objetivo final é determinar se conseguimos acertar ou não, passando por diferentes interações até recebermos uma mensagem de parabéns. Para isso, será fundamental aprender a lidar com o Gemini e suas funcionalidades, como memória, envio de imagens, produção de textos curtos e longos, além de entender como gerenciar cada uma dessas situações.

Também exploraremos os modelos disponíveis para uso no Android. Para acompanhar este conteúdo, é importante ter conhecimento sobre o desenvolvimento de aplicativos Android com Jetpack Compose e o gerenciamento de estados com ViewModel. Além disso, noções de gerenciamento de arquivos serão úteis, pois em alguns momentos trabalharemos com acesso à galeria e à câmera.

Na Alura, você encontra materiais sobre esses pré-requisitos. Se ainda não os conhece, vale a pena conferir antes de seguir adiante.

Estamos animados para essa jornada de aprendizado. Vamos lá!

Configuração do Gemini - Conhecendo o projeto e obtendo a API Key do Gemini

Antes de começarmos a trabalhar no projeto, vamos revisar rapidamente sua estrutura e destacar alguns pontos essenciais. Recebemos este projeto quase totalmente construído, especialmente nas partes de lógica e layout. Nossa tarefa será integrar o Gemini dentro desse contexto.

Analisando a Estrutura do Projeto

Estamos utilizando o Android Studio, com o projeto já aberto. Na pasta principal, encontramos elementos como o package data, que armazena informações locais para simular o que buscaríamos de uma API. Também temos a dataStore, responsável pelo gerenciamento de armazenamento de dados. A injeção de dependências é feita com o Realtime, e há materiais complementares e links extras disponíveis para aprofundamento.

Na pasta model, encontramos as classes que utilizaremos ao longo do curso. A interface de usuário está organizada na pasta ui, onde também há uma estrutura pronta para lidar com a câmera, incluindo toda a lógica necessária. Além disso, há componentes pré-desenhados e, dentro da pasta gamemodes, estão todas as telas principais que modificaremos durante o curso. Essa será a seção onde integraremos o Gemini, permitindo a geração de conteúdo com base nas interações dos usuários.

Na parte de navegação, temos a pasta navigation com Jetpack Compose já está configurado, caso queiramos explorar essa funcionalidade. Por fim, toda a aplicação é inicializada pela MainActivity, seguindo uma estrutura padrão com a qual já devemos estar familiarizados.

Configurando a Chave da API do Gemini

Antes de integrar o Gemini ao nosso aplicativo, vamos explorar a página da Google AI Studio. Caso ainda não esteja familiarizado, o Gemini é uma inteligência artificial generativa, também conhecida como LLM (Large Language Model). Disponibilizaremos materiais explicativos sobre esse conceito. De forma resumida, os LLMs permitem gerar conteúdo a partir de entradas de texto, imagem e outras mídias — e nosso objetivo é incorporar essa funcionalidade ao aplicativo.

Para acessar o Gemini, precisamos obter uma chave de acesso para conectar à API. Na documentação, há um botão para gerar a chave de API. Ao clicar nessa opção, será solicitado que criemos um projeto. Por padrão, existe um Gemini API, mas podemos criar um novo, selecioná-lo e, em seguida, gerar a chave para esse projeto específico. Após um breve processamento, será exibida uma sequência de caracteres única.

Importante: É fundamental não compartilhar essa chave, pois ela é exclusiva para cada usuário. Para utilizá-la, basta clicar no botão de "Copiar" e voltar ao projeto no Android Studio.

Um detalhe importante deste projeto é o uso do Secrets Gradle Plugin, uma solução para armazenar chaves secretas de forma segura, evitando que sejam enviadas para repositórios comuns.

Tudo o que faremos a partir de agora utilizará a chave de API que acabamos de gerar. Mesmo que alguém tente digitá-la manualmente, não funcionará, pois essa chave já terá expirado. No entanto, ela ficará armazenada localmente dentro do nosso projeto.

Configurando o local.properties

Essa chave será armazenada dentro da pasta Gradle Scripts, no arquivo local.properties. Após acessar esse arquivo, podemos criar uma nova propriedade. Esse arquivo é gerado localmente sempre que baixamos e compilamos o projeto. Chamaremos essa propriedade de apiKey e passamos para ela o valor que copiamos da documentação.

apiKey=AIzaSyBEx3WZ26RJKmpyXfYuaewyD2GnimYNIog

Depois dessa configuração, podemos clicar na opção "Make Selected Modules", no menu superior, para reconstruir o projeto. A partir desse momento, a propriedade apiKey será indexada junto com os demais arquivos do nosso projeto, permitindo seu uso em qualquer parte do aplicativo para acessar a API do Gemini.

Verificando a Disponibilidade da Chave

Após o processo de build, para verificar se a chave está disponível para uso no aplicativo, vamos localizar a MainActivity e criar uma variável chamada apiKey, que será atribuída ao nosso BuildConfig. Ao digitar um ponto (.), a opção apiKey deve aparecer automaticamente, confirmando que está acessível. Essa apiKey só estará disponível após a conclusão do build do projeto, garantindo que a propriedade esteja corretamente configurada.

Essa abordagem é segura, pois utiliza um plugin recomendado pela própria Google para armazenar e acessar esse tipo de chave nos projetos.

Agora, vamos imprimir essa chave na tela utilizando um Log.d(). Para isso, adicionamos "apiKey" como rótulo e, em seguida, a própria apiKey.

val apiKey = BuildConfig.apiKey
Log.d("apiKey", apiKey)

setContent {
    SabiaTheme {
        NavHost(
            rememberNavController()
        )
    }
}

Caso o Log.d() do Android não seja reconhecido por padrão, podemos substituí-lo por um println, que pode ser uma alternativa mais simples para testes. Basta utilizar println()e interpolar a apiKey, garantindo que as aspas sejam inseridas corretamente no final.

val apiKey = BuildConfig.apiKey
println("apiKey: $apiKey")

setContent {
    SabiaTheme {
        NavHost(
            rememberNavController()
        )
    }
}

Em seguida, executamos o projeto para verificar se a chave está disponível quando o aplicativo for iniciado. Assim que o aplicativo rodar, acessamos o LogCat, pesquisamos por "apiKey" e confirmamos que a chave foi impressa corretamente. Ela deve começar com "AI" e terminar com "og".

Por fim, acessamos o local.properties e verificamos se a chave impressa corresponde exatamente à que armazenamos. Se tudo estiver correto, significa que nossa chave de acesso ao Gemini foi configurada com sucesso.

Próximos Passos

Agora, estamos prontos para o próximo passo: instalar a API do Gemini e começar a trabalhar com ela.

Configuração do Gemini - Obtendo a primeira resposta do Gemini no projeto

Vamos dar continuidade aos nossos estudos!

Integrando o Gemini em Projetos Android

Para integrar o Gemini em projetos Android, a equipe de desenvolvimento do Android recomenda, na documentação oficial, o uso do Vertex AI no Firebase.

Essa documentação detalha o processo de acesso ao Gemini. Basicamente, há um diagrama ilustrando nosso aplicativo Android de um lado e, do outro, as solicitações sendo enviadas para o Google Cloud, onde o modelo do Gemini é executado. A documentação sugere começar com o Firebase e Vertex AI, mas essa abordagem é mais indicada para quando estivermos preparando o projeto para produção, ou seja, para disponibilizá-lo a usuários reais.

Biblioteca para Prototipagem

Para fins de prototipagem, existe uma biblioteca recomendada pela documentação, cujo funcionamento e código são praticamente os mesmos da solução utilizada para produção. Essa biblioteca é ideal para quem está aprendendo a trabalhar com o Gemini no Android. Embora seja possível utilizar outra alternativa, o processo inicial será idêntico, incluindo a obtenção de modelos e o envio de bindings de texto. Ao final do curso, disponibilizaremos um material complementar explicando como realizar a migração para a versão definitiva.

Essa biblioteca pode ser acessada no repositório oficial do Google, chamado Generate AI Android dentro do Google Gemini. Trata-se da biblioteca oficial da Google, com um aviso informando que se destina a prototipagem, ou seja, à criação de aplicativos para validar ideias.

Para instalá-la no projeto e utilizar os recursos disponíveis, basta copiar o seguinte código

implementation("com.google.ai.client.generativeai:generativeai:<version>"

A versão 0.9.0 era a mais recente no momento da gravação. O código pode ser encontrado diretamente no GitHub e deve ser adicionado ao projeto para dar continuidade à implementação.

No Android Studio, abrimos o arquivo build.gradle.kts e colamos o código copiado. No momento da instalação, a versão disponível é a 0.9.0, mas, caso haja uma mais recente, podemos utilizá-la. Após inserir a versão correta, adicionamos as aspas e os parênteses para fechar a instrução.

implementation("com.google.ai.client.generativeai:generativeai:0.9.0")

Em seguida, utilizamos o comando "Alt + Enter" e selecionamos "Replace with new library catalog..." para ajustar ao novo padrão, que organiza as dependências em arquivos separados. Após esse ajuste, clicamos no botão "Sync Now" para iniciar o download da biblioteca. Assim que o processo for concluído, voltamos à documentação no GitHub, onde encontramos exemplos de uso.

Configurando o Gemini

Para configurar o Gemini, precisamos criar uma instância do modelo gerativo (GenerativeModel), informando dois parâmetros essenciais: o nome do modelo e a API Key. A Google recomenda utilizar o padrão já implementado no projeto com o BuildConfig.

Vamos testar essa configuração no aplicativo. No Android Studio, abrimos a MainActivity e, logo abaixo do print da apiKey, criamos uma variável val model, que recebe uma instância de GenerativeModel. Inicialmente, deixamos o nome do modelo em branco e utilizamos a variável apiKey, já definida anteriormente.

val apiKey = BuildConfig.apiKey
println("apiKey: $apiKey")

val model = GenerativeModel(
    modelName: "",
    apiKey
)

O nome do modelo pode ser encontrado na documentação do GitHub. Entre as opções disponíveis, destacamos o Gemini-1.5 Pro Latest. A Google oferece várias variantes do Gemini e há uma documentação explicativa sobre as versões e suas aplicações.

No momento da gravação deste conteúdo, temos disponíveis modelos como Gemini-1.5 e Gemini 2.0, além de variantes como Flash e Pro. É possível que novas versões estejam disponíveis futuramente, mas a documentação oficial detalha as capacidades de entrada e saída de cada modelo. Para este projeto, utilizaremos o Gemini-2.0-Flash. Basta copiar esse nome da documentação e defini-lo como o nome do modelo dentro do código.

val apiKey = BuildConfig.apiKey
println("apiKey: $apiKey")

val model = GenerativeModel(
    modelName: "gemini-2.0-flash",
    apiKey
)

Testando a Integração

Para testar a integração, chamamos o método model.generateContent() e passamos uma pergunta simples, como "Quando o Brasil foi descoberto?", para verificar se tudo está funcionando corretamente. Como generateContent é uma suspend function (função suspensa), precisamos executá-la em uma thread separada, ou seja, dentro de um contexto de coroutines.

Para isso, utilizamos lifecycleScope.launch, garantindo que a chamada ocorra dentro do ciclo de vida da aplicação. O resultado será armazenado em uma variável response.

Para facilitar a depuração, imprimimos o resultado com println(), interpolando a resposta obtida do modelo. Esse procedimento garante que a API está respondendo corretamente e que a integração foi realizada com sucesso.

Um ponto importante é que a response retornada pelo modelo possui várias propriedades. A que mais nos interessa, ou seja, a resposta do modelo, é a propriedade text. Então, utilizaremos .text para acessar o conteúdo da resposta. O Android Studio já realiza a formatação correta automaticamente, o que facilita o processo.

val model = GenerativeModel("gemini-2.0-flash", apiKey)

lifecycleScope.launch {
    val response = model.generateContent("Quando o Brasil foi descoberto?")
    println("response: ${response.text}")
}

Agora, podemos rodar o aplicativo e verificar se a resposta aparece corretamente. Ao abrir o LogCat,pesquisaremos por "response". A resposta já está disponível: "O Brasil foi descoberto pelos europeus em 22 de abril de 1500..." Embora gostaríamos de apenas o ano, a resposta foi mais completa, incluindo a informação de que foi Pedro Álvares Cabral quem fez a descoberta. Mesmo assim, a resposta forneceu uma descrição bastante detalhada.

Um detalhe relevante é que existem duas versões do Gemini que podemos utilizar. A versão que estamos utilizando, ideal para prototipagem, possui uma cota de requisições, ou seja, há limites sobre quantas requisições podemos fazer por dia, hora ou mês. Esses limites são bem explicados na documentação do Gemini.

Analisando as Limitações e Planos de Uso

Em geral, os limites fornecidos pela Google são generosos o suficiente para quem está prototipando ou estudando, permitindo trabalhar sem grandes problemas, até mesmo em projetos de menor escala, utilizando apenas essa versão.

Na documentação, no canto esquerdo, podemos visualizar os nomes dos modelos disponíveis, como o Gemini 2.0 Flash. Existe um nível gratuito de acesso, sem custo financeiro, que oferece um bom número de requisições. Claro, caso desejemos mais capacidade, podemos optar por pagar para aumentar os limites.

O nível gratuito permite até 15 solicitações por minuto, ou seja, podemos fazer até 15 solicitações em um único minuto. Além disso, temos 1 milhão de tokens por minuto, o que possibilita solicitações grandes. Essa questão de tokens será explicada com mais detalhes em material extra, mas você começará a entendê-la ao longo do curso.

No nível gratuito, também podemos fazer até 1500 solicitações por dia, o que é mais do que suficiente para estudar e criar projetos menores com bastante flexibilidade. Cada modelo tem informações específicas sobre suas capacidades. Por exemplo, o Gemini 1.5 Flash possui características próprias que podem ser consultadas na documentação.

Próximos Passos

Agora que já instalamos e configuramos o Gemini corretamente, ele está pronto para ser utilizado. Vamos começar a integrar funções que permitam ao usuário interagir dinamicamente com o aplicativo, e o Gemini será fundamental para melhorar essa experiência.

Sobre o curso Android com Gemini: trabalhando com textos e imagens na IA

O curso Android com Gemini: trabalhando com textos e imagens na IA possui 119 minutos de vídeos, em um total de 48 atividades. Gostou? Conheça nossos outros cursos de Android em Mobile, ou leia nossos artigos de Mobile.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Configuração do Gemini
• Prompts e serialização
• Respostas de imagens com IA
• Contexto com o modo chat
• Stream e respostas rápidas