Criar apps Android inteligentes: integrar ao sistema de inteligência do Android usando AppFunctions

Bem-vindos de volta à 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 agêntica. Na nossa postagem anterior, mostramos como aproveitar o Firebase AI Logic para criar recursos de IA híbridos e hospedados na nuvem.

As interfaces tradicionais para dispositivos móveis 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 de várias etapas. Ao complementar as interfaces tradicionais, as AppFunctions oferecem um novo ponto de entrada poderoso: um agente privilegiado no dispositivo pode acessar os recursos do app em segundo plano. Isso pode ser particularmente útil quando os usuários estão dirigindo, caminhando ou fazendo várias tarefas 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 mostrar a lógica por trás das nossas escolhas de recursos, discutir as ferramentas especializadas que usamos para acelerar o desenvolvimento e analisar o código que faz tudo funcionar.

Como projetar recursos preparados para IA: fazer escolhas importantes 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 acompanhamento de despesas. Registrar uma despesa de café durante uma viagem geralmente exige alguns toques: desbloquear o smartphone, abrir o app, encontrar a viagem ativa, navegar até a guia de despesas, tocar no botão "Adicionar", 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 "Adicionar uma despesa de café de cinco dólares à minha viagem a Paris", o agente pesquisa automaticamente o ID da viagem correto em segundo plano e insere a despesa, ignorando completamente o fluxo manual da interface.

Também priorizamos o gerenciamento de itinerários. Encontrar a próxima atividade em um itinerário de viagem movimentado geralmente exige 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, nos concentramos na captura de notas sem usar as mãos. Digitar lembretes ou notas enquanto caminha por uma rua movimentada é difícil e perigoso. Expor um recurso de nota em áudio permite que o usuário diga "O voo foi incrível, vi um pôr do sol lindo e consegui dormir bem", e o agente privilegiado transcreve e salva automaticamente a nota diretamente no banco de dados de viagens usando a AppFunction addVoiceNote.

MCP do Android com tecnologia AppFunctions

Toda essa experiência é criada 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.

A AppFunctions do Android é a API que dá vida a esse conceito. Ela lê funções Kotlin anotadas e as compila em definições de ferramentas seguras e em sandbox que o agente privilegiado pode descobrir e invocar localmente no dispositivo.

No modelo MCP do Android, o 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 MCP, os apps de agente são registrados no sistema de inteligência depois de receber permissões privilegiadas do sistema 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 apropriadas em segundo plano. Esse design de cliente-servidor MCP local oferece controle total: você escolhe exatamente quais recursos estão acessíveis ao agente, mantendo o restante dos dados do app privados.

Como aceleramos o desenvolvimento com habilidades do Android

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

Como fornecer recursos de app ao sistema de inteligência

Chega de teoria, vamos à implementação.

Configuração e dependência

Começamos adicionando as dependências das AppFunctions. Uma para a API e outra para o compilador 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 nosso modelo de dados de 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 Kotlin que executam as consultas do banco de dados e as anotam 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 da interface por padrão, usamos withContext(Dispatchers.IO) para mudar para um dispatcher 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 processar erros 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. Anotamos com @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 as AppFunctions

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

Em dispositivos 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, você pode executar uma função específica e testar a integração do banco de dados executando adb shell cmd app_function execute-app-function ao transmitir uma string de parâmetros JSON bruta.

Em vez desses comandos ADB, também é possível usar o agente de teste de AppFunctions para inspecionar a configuração, listar e executar AppFunctions e até mesmo ver como as AppFunctions se comportam em um fluxo conversacional real.

Juntando tudo

Ao pensar em recursos de app 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. As AppFunctions permitem 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, ajudando 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.

A contribuição de recursos de app pelas AppFunctions prepara o aplicativo para o sistema de inteligência. Informe 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 do app e uma visão geral de alto nível.
Parte 2: inteligência no dispositivo. Aprofunde-se nas APIs GenAI do Kit de ML e no Gemini Nano para criar recursos que priorizam a privacidade, como resumo de itinerários, análise de recibos e tratamento de áudio local.
Parte 3: raciocínio híbrido e na nuvem. Saiba como usar o Firebase AI Logic para fundamentar as respostas do LLM em dados do mundo real, como o Google Maps e o contexto da Web.
Parte 4 (esta postagem): Integração de sistema. Integração com o sistema de inteligência do Android usando AppFunctions.
Parte 5 (em breve): fluxos de trabalho agênticos no app. Estenda o app com um assistente de reservas completo com tecnologia A2UI e ADK.

Tem interesse em saber mais sobre o desenvolvimento para Android? Siga o Android Developers no YouTube ou no LinkedIn.

Todos os snippets de código nesta postagem do blog seguem a notificação de direitos autorais abaixo:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0