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 pegar 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
  • Solicitação 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 usuário usa a função de pesquisa de um app de e-mail para recuperar o conteúdo. Em seguida, ele extrai os ingredientes relevantes e invoca a 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 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.

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 remotas do MCP 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 vai selecionar e executar a AppFunction adequada com os parâmetros apropriados.

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.

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.

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

class NoteFunctions(
  private val noteRepository: NoteRepository
) {
    /**
     * A note.
     *
     * @param id The note's ID.
     * @param title The note's title.
     * @param content The note's content.
     */
    @AppFunctionSerializable(isDescribedByKDoc = true)
    data class Note(val id: Int, val title: String, val content: String)

    /**
     * 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 if (noteRepository.appNotes.isEmpty()) null else viewModel.appNotes
    }

    /**
     * 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 new 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: String,
      title: String?,
      content: String,
    ): Note? {
        return noteRepository.updateNote(noteId, title, content)
    }
}