Interfaces de usuário móveis tradicionais se destacam em tarefas focadas e manuais, e o sistema de inteligência do Android está introduzindo recursos complementares para tornar ações complexas e multi-etapas ainda mais fáceis. Ao complementar as interfaces de usuário tradicionais, AppFunctions fornecem uma nova entrada poderosa: um agente privilegiado no dispositivo pode acessar recursos de aplicativos em segundo plano. Isso é particularmente útil quando os usuários estão dirigindo, caminhando ou realizando outras tarefas simultâneas.
Neste artigo, mostraremos como projetamos e integraramos essas capacidades no nosso aplicativo de planejamento de viagens, JetPacker, usando Android AppFunctions. Exploraremos a lógica por trás das nossas escolhas de recursos, discutiremos as ferramentas especializadas que usamos para acelerar o desenvolvimento e mergulharemos no código que torna tudo isso possível.
Para selecionar quais recursos fornecer ao sistema de inteligência, procuramos por tarefas onde um comando de voz ou texto é objetivamente mais rápido do que tocar em várias telas. Nesta gravação de tela lado a lado, você pode ver essa contraste perfeitamente: à esquerda, um usuário tocando em várias telas para registrar uma despesa; à direita, a mesma tarefa concluída instantaneamente no segundo plano por meio de um agente privilegiado.
Nossa primeira escolha foi o rastreamento de gastos. Registrar um gasto com café durante uma viagem geralmente requer muitos toques - desbloquear o telefone, abrir o aplicativo, encontrar a viagem ativa, navegar até a aba de despesas, clicar no botão adicionar, tirar uma foto do recibo e verificar o resultado. Ao fornecer os recursos addExpense e getExpenses como AppFunctions, o sistema agente lida com toda a operação pesada. Quando o usuário diz: "Adicione um gasto de cinco dólares em café à minha viagem em Paris", o agente pesquisa automaticamente a ID da viagem correta no segundo plano e insere o gasto, pulando completamente o fluxo manual de interface do usuário.
Também priorizamos a gestão de itinerários. Encontrar qual atividade vem a seguir em um itinerário de viagem ocupado geralmente requer rolar por uma visualização densa de cronograma. Ao fornecer getItinerary e addItineraryEvent ao sistema, o usuário pode simplesmente perguntar: "O que estou fazendo a seguir em Paris?" e receber uma resposta imediata.
Finalmente, focamos na captura de notas sem mãos. Digitar lembretes ou anotações enquanto caminha por uma rua movimentada é difícil e inseguro. Expor uma capacidade de nota por voz permite que o usuário diga: "O voo foi incrível, vi um pôr do sol bonito e consegui dormir bem", e o agente privilegiado transcreve automaticamente e salva diretamente no banco de dados de viagem usando a função AppFunction addVoiceNote.
Android MCP alimentado por AppFunctions
Toda essa experiência é construída sobre Android MCP. Nesta design, o aplicativo atua como um servidor local MCP. Em vez de APIs remotas, você fornece os recursos do seu aplicativo diretamente ao sistema de inteligência no dispositivo.
Android AppFunctionsé a API que traz essa ideia à vida. Ela lê funções Kotlin anotadas e as compila em definições de ferramentas seguras do tipo que o agente privilegiado pode descobrir e invocar localmente no dispositivo.
Diagrama destacando nossos aplicativos, a plataforma Android e os agentes do sistema coordenam AppFunctions.
No modelo MCP do Android, seu aplicativo atua como um servidor local MCP que expõe ferramentas estruturadas, enquanto a plataforma Android serve como o registro central de ferramentas. Do lado do cliente MCP, aplicativos de agente são registrados no sistema de inteligência após serem concedidos permissões privilegiadas do sistema para acessar o registro.
Quando um usuário interage com um agente registrado, seu LLM determina se a solicitação pode ser tratada por uma AppFunction, consulta os metadados da plataforma e executa as funções registradas adequadas em segundo plano. Este design cliente-servidor local MCP dá a você o controle total: você escolhe exatamente quais recursos são acessíveis ao agente, mantendo o restante dos dados do seu aplicativo privado.
Como aceleramos o desenvolvimento com habilidades Android
Habilidade de desenvolvimento de AppFunctions
. A habilidade de desenvolvimento de AppFunctions é um companheiro completo durante o ciclo de vida. Ela nos guiou desde a mapeação de classes de dados Kotlin para serializar parâmetros, geração dos pontos de entrada Service, refinamento da documentação KDoc para garantir que o LLM entenda os limites dos parâmetros e configuração de testes automatizados usando ADB.
Fornecendo recursos do aplicativo ao sistema inteligente
Suficiente com a teoria, vamos mergulhar na implementação.
Configuração e instalação de dependências
Iniciamos adicionando as dependências AppFunctions. Uma para a API e uma para o compilador Kotlin Symbol Processing.
implementation("androidx.appfunctions:appfunctions:1.0.0-alpha10")
ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha10")Mapeando tipos de dados personalizados
Qualquer objeto personalizado trocado com o agente deve ser anotado com @AppFunctionSerializable. Em nosso arquivo TripSerializable.kt, definimos nosso modelo de dados para viagens:
@AppFunctionSerializable(isDescribedByKDoc = true)
data class TripSerializable(
/** O identificador único da viagem. */
val id: String,
/** O título da viagem. */
val title: String,
/** A localização de destino da viagem. */
val location: String,
/** A data de início da viagem em milissegundos. */
val startDate: Long,
/** A data final da viagem em milissegundos. */
val endDate: Long,
/** Uma lista de participantes. */
val participants: List<String>,
)Fornecendo recursos usando a anotação @AppFunction
A seguir, a habilidade escreveu as funções Kotlin que realizam consultas ao banco de dados e as anotou com @AppFunction. Podemos ver isso em searchTrip:
/**
* Procura por viagens com base em filtros opcionais como id, título (nome), localização e datas.
*
* @param id O identificador único da viagem.
* @param title O título ou nome da viagem.
* @param location A localização de destino.
* @param startDate A data mínima de início em milissegundos.
* @param endDate A data máxima final em milissegundos.
* @return Uma lista de viagens que correspondem aos filtros.
*/
@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) {
// implementação
}Como AppFunctions executam na thread do UI por padrão, usamos withContext(Dispatchers.IO) para trocar para um despachante de fundo. Além disso, refinamos nossa documentação KDoc para usar verbos imperativos claros e especificar restrições de parâmetros. Esta documentação compila diretamente no esquema da ferramenta, que o agente privilegiado usa para resolver parâmetros e lidar com erros em tempo de execução.
O ponto de entrada do serviço e integração Hilt
Para registrar esses recursos com o sistema inteligente, criamos uma classe base abstrata que estende AppFunctionService. Anotamos-a com @AppFunctionServiceEntryPoint:
@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
serviceName = "JetPackerAppFunctionService",
appFunctionXmlFileName = "jetpacker_app_function_service"
)
abstract class BaseJetPackerAppFunctionService : AppFunctionService() {
@Inject internal lateinit var tripDao: TripDao
// DAOs e referências de banco de dados são injetados aqui...
}Durante a compilação, KSP gera a subclasse concreta final do serviço JetPackerAppFunctionService, conforme declarado com o parâmetro serviceName. Também registramos app_metadata.xml no manifesto do aplicativo. Este arquivo fornece regras operacionais globais para AppFunctions declaradas pelo JetPacker.
Testando e verificando suas AppFunctions
Uma vez implementado, você deve verificar que suas AppFunctions estão registradas e funcionando corretamente.
Rodando dispositivos ou emuladores com Android 17 ou superior, você pode usar os comandos ADB do terminal para listar e invocar suas funções. Executando adb shell cmd app_function list-app-functions, exibe todas as funções registradas para seu pacote. Você pode então executar uma função específica e testar a integração de banco de dados, executando adb shell cmd app_function execute-app-function enquanto passa uma string JSON de parâmetros brutos.
Ao invés desses comandos ADB, você também pode usar o AppFunctions Testing Agent para inspecionar sua configuração, listar e executar AppFunctions, e até mesmo ver como suas AppFunctions se comportam em um fluxo conversacional real.
Conclusão
Criar recursos de aplicativo que podem ser contribuídos para o sistema inteligente usando AppFunctions requer uma pequena mudança na maneira como pensamos sobre código e documentação. As AppFunctions permitem usar esse novo modelo de interação para apps, permitindo ao agente acessar recursos do app.
Primeiro, a habilidade de desenvolvimento de AppFunctions é uma ferramenta essencial do ciclo de vida, ajudando você a descobrir recursos, implementar e refinar AppFunctions para seus apps. Em segundo lugar, os comentários KDoc são um ativo da API compilada; descrições claras dos parâmetros impactam diretamente na precisão de execução do sistema agente. Finalmente, o Android MCP fornece a execução local-first permitindo que os aplicativos colaborem com segurança com agentes de IA.
Contribuir recursos de aplicativo através das AppFunctions torna seu aplicativo pronto para o sistema inteligente. Nos conte como você está adaptando seus apps para a era agêntica!
Saiba mais
Confira as outras partes desta série do blog post:
Parte 1: Introdução ao app e uma visão geral de alto nível.
Parte 2: Inteligência no dispositivo. Profundidade em APIs GenAI do ML Kit e Gemini Nano para construir recursos de privacidade-first como resumo de itinerário, análise de recibos e processamento local de áudio.
Parte 3: Raciocínio híbrido e em nuvem. Explore como usar o Firebase AI Logic para fundamentar respostas de LLM em dados do mundo real, como Google Maps e contexto da web.
Parte 4 (esta postagem!): Integração com o sistema inteligente do Android usando AppFunctions.
Parte 5 (em breve): Fluxos de trabalho agênticos no aplicativo. Estenda o app com um assistente de reserva end-to-end alimentado por A2UI e ADK.
Interessado em mais sobre desenvolvimento para Android? Siga os Desenvolvedores do Android no YouTube ou LinkedIn!
Todos os trechos de código neste post de blog seguem a seguinte declaração de direitos autorais:
Direitos Autorais 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0