Visão geral do AppFunctions

Com as AppFunctions, seu app Android pode compartilhar funcionalidades específicas que o sistema e vários agentes e assistentes de IA podem descobrir e invocar. Ao definir essas funções, você permite que o app forneça serviços, dados e ações ao SO Android, permitindo que os usuários concluam tarefas por agentes de IA e interações no nível do sistema.

As AppFunctions são o equivalente móvel das ferramentas no Protocolo de Contexto de Modelo (MCP). Embora o MCP padronize tradicionalmente 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 app como "ferramentas" orquestráveis que apps autorizados (chamadores) podem descobrir e executar para atender às intenções do usuário. Os chamadores 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.

As AppFunctions funcionam com dispositivos que executam o Android 16 ou versões mais recentes.

Exemplos de casos de uso

As AppFunctions oferecem um mecanismo eficiente para automatizar tarefas e simplificar as interações do usuário. Ao expor os recursos do app, você permite que os usuários alcancem metas complexas usando linguagem natural, muitas vezes sem precisar de navegação manual e gradual com a interface.

Os cenários a seguir ilustram como o AppFunctions pode ser usado para impulsionar experiências em várias categorias de apps:

  • Gerenciamento de tarefas e produtividade
    • Comando do usuário: "Me lembre de retirar meu pacote no trabalho hoje às 17h".
    • Ação 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, hora e local com base no comando do usuário.
  • Mídia e entretenimento
    • Comando do usuário: "Crie uma playlist com os melhores álbuns de jazz deste ano".
    • Ação AppFunction: o usuário executa uma função de criação de playlist em um app de música, transmitindo um contexto como "melhores álbuns de jazz de 2026" como a consulta para gerar e iniciar o conteúdo imediatamente.
  • Fluxos de trabalho entre apps
    • Comando do usuário: "Encontre a receita de macarrão no e-mail da Lisa e adicione os ingredientes à minha lista de compras".
    • Ação 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.
  • Agenda e programação
    • Comando 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 AppFunction: o app agente aprovado invoca a função "criar evento" do app de calendário, analisando o contexto relevante, como "próxima segunda-feira" e "18h", para criar a entrada sem que o usuário precise abrir o calendário manualmente.

Como as AppFunctions funcionam

O AppFunctions é um recurso da plataforma Android 16 e uma biblioteca Jetpack (link em inglês) que permite que os apps exponham funções específicas para chamadores, como apps de agentes, para acessar e executar no dispositivo.

O diagrama a seguir ilustra o fluxo típico de como as AppFunctions são compartilhadas por apps com um agente e executadas posteriormente. É provável que os agentes considerem as ferramentas MCP remotas do lado do servidor e as AppFunctions locais ao processar solicitações do usuário. O fluxo detalhado para usar AppFunctions locais é o seguinte:

  • Declaração AppFunction: o app Android é criado para expor as AppFunctions, 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. Esse arquivo é usado pelo SO Android para indexar as AppFunctions disponíveis.
  • Recuperação de metadados: o agente pode recuperar metadados de AppFunction consultando-os.
  • Seleção e execução de AppFunction: com base nos comandos do usuário, o agente seleciona e executa a AppFunction adequada com os parâmetros apropriados.
Diagrama mostrando o fluxo típico das AppFunctions, desde a exposição do app até a execução do agente.
Figura 1: o fluxo típico de como as AppFunctions são expostas e executadas por um agente.

A biblioteca AppFunctions do Jetpack simplifica a exposição da funcionalidade do app. Com o processador de anotações, os desenvolvedores anotam as funções que querem expor. Os chamadores podem descobrir e invocar essas funções indexadas usando AppFunctionManager.

Antes de invocar uma função, os chamadores precisam verificar se o dispositivo é compatível com o recurso AppFunctions tentando recuperar uma instância de AppFunctionManager. Quando for possível, os chamadores 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ário o android.permission.EXECUTE_APP_FUNCTIONS permission.

Não é necessário que o app verifique se o recurso AppFunction é compatível. Isso é processado automaticamente na biblioteca Jetpack. Por exemplo, AppFunctionManager pode verificar se o recurso é compatível ou não.

Confira um exemplo de AppFunctions para um app de anotações com recursos para criar, editar e listar observações:

/**
 * A note app's [AppFunction]s.
 */
class NoteFunctions(
    private val noteRepository: NoteRepository
) {
    /**
     * Lists all available notes.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun listNotes(appFunctionContext: AppFunctionContext): List<Note>? {
        return noteRepository.appNotes.ifEmpty { null }?.toList()
    }

    /**
     * Adds a new note to the app.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param title The title of the note.
     * @param content The note's content.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createNote(
        appFunctionContext: AppFunctionContext,
        title: String,
        content: String
    ): Note {
        return noteRepository.createNote(title, content)
    }

    /**
     * Edits a single note.
     *
     * @param appFunctionContext The context in which the AppFunction is executed.
     * @param noteId The target note's ID.
     * @param title The note's title if it should be updated.
     * @param content The new content if it should be updated.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun editNote(
        appFunctionContext: AppFunctionContext,
        noteId: Int,
        title: String?,
        content: String?,
    ): Note? {
        return noteRepository.updateNote(noteId, title, content)
    }
}

/**
 * A note.
 */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class Note(
    /** The note's identifier */
    val id: Int,
    /** The note's title */
    val title: String,
    /** The note's content */
    val content: String
)
AppFunctionsApiSnippets.kt

Perguntas frequentes

A seção a seguir aborda perguntas frequentes sobre o AppFunctions.

P: Sou desenvolvedor de apps. Posso implementar o AppFunctions hoje?

R: Sim, é possível implementar e testar AppFunctions no seu app seguindo as orientações detalhadas nas seções anteriores.

P: Implementei AppFunctions no meu app. Por que meu agente de sistema não consegue acessá-las?

R: AppFunctions é um recurso experimental. Para avaliar cuidadosamente a qualidade da experiência geral durante essa fase experimental, apenas um número limitado de apps e agentes do sistema podem acessar todo o pipeline.

Pergunta: estou desenvolvendo um agente. Posso acessar AppFunctions fornecidas por apps?

R: Seu agente de teste pode acessar o AppFunctions em um ambiente de desenvolvimento. Durante essa fase experimental, apenas um número limitado de agentes do sistema pode acessar e executar AppFunctions em produção.

P: Quais agentes do sistema têm acesso ao AppFunctions?

A: apenas um número limitado de agentes do sistema pode acessar todo o pipeline enquanto as AppFunctions estão em fase experimental.

P: Como posso preparar meu app para a disponibilidade geral do AppFunctions?

R: considere quais recursos do app você quer expor à automação de agentes. Você pode implementar o AppFunctions no seu app. Para 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.

P: Posso ter acesso antecipado à experiência de desenvolvedor agêntico de ponta a ponta?

R: estamos realizando um Programa de Acesso Antecipado (EAP, na sigla em inglês) para integrar apps selecionados e testar a experiência completa do desenvolvedor necessária para lançar o AppFunctions em produção no Android. Registre seu interesse em integrar suas AppFunctions usando este formulário de inscrição no PAA. Ao registrar seu interesse, você NÃO recebe acesso automático à integração completa. Vamos enviar um e-mail se o app for selecionado para o EAP ou para avisar quando as AppFunctions estiverem disponíveis ao público.

P: Como posso enviar feedback sobre o AppFunctions?

R: Você pode enviar feedback sobre a API registrando um problema e demonstrando interesse no formulário do Programa de acesso antecipado.