Instruções

Crie apps Android inteligentes: integre ao sistema de inteligência do Android usando as AppFunctions

Leitura de 6 min
Ver o perfil de Ben Weiss
Ben Weiss Engenheiro de relações com desenvolvedores

Voltamos com a série de postagens do blog "Criar apps Android inteligentes", em que pegamos um app Android básico e o transformamos em uma experiência personalizada, inteligente e de agente. No nosso post anterior, mostramos como usar o Firebase AI Logic para criar recursos de IA híbridos e hospedados na nuvem.

As interfaces móveis tradicionais são excelentes para tarefas focadas e práticas, e o sistema de inteligência do Android está introduzindo recursos complementares para facilitar ainda mais ações complexas e de várias etapas. Ao complementar as interfaces do usuário tradicionais, as AppFunctions oferecem um novo ponto de entrada eficiente: um agente privilegiado no dispositivo pode acessar os recursos do app em segundo plano. Isso pode ser útil principalmente quando os usuários estão dirigindo, caminhando ou fazendo outras coisas ao mesmo tempo.

Neste artigo, vamos mostrar como projetamos e integramos esses recursos ao nosso app de planejamento de viagens, o JetPacker, usando as AppFunctions do Android. Vamos analisar as razões por trás das nossas escolhas de recursos, discutir as ferramentas especializadas que usamos para acelerar o desenvolvimento e conferir o código que faz tudo funcionar.

Como criar recursos prontos para IA: escolhas que fazem a diferença para os usuários

Para selecionar quais recursos fornecer ao sistema de inteligência, procuramos tarefas em que um comando de voz ou texto é objetivamente mais rápido do que tocar nas telas. Nesta gravação de tela lado a lado, você pode ver esse contraste perfeitamente: à esquerda, um usuário tocando em várias telas para registrar uma despesa; à direita, a mesma tarefa concluída instantaneamente em segundo plano por um agente privilegiado.

Nossa primeira escolha foi o controle de despesas. Registrar uma despesa de café durante uma viagem geralmente exige vários toques: desbloquear o smartphone, abrir o app, encontrar a viagem ativa, navegar até a guia de despesas, tocar no botão de adição, tirar uma foto do recibo e verificar o resultado. Ao fornecer os recursos addExpense e getExpenses como AppFunctions, o agente do sistema lida com o trabalho pesado. Quando o usuário diz "Adicione uma despesa de café de cinco dólares à minha viagem a Paris", o agente pesquisa automaticamente o ID da viagem correta em segundo plano e insere a despesa, ignorando completamente o fluxo manual da interface.

Também priorizamos o gerenciamento de itinerários. Para descobrir qual é a próxima atividade em um itinerário de viagem movimentado, geralmente é necessário rolar por uma visualização de linha do tempo densa. Ao fornecer getItinerary e addItineraryEvent ao sistema, o usuário pode simplesmente perguntar: "O que vou fazer em seguida em Paris?" e receber uma resposta imediata.

Por fim, focamos na captura de notas por comando de voz. Digitar lembretes ou notas enquanto caminha por uma rua movimentada é difícil e perigoso. Ao expor um recurso de nota de voz, o usuário pode dizer: "O voo foi incrível, vi um pôr do sol lindo e consegui dormir bem", e o agente privilegiado transcreve e salva automaticamente essa informação no banco de dados de viagens usando a AppFunction addVoiceNote.

MCP do Android com tecnologia AppFunctions

Toda essa experiência é baseada no MCP do Android. Nesse design, o app atua como um servidor MCP local. Em vez de APIs remotas, você fornece os recursos do app diretamente ao sistema de inteligência no dispositivo.

As AppFunctions do Android são a API que dá vida a esse conceito. Ele lê funções anotadas do Kotlin e as compila em definições de ferramentas com segurança de tipos e em sandbox que o agente privilegiado pode descobrir e invocar localmente no dispositivo.

Android MCP diagram.png
Diagrama destacando nossos apps, a plataforma Android e os agentes do sistema que coordenam as AppFunctions.

No modelo MCP do Android, seu app atua como um servidor MCP local que expõe ferramentas estruturadas, enquanto a plataforma Android serve como o registro central de ferramentas. No lado do cliente do MCP, os apps de agente são registrados no sistema de inteligência depois de receberem permissões privilegiadas para acessar o registro.

Quando um usuário interage com um agente registrado, o LLM dele determina se a solicitação pode ser processada por uma AppFunction, consulta os metadados da plataforma e executa as funções registradas adequadas em segundo plano. Esse design de cliente-servidor MCP local oferece controle total: você escolhe exatamente quais recursos o agente pode acessar, mantendo o restante dos dados do app privados.

Como aceleramos o desenvolvimento com as habilidades do Android

Para simplificar o processo de integração, usamos a habilidade de desenvolvimento de AppFunctions. A habilidade de desenvolvimento de AppFunctions é um assistente de desenvolvimento completo. Ele nos guiou por todo o ciclo de vida: mapeamento de classes de dados do Kotlin para serializar parâmetros, geração dos pontos de entrada Service necessários, refinamento da documentação do KDoc para garantir que o LLM entenda os limites dos parâmetros e configuração de testes automatizados usando o ADB.

Fornecer recursos do app para o sistema de inteligência

Chega de teoria, vamos para a implementação.

Configuração e dependências

Começamos adicionando as dependências do AppFunctions. Uma para a API e outra para o compilador do Kotlin Symbol Processing.

implementation("androidx.appfunctions:appfunctions:1.0.0-alpha10")
ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha10")

Como modelar tipos de dados personalizados

Qualquer objeto personalizado trocado com o agente precisa ser anotado com @AppFunctionSerializable. No arquivo TripSerializable.kt, definimos o modelo de dados da viagem:

@AppFunctionSerializable(isDescribedByKDoc = true)
data class TripSerializable(
    /** The trip's unique identifier. */
    val id: String,
    /** The trip's title. */
    val title: String,
    /** The trip's destination location. */
    val location: String,
    /** The trip's start date in milliseconds. */
    val startDate: Long,
    /** The trip's end date in milliseconds. */
    val endDate: Long,
    /** A list of participants. */
    val participants: List<String>,
)

Como fornecer recursos usando a anotação @AppFunction

Em seguida, a habilidade escreveu as funções do Kotlin que realizam as consultas no banco de dados e as anotou com @AppFunction. Podemos ver isso em searchTrip:

/**
 * Looks for trips based on optional filters like id, title (name), location, and dates.
 *
 * @param id The unique identifier of the trip.
 * @param title The title or name of the trip.
 * @param location The destination location.
 * @param startDate The minimum start date in milliseconds.
 * @param endDate The maximum end date in milliseconds.
 * @return A list of trips matching the filters.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun searchTrip(
    id: String? = null,
    title: String? = null,
    location: String? = null,
    startDate: Long? = null,
    endDate: Long? = null
): List<TripSerializable> {
    return withContext(Dispatchers.IO) {
    // implementation
}

Como as AppFunctions são executadas na linha de execução de interface por padrão, usamos withContext(Dispatchers.IO) para alternar para um agente em segundo plano. Além disso, refinamos nosso KDoc para usar verbos claros e imperativos e especificar restrições de parâmetros. Essa documentação é compilada diretamente no esquema da ferramenta, que o agente privilegiado usa para resolver parâmetros e lidar com erros de tempo de execução.

O ponto de entrada do serviço e a integração do Hilt

Para registrar esses recursos no sistema de inteligência, criamos uma classe de base abstrata que estende AppFunctionService. Adicionamos a anotação @AppFunctionServiceEntryPoint:

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "JetPackerAppFunctionService",
    appFunctionXmlFileName = "jetpacker_app_function_service"
)
abstract class BaseJetPackerAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var tripDao: TripDao
    // DAOs and database references are injected here...
}

Durante a compilação, o KSP gera a subclasse de serviço concreta final, JetPackerAppFunctionService, conforme declarado com o parâmetro serviceName. Também registramos app_metadata.xml no manifesto do app. Esse arquivo fornece regras operacionais globais para as AppFunctions declaradas do JetPacker.

Como testar e verificar suas AppFunctions

Depois de implementar, verifique se as AppFunctions estão registradas e funcionando corretamente.

Em dispositivos em execução ou emuladores com o Android 17 ou mais recente, é possível usar comandos adb no terminal para listar e invocar as funções. A execução de adb shell cmd app_function list-app-functions mostra todas as funções registradas para o pacote. Em seguida, execute uma função específica e teste a integração do banco de dados executando adb shell cmd app_function execute-app-function enquanto transmite uma string de parâmetros JSON brutos.

Em vez desses comandos do ADB, você também pode usar o Agente de teste de AppFunctions para inspecionar sua configuração, listar e executar AppFunctions e até mesmo ver como elas se comportam em um fluxo de conversa real.

Juntando tudo

Ao pensar em recursos de apps que podem ser contribuídos para o sistema de inteligência usando AppFunctions, é necessário mudar um pouco a forma como pensamos sobre código e documentação. Com as AppFunctions, você pode usar esse novo modelo de interação para apps, que permite usar um agente para acessar recursos do app.

Primeiro, a habilidade de desenvolvimento de AppFunctions é uma ferramenta essencial do ciclo de vida, que ajuda você a descobrir recursos, implementar e refinar AppFunctions para seus apps. Em segundo lugar, os comentários do KDoc são um recurso de API compilado. Descrições claras de parâmetros afetam diretamente a precisão da execução do agente do sistema. Por fim, o MCP do Android oferece execução local, permitindo que os apps colaborem com segurança com agentes de IA.

Ao contribuir com recursos do app usando as AppFunctions, seu aplicativo fica pronto para o sistema de inteligência. Conte para a gente como você está adaptando seus apps para a era agêntica.

Saiba mais

Confira as outras partes desta série de postagens do blog:
Parte 1: introdução ao app e visão geral de alto nível.
Parte 2: inteligência no dispositivo. Conheça as APIs de IA generativa do Kit de ML e o Gemini Nano para criar recursos com foco em privacidade, como resumo de itinerários, análise de recibos e processamento de áudio local.
Parte 3: raciocínio híbrido e na nuvem. Saiba como usar o Firebase AI Logic para embasar as respostas do LLM em dados do mundo real, como o Google Maps e o contexto da Web.
Parte 4 (este post!) Integração de sistemas. Integração com o sistema de inteligência do Android usando AppFunctions.
Parte 5 (em breve): Agentic Workflows no app. Estender o app com um assistente de agendamento completo, com tecnologia da A2UI e do ADK.

Quer saber mais sobre o desenvolvimento para Android? Siga o Desenvolvedores Android no YouTube ou no LinkedIn!

Todos os snippets de código neste post do blog seguem a seguinte notificação de direitos autorais:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
Escrito por:
Continue lendo