As AppFunctions são uma API da plataforma Android com uma biblioteca do Jetpack para simplificar a integração do MCP do Android. Ele permite que seus apps se comportem como servidores MCP no dispositivo, contribuindo com funções que atuam como ferramentas para uso por recursos proativos, além de agentes e assistentes, como o Google Gemini. Para testar e publicar suas AppFunctions com o Gemini, inscreva-se na prévia para desenvolvedores da plataforma de apps conectados. Depois de participar, siga as etapas em Criar e gerenciar apps conectados.
Ao definir essas AppFunctions, você permite que seu app forneça serviços, dados e ações ao registro integrado ao SO Android, permitindo que os usuários concluam tarefas por meio de agentes e interações no nível do sistema.
As AppFunctions são o equivalente para dispositivos móveis das ferramentas no Protocolo de Contexto de Modelo (MCP). Enquanto o MCP tradicionalmente padroniza como os agentes
se conectam a ferramentas do lado do servidor, as AppFunctions oferecem o mesmo mecanismo para
apps Android. Isso permite expor os recursos do seu app como "ferramentas"
orquestráveis que os apps autorizados (chamadores) podem descobrir e executar para atender às intenções
do usuário. Os autores de chamada precisam ter a permissão EXECUTE_APP_FUNCTIONS para
descobrir e executar AppFunctions, e podem incluir agentes, apps e assistentes de
IA, como o Gemini.
O AppFunctions está disponível em dispositivos com o Android 16 ou versões mais recentes.
Exemplos de casos de uso
As AppFunctions oferecem um mecanismo poderoso para automatizar tarefas e simplificar as interações do usuário. Ao abrir os recursos do app, você permite que os usuários alcancem metas complexas usando linguagem natural, muitas vezes substituindo a necessidade de navegação manual detalhada pela interface.
Os cenários a seguir ilustram como as AppFunctions podem ser usadas para impulsionar experiências em várias categorias de apps:
Gerenciamento de tarefas e produtividade
- Solicitação do usuário: "Me lembre de pegar meu pacote no trabalho hoje às 17h".
- Ação do AppFunction: o autor da chamada identifica o app de gerenciamento de tarefas relevante e invoca uma função para criar uma tarefa, preenchendo automaticamente os campos de título, horário e local com base no comando do usuário.
/** * Create a new task or reminder with a title, due time, and location. * * @param title The descriptive title of the task (e.g., "Pick up my package"). * @param dueDateTime The specific date and time when the task should be completed. * @param location The physical location associated with the task (e.g., "Work"). * @return The created Task */ @AppFunctionDeclaration(isDescribedByKDoc = true) suspend fun createTask( title: String, dueDateTime: LocalDateTime? = null, location: String? = null, ): Task = TODO()
Mídia e entretenimento
- Pedido do usuário: "Crie uma playlist com os melhores álbuns de jazz deste ano".
- Ação do AppFunction: o autor da chamada executa uma função de criação de playlist em um app de música, transmitindo um contexto como "principais álbuns de jazz de 2026" como a consulta para gerar a playlist imediatamente.
/** * Create a new music playlist based on a natural language query. * * @param query The description used to generate the playlist (e.g., "top jazz albums from 2026"). * @return The final created playlist based on songs. */ @AppFunctionDeclaration(isDescribedByKDoc = true) suspend fun createPlaylistFromQuery( query: String, ): Playlist = TODO()
Fluxos de trabalho entre apps
- Pedido do usuário: "Encontre a receita de macarrão no e-mail da Lisa e adicione os ingredientes à minha lista de compras".
- Ação do AppFunction: essa solicitação usa funções de vários apps. Primeiro, o autor da chamada usa a função de pesquisa de um app de e-mails para recuperar o conteúdo. Em seguida, ele extrai os ingredientes relevantes e invoca uma função de um app de lista de compras para preencher a lista do usuário.
/** * Search for emails matching a query or sender name to retrieve content like recipes. * * @param query The search term or contact name (e.g., "Lisa noodle recipe"). * @return A list of matching email summaries containing the requested information. */ @AppFunctionDeclaration(isDescribedByKDoc = true) suspend fun searchEmails( query: String, ): List<EmailSummary> = TODO() /** * Add a list of items or ingredients to the user's active shopping list. * * @param items The names of the ingredients or products to add to the list. * @return The final shopping list with new items added */ @AppFunctionDeclaration(isDescribedByKDoc = true) suspend fun addItemsToShoppingList( items: List<String>, ): ShoppingList = TODO()
Agenda e agendamento
- Solicitação do usuário: "Adicione a festa de aniversário da minha mãe à minha agenda para a próxima segunda-feira às 18h".
- Ação do AppFunction: o app agêntico aprovado invoca a função "criar evento" do app de agenda, analisando o contexto relevante, como "próxima segunda-feira" e "18h", para criar a entrada sem que o usuário precise abrir a agenda manualmente.
/** * Schedule a new event on the user's primary calendar. * * @param title The name of the calendar event (e.g., "Mom's birthday party"). * @param startDateTime The specific date and time the event is scheduled to begin. * @return The created Event object. */ @AppFunctionDeclaration(isDescribedByKDoc = true) suspend fun createCalendarEvent( title: String, startDateTime: LocalDateTime, ): Event = TODO()
Como as AppFunctions funcionam
O diagrama a seguir ilustra o fluxo típico de como as AppFunctions são compartilhadas por apps com um agente e executadas em seguida. É provável que os agentes considerem as ferramentas MCP remotas do lado do servidor e as AppFunctions locais ao processar as solicitações do usuário. O fluxo detalhado para usar AppFunctions locais é o seguinte:
- Declaração de AppFunction: o app Android é criado para usar AppFunctions e disponibilizar os recursos dele, como "Criar nota" ou "Enviar mensagem".
- Geração de esquema: a biblioteca AppFunctions do Jetpack gera um arquivo de esquema XML que lista todas as AppFunctions declaradas no app. O SO Android usa esse arquivo para indexar as AppFunctions disponíveis.
- Recuperação de metadados: o agente pode recuperar metadados de AppFunction consultando-os. Além dos KDocs específicos de funções, os desenvolvedores podem definir padrões e restrições operacionais no nível do app nos metadados do app para orientar a orquestração de agentes em várias ferramentas.
- Seleção e execução de AppFunction: com base nas solicitações do usuário, o agente seleciona e executa a AppFunction adequada com os parâmetros apropriados.
A biblioteca AppFunctions do Jetpack simplifica a exposição da funcionalidade do seu app.
Com o processador de anotações, você anota as funções que quer disponibilizar
para os agentes. Os autores de chamadas podem descobrir e invocar essas funções indexadas usando AppFunctionManager.
Antes de invocar uma função, os autores da chamada precisam verificar se o dispositivo oferece suporte ao
recurso AppFunctions tentando recuperar uma instância de
AppFunctionManager. Depois que houver suporte, os autores de chamada poderão verificar se uma função específica
está ativada em um app de destino usando
isAppFunctionEnabled(packageName,functionId). Para consultar o status de
funções em outros pacotes, é necessária a
permissão android.permission.EXECUTE_APP_FUNCTIONS.
O app não precisa verificar se o recurso AppFunction é compatível.
Isso é processado automaticamente na biblioteca do Jetpack. Por exemplo,
AppFunctionManager pode verificar se o recurso é compatível.
Confira um exemplo de AppFunctions para um app de anotações com recursos para criar, editar e listar notas:
@RequiresApi(36) @AndroidEntryPoint @AppFunctionServiceEntryPoint( serviceName = "TaskAppFunctionService", appFunctionXmlFileName = "task_app_function_service", ) abstract class BaseTaskAppFunctionService : AppFunctionService() { @Inject internal lateinit var taskRepository: TaskRepository /** * Creates a task with a title, content, or both. * * @param createTaskParams The title and content of the task. At least one * of them is required. * @return The created task, including its ID. */ @AppFunctionDeclaration(isDescribedByKDoc = true) suspend fun createTask( createTaskParams: CreateTaskParams, ): Task = withContext(Dispatchers.IO) { // Developers can use predefined exceptions to let the agent know // why it failed. if (createTaskParams.title == null && createTaskParams.content == null) { throw AppFunctionInvalidArgumentException("A task needs a title, content, or both.") } val id = taskRepository.createTask( createTaskParams.title, createTaskParams.content ) return@withContext taskRepository .getTask(id) ?.toTask() ?: throw AppFunctionElementNotFoundException("Task not found for ID = $id") } // Maps internal TaskEntity private fun TaskEntity.toTask() = Task(id = id, title = title, content = description) }
/** The title and content of a new task. */ @AppFunctionSerializable(isDescribedByKDoc = true) data class CreateTaskParams( /** The title of the task. */ val title: String?, /** The content of the task. */ val content: String?, ) /** The user-created task. */ @AppFunctionSerializable(isDescribedByKDoc = true) data class Task( /** The ID of the task. */ val id: String, /** The title of the task. */ val title: String, /** The content of the task. */ val content: String, )
Amostras, habilidades e ferramentas de teste
Disponibilizamos os seguintes recursos para ajudar você a se aprimorar no AppFunctions:
- Confira o exemplo de AppFunctions para verificar e entender como tudo funciona nos seus dispositivos.
- Use a habilidade de agente do AppFunctions para acelerar
o desenvolvimento no ciclo de vida de quatro etapas:
- Descoberta: analise sua base de código para identificar e recomendar recursos de alto valor para a orquestração de IA.
- Implementação e configuração: gere implementações do Kotlin e configure os metadados do sistema e as dependências de build.
- Refinamento do KDoc: otimize a documentação de funções e propriedades para agentes de IA e o MCP do Android.
- Teste e depuração: forneça comandos do ADB para avaliação local e depuração no dispositivo.
- Teste o comportamento das suas funções, incluindo padrões omitidos, chamadas de linha de execução principal, erros
AppFunctionExceptione entradas geradas pelo modelo, e como os agentes as selecionam e chamam. Para mais informações sobre testes de unidade, ADB e agente, consulte Verificar a integração do AppFunction. - Para testar como o Gemini usa suas AppFunctions, siga as etapas em Criar e gerenciar apps conectados.
Perguntas frequentes
A seção a seguir aborda as perguntas frequentes sobre as AppFunctions.
Sou desenvolvedor de apps. Posso implementar as AppFunctions hoje?
Sim, é possível implementar e testar as AppFunctions no seu app seguindo as orientações detalhadas nas seções anteriores.
Qual é a diferença entre as AppFunctions e o MCP?
Ambos permitem que os agentes de IA orquestrem ferramentas, mas têm diferenças significativas na arquitetura, na latência e no esforço de desenvolvimento necessário. As AppFunctions são ganchos integrados no nível do SO exclusivos do Android que são executados localmente. Por outro lado, um servidor MCP padrão é uma solução independente de plataforma que depende da execução na nuvem e de idas e voltas de rede.
Em resumo, o desenvolvimento com AppFunctions permite usar o estado atual do app diretamente no dispositivo e não exige que você mantenha serviços fora do app Android.
Implementei as AppFunctions no meu app. Por que o Gemini ou outros agentes de IA não conseguem acessá-las?
- Para usar suas AppFunctions com o Gemini no Android: registre e envie seu app no Google Connected Console pela prévia para desenvolvedores da Connected Apps Platform. Até que o app conectado seja publicado, somente os testadores na lista de testadores do app conectado poderão usá-lo, e apenas na versão do pacote de apps que você enviou. Para conferir as etapas de configuração, consulte os guias do Console conectado do Google para apps conectados e MCP do Android.
- Para chamar AppFunctions do seu próprio agente: um app pode chamar AppFunctions
declaradas no próprio pacote. Para descobrir e chamar as AppFunctions de outros apps, é necessária a permissão privilegiada
EXECUTE_APP_FUNCTIONS, que o Android concede apenas a assistentes de sistema autorizados.
Como posso preparar meu app para a disponibilidade geral das AppFunctions?
Considere quais recursos do app você quer expor à automação agêntica.
Você pode implementar as AppFunctions no seu app. Para fazer isso, siga as etapas nas
seções anteriores desta página e verifique se elas estão registradas no
dispositivo chamando adb shell cmd app_function list-app-functions --package
com o nome do pacote do app.
Como posso testar e publicar minhas AppFunctions com o Gemini?
Participe da prévia para desenvolvedores da Connected Apps Platform. Para solicitar acesso, inscreva-se no pré-lançamento. Depois de participar, no Google Connected Console, crie um app conectado do MCP para Android, faça upload do pacote de app para uma faixa de teste e adicione os mesmos testadores a ambos. Para mais detalhes, consulte Criar e gerenciar apps conectados.
Como posso enviar feedback sobre as AppFunctions?
Para enviar feedback sobre a API, registre um problema.