Crie apps Android seguros e com custo otimizado usando o Firebase AI Logic e o Gemini Nano 4

Bem-vindo à Conferência de Desenvolvedores Android.

Meu nome é Ankita Saxena, sou gerente de produtos do Firebase.

E eu sou Arthur Thompson, engenheiro de relações com desenvolvedores na equipe do Firebase.

Hoje, vamos mostrar como adicionar recursos generativos aos seus apps Android.

Certo.

O que é o Firebase?

Levante a mão se você já ouviu falar do Firebase.

Ah, vejo muitos.

Ótimo.

O Firebase é a plataforma de desenvolvimento de apps do Google.

O Firebase oferece uma plataforma unificada com mais de 20 produtos integrados, para que você não tenha a experiência fragmentada que teria com outros softwares.

Vamos falar sobre os desafios de enviar a IA generativa para os apps para dispositivos móveis.

Identificamos os três principais desafios.

Primeiro, vazamentos de chaves de API: leva minutos para extraí-las.

Em segundo lugar, ao atualizar os nomes dos modelos, sempre recomendamos que os desenvolvedores não os codifiquem nos apps. Caso contrário, sempre que um novo modelo for lançado, será necessário enviar outra versão.

Em terceiro lugar, a privacidade dos arquivos: é muito importante que qualquer desenvolvedor ou usuário de app tenha os dados protegidos e as proteções certas para o app.

Apresentar o Firebase AI Logic como a principal solução para lidar com os desafios que discutimos.

Qual é a proposta de valor que o Firebase AI Logic oferece?

Basicamente, cuidamos de todo o back-end personalizado complexo para que você não precise desenvolvê-lo.

Em segundo lugar, ao usar nossos SDKs de cliente, você pode chamar a API Gemini de forma direta e segura nos seus apps para dispositivos móveis.

Vamos analisar os bastidores e entender como a arquitetura funciona.

No lado esquerdo, temos os SDKs de cliente do Firebase.

Oferecemos suporte a uma grande variedade de SDKs de cliente.

Também oferecemos suporte ao Kotlin.

Quando um desenvolvedor quer realizar uma ação de IA, o SDK envia a solicitação para o Firebase AI Logic, que a encaminha com segurança para a API Gemini Developer ou a API Gemini da Agent Platform.

Basicamente, estamos lidando com todo o back-end personalizado que você está criando hoje.

E o valor que estamos recebendo é que vocês estão acelerando o tempo de lançamento no mercado sem custo.

Agora, a parte divertida.

Esta será uma demonstração do app FriendlyMeals.

Vamos usar o mesmo app para as outras demonstrações desta sessão. Se quiser, você pode fazer o download dele.

Você pode ler o QR code aqui.

Vamos fazer a demonstração.

O app FriendlyMeals ajuda a identificar receitas com base nos ingredientes que você insere.

Nesse fluxo de trabalho, você vê as duas maneiras de capturar esses ingredientes.

Primeiro, insira os ingredientes que você tem.

Depois, você tira uma foto dos ingredientes.

Vou usar o primeiro fluxo de trabalho, que é inserir os ingredientes.

Isso é tudo que encontrei na minha geladeira.

Enquanto a receita é gerada, quero destacar alguns pontos.

Nos bastidores, estamos chamando os modelos do Gemini aqui.

Para esse caso de uso específico, estamos chamando três Gemini 3.8 Flash.

Se você olhar para a parte de cima, a imagem está usando o modelo Gemini Nano Banana, que é o 2.1 Nano Banana, a versão mais recente.

Antes de entrarmos no código, quero reforçar a proposta de valor que você recebe com o Firebase AI Logic.

A primeira são os SDKs sem servidor.

Você quer adicionar um recurso de IA, mas não quer ter que configurar um back-end.

É aí que entram nossos SDKs do lado do cliente.

Você chama o Gemini diretamente do seu app Android.

O segundo são os recursos de segurança integrados e robustos.

Assim, nas chamadas para o Gemini, você pode usar recursos como o Firebase App Check, os modelos de comando do servidor e outros. Vamos falar mais sobre esses recursos de segurança mais adiante.

Em terceiro lugar, há o suporte a recursos avançados, como entradas multimodais e streaming.

Digamos que você queira criar um app que adicione um recurso simples de IA para gerar uma história sobre uma mochila mágica.

import com.google.firebase.Firebase
import com.google.firebase.ai.ai

@Composable
fun MagicBackpackGenerator() {
    var output by remember { mutableStateOf("") }

    LaunchedEffect(Unit) {

       val model=Firebase.ai.generativeModel("gemini-4-argon")

        val response = model.generateContent("Write a story about a magic backpack")

        output = response.text.toString()

    }
    MagicBackpackUI(output)
}

São necessárias apenas essas três etapas simples para adicionar esse recurso de IA e deixá-lo pronto para produção.

Com o Firebase AI Logic, é muito fácil adicionar recursos de IA ao seu app. Por isso, a primeira pergunta que você deve fazer é: como proteger esse recurso?

Vamos falar sobre os detalhes de segurança, começando com o Firebase App Check.

O Firebase App Check ajuda a proteger seus dados, proteger seus usuários e controlar quem tem acesso aos recursos da API, atestando que as solicitações vêm do seu app.

É uma camada extra de segurança para evitar que seu app seja usado de forma indevida.

Antes de começar a programar, você precisa seguir algumas etapas no console do Firebase.

No console do Firebase, em App Check, registre seu app Android e adicione os respectivos provedores de atestado.

Por exemplo, a Play Integrity ou o reCAPTCHA Enterprise.

Depois de configurar o App Check, comece com o modo não aplicado.

Dessa forma, você permite que o app forneça telemetria para garantir que todos os seus apps estejam recebendo chamadas de API bem-sucedidas para o back-end antes de aplicar a restrição.

Depois de verificar que a telemetria está funcionando corretamente, você pode aplicar o App Check. Nesse momento, todas as solicitações que não tiverem um token válido com atestado de hardware serão rejeitadas.

Este é o código para implementar o App Check.

class FireTravelApp : Application() {
   lateinit var appContainer: AppContainer
       private set
   override fun onCreate() {
       super.onCreate()
       if (BuildConfig.DEBUG) {
           Firebase.appCheck.installAppCheckProviderFactory(
               DebugAppCheckProviderFactory.getInstance()
           )
       } else {
           Firebase.appCheck.installAppCheckProviderFactory(
               PlayIntegrityAppCheckProviderFactory.getInstance()
           )
       }
       appContainer = AppContainer(this)
   }
}

Na classe do aplicativo, instale o provedor do App Check.

Nas etapas de desenvolvimento, use o provedor de depuração. Quando estiver tudo pronto para a produção, mude para o Play Integrity ou o reCAPTCHA Enterprise.

No entanto, lembre-se de que você precisa configurar o App Check antes de fazer qualquer outra chamada do Firebase.

Ao criar recursos de IA, os desenvolvedores costumam codificar os comandos diretamente no código dos apps, mas isso cria dois grandes desafios.

Primeiro, se for necessário improvisar o comando, você precisará enviar a atualização completa.

Segundo, quem descompactar o app terá acesso à sua engenharia de comandos reservada.

Para resolver esse problema, o Firebase AI Logic usa modelos de comandos de servidor.

Em vez de manter os comandos no dispositivo, eles são armazenados na nuvem.

Esta é a visualização dos modelos de comando de servidor no console do Firebase.

Você cria os modelos no formato .prompt.

---
model: 'gemini-3-flash'
input:
  schema:...
tools:...
---
{{role "system"}}
You're a storyteller that tells nice and joyful stories with happy endings.

{{role "user"}}
Create a story about {{topic}} with the length of {{length}} words in the {{language}} language.

Você pode definir o nome do modelo aqui.

Você pode atualizar essa informação a qualquer momento.

Não é necessário enviar a atualização completa do app.

Também é possível atualizar as instruções do sistema, que aceitam um esquema JSON estrito para entrada e saída.

Novamente, não é necessário lançar o app.

Como ele está na nuvem, é possível ajustar um comando ou trocar um modelo instantaneamente.

E este é o código em Kotlin.

val generativeModel = Firebase.ai.templateGenerativeModel()

val response = generativeModel.generateContent("storyteller-v1",
    mapOf(
        "topic" to topic,
        "length" to length,
        "language" to language
    )
)

output.value = response.text

Vale mencionar que os modelos de comando do servidor estão em pré-lançamento público.

Também é possível implementar o modo somente autenticação.

Isso usa tokens de usuário do Firebase Auth para autorizar a solicitação.

Para completar nossos recursos de segurança e bloquear totalmente seu aplicativo, use o modo somente modelo diretamente no console do Firebase.

Depois que o app estiver ativo, talvez você queira saber como ele está se comportando.

Na guia "Monitoramento de IA", com apenas um clique, é possível ativar o monitoramento de IA e configurar a taxa de amostragem.

O Firebase vai capturar automaticamente métricas, latências e contagens de tokens sem que você precise escrever um código de análise personalizado para isso.

Vale lembrar que os dois modos que acabamos de ver estão disponíveis na mesma janela.

Depois de ativar o AI Monitoring no console do Firebase, ele vai alimentar diretamente o painel do AI Monitoring.

É possível observar a latência do 95º percentil, identificar picos repentinos de erro e acompanhar o consumo de tokens em diferentes modalidades, como texto, imagens e áudio.

Também é possível inspecionar o visualizador de traces para ver determinados traces.

Neste caso, como ele mostra o modelo que estamos usando, é possível ver a latência e a taxa de sucesso.

No console do Firebase, onde você pode acessar toda a telemetria e visibilidade de como seu recurso de IA está funcionando.

Nesse caso, digamos que você perceba um aumento repentino no uso de tokens ou na latência. O modelo híbrido é uma maneira de reduzir esses custos ou a latência.

E, como os recursos de IA generativa estão se tornando uma parte fundamental dos nossos apps, confiar 100% apenas na nuvem provavelmente não é a escolha certa.

Ao usar o Nano 4, os modelos no dispositivo no Android, você tem três grandes benefícios, que talvez já conheça.

O primeiro é o modo off-line.

Portanto, seja em uma grande conferência, em um avião ou no metrô, o recurso de IA ainda vai funcionar.

O custo.

Como a inferência é executada no dispositivo, você pode adicionar esses recursos sem se preocupar com o aumento dos custos do seu recurso de IA.

E o terceiro é a privacidade de dados.

Portanto, se forem dados sensíveis, você pode garantir aos usuários que nenhuma inferência está saindo do dispositivo.

Assim, ao usar o Firebase AI Logic, você pode definir esses modos de inferência e ter estratégias de roteamento claras, como PREFER_ON_DEVICE, PREFER_IN_CLOUD ou ONLY_ON_DEVICE.

Quando você escolhe ONLY_ON_DEVICE, o SDK acessa diretamente o modelo no dispositivo, ignorando totalmente a nuvem.

Vamos mudar para o smartphone.

Então, vamos acessar o FriendlyMeals e conferir alguns dos recursos no dispositivo.

Primeiro, vamos tentar criar uma receita com base em alguns ingredientes que podem estar disponíveis na nossa geladeira.

Antes, você viu a Ankita usar o método manual, digitando os ingredientes e gerando a receita.

Então, vamos tentar de outra maneira.

Vamos usar esta geladeira muito real, que não foi gerada por IA.

Tem muitas azeitonas nessa geladeira, então vamos ver que tipo de receita será gerada.

Quero destacar alguns pontos.

Uma delas é que a imagem nunca saiu do dispositivo.

A imagem foi analisada localmente pelo Nano do Gemma…

Nano 4.

E, em segundo lugar, a velocidade com que a resposta foi enviada.

Os ingredientes foram gerados.

Assim, você tem os dois benefícios.

Os dados não saem do dispositivo, e há uma redução significativa na latência.

Vamos ver qual receita recebemos para a geladeira cheia de azeitonas.

Desta vez, vamos usar a nuvem.

Então, estamos pegando os ingredientes identificados na geladeira e enviando para a nuvem usando o Firebase AI Logic para gerar uma receita.

Não vi salmão na geladeira, mas vi na receita.

Mas vamos voltar aos slides, por favor.

Como vimos na demonstração, alternar entre um modelo local e um modelo na nuvem é bem simples.

Atualmente, o Firebase AI Logic permite a inferência usando roteamento básico com base na disponibilidade da rede.

Para gerenciar essa inferência, pense nela como proteções.

Por isso, a arquitetura inclui suporte integrado para recursos como esquemas multimodais e de entrada e saída, além de integração completa com o Gemma, desculpe, com o Gemini Nano 4.

Vamos ver como essas proteções são implementadas na prática.

Assim, o roteamento híbrido não exige que você crie um middleware complexo ou grande parte da lógica de fallback.

Em termos de código, é apenas um parâmetro extra.

Você transmite um parâmetro onDeviceConfig para definir o modo que preferir.

import com.google.firebase.Firebase
import com.google.firebase.ai.ai

@Composable
fun MagicBackpackGenerator() {
    var output by remember { mutableStateOf("") }

    LaunchedEffect(Unit) {

        val model = Firebase.ai.generativeModel(modelName = "gemini-3.8-flash",
onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE))

       val response = model.generateContent("Write a story about a magic backpack")

        output = response.text.toString()

    }
    MagicBackpackUI(output)
}

Nesse caso, o SDK vai tentar o modelo local primeiro e, se ele não estiver disponível, vai usar o modelo na nuvem automaticamente.

Agora que já falamos sobre como criar apps seguros e usar modelos no dispositivo, vamos falar sobre a otimização de custos.

Os recursos generativos podem ser escalonados rapidamente, assim como sua fatura do Cloud Billing.

Por isso, precisamos de proteções adequadas para garantir que tenhamos os controles de infraestrutura proativos e os recursos automatizados certos para tornar seus orçamentos previsíveis e seus aplicativos financeiramente eficientes.

O Arthur acabou de destacar que a inferência no dispositivo é totalmente sem custo financeiro, mas sempre haverá cenários que exigem tarefas de raciocínio complexas, além de fallback e roteamento para a nuvem.

Quando essas chamadas de nuvem acontecem, você precisa de proteções para manter seu orçamento previsível.

É por isso que os limites de gastos do Firebase são tão importantes.

Com os gastos máximos, você tem um controle mais granular sobre o custo dos seus apps.

Assim, em vez de uma configuração de orçamento genérica para todo o projeto, com alertas de orçamento que apenas enviam um e-mail, você pode definir um limite de orçamento específico para serviços individuais, como o Firebase AI Logic.

Quando seu gasto atingir 100%, o Firebase vai pausar automaticamente o serviço de IA para evitar cobranças inesperadas.

Além dos gastos máximos simples, existem várias estratégias avançadas de otimização de custos.

Hoje, queremos destacar os gatilhos do Firebase AI Logic.

E se você precisar de uma lógica personalizada no meio?

Esses são os gatilhos do Firebase AI Logic.

É possível executar uma função antes ou depois de gerar conteúdo.

Use-o para verificar o usuário, filtrar entradas, adicionar contexto e ajustar a resposta.

Agora que já falamos sobre otimização de custos e segurança, vamos mudar o foco para a capacidade do modelo e ver o que o Firebase AI Logic oferece.

Para viabilizar essas experiências multimodais, o Firebase AI Logic oferece um catálogo abrangente de modelos e ferramentas prontos para produção.

Para raciocínio, texto, código e mídia de alta velocidade, use o Gemini 4 Argon, o Gemini 3.1 Pro, o Gemini 3.8 Flash e outros.

Também é possível conectar esses modelos a dados reais usando o embasamento da Pesquisa e do Maps.

Por fim, para voz, oferecemos conversão de texto em voz natural e geração de áudio sintético do Gemini Live.

Vamos mudar para o smartphone mais uma vez.

Aqui temos o doce e o salgado.

Ah, desculpe, não é essa.

Aqui temos nossa torrada rápida com queijo e ketchup para a receita.

Parece gostoso.

A primeira coisa que vamos analisar é a API Live.

Nesse caso, vamos usar o vídeo que está voltando e eu posso dizer: "Gemini, você pode me dizer quais são os ingredientes que estão na mesa?"

Com base na imagem na tela do seu laptop, os ingredientes que você tem são pão, queijo cheddar e ketchup.

Certo.

Posso começar com a primeira etapa da receita?

Sim.

A primeira etapa é preaquecer o forno elétrico ou a grelha em fogo médio-alto.

Nossa equipe agradece.

Certo.

Nesse caso, era a API Live, e a conversa permaneceria aberta até que eu a encerrasse.

O outro que eu gostaria de mostrar é a conversão de voz em texto, ou conversão de texto em voz, desculpe.

E com a conversão de texto em voz, neste exemplo, temos as instruções da receita.

Em vez de ler, posso clicar em "Gerar" ou "Falar" para enviar o texto das instruções ao modelo de conversão de texto em voz.

Ele vai gerar o áudio e enviá-lo de volta ao dispositivo.

Posso reproduzir, armazenar em cache para mais tarde, e ele será reproduzido como vemos aqui.

1.

Preaqueça o forno elétrico ou a grelha em fogo médio-alto.

2.

Coloque duas fatias de pão em uma assadeira ou bandeja de torradeira.

Legal.

Legal, né?

O Firebase AI Logic permite implementar esses tipos de recursos legais com apenas algumas linhas de código.

Vamos voltar aos slides.

Agora que vimos na demonstração como a API Gemini Live funciona, que tal criar sua própria experiência de conversa por comando de voz?

É aí que entra a API Gemini Live, que permite criar conversas de voz bidirecionais.

Seu app Android pode transmitir áudio de microfone e frames de câmera ao vivo e receber uma voz natural, de baixa latência e falada em tempo real.

No Kotlin, a configuração é bem parecida.

val model = Firebase.ai.liveModel(
    modelName = "gemini-3.1-flash-live-preview",
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
   },
   systemInstruction = "Your main job is to change the color...",
   tools = listOf(Tool.functionDeclarations(listOf(changeColorFunction)))
)

val session = model.connect(::handler)

session.startAudioConversation(::handler)

session.stopAudioConversation()

Você instancia um modelo Live configurado para respostas de áudio e se conecta à sessão com um gerenciador de stream.

O ponto principal que gostaríamos de destacar aqui é que o SDK lida com todo o material do WebSocket e os protocolos de streaming em segundo plano.

Então, você não precisa programar, certo?

Continue escrevendo linhas.

Para encerrar nossas demonstrações e olhar para o futuro do desenvolvimento de apps, queremos destacar uma ferramenta poderosa para seu fluxo de trabalho: as habilidades de agente do Firebase.

# Execute to add agent capabilities to your workspace
npx skills add firebase/agent-skills

Além disso, para quem usa o Antigravity e o Android Studio, já integramos o Firebase AI Logic diretamente ao fluxo de integração.

Para encerrar, três conclusões importantes: comece a criar, use as ferramentas de produção desde o início, como as de segurança que abordamos hoje, e use as habilidades de agente sempre que possível.

Nossa equipe agradece.