Présentation d'AppFunctions

Les AppFunctions permettent à votre application Android de partager des fonctionnalités spécifiques que le système et divers agents et assistants d'IA peuvent découvrir et invoquer. En définissant ces fonctions, vous permettez à votre application de fournir des services, des données et des actions à l'OS Android, ce qui permet aux utilisateurs d'effectuer des tâches grâce à des agents d'IA et des interactions au niveau du système.

Les AppFunctions sont l'équivalent mobile des outils du Model Context Protocol (MCP). Alors que MCP standardise traditionnellement la façon dont les agents se connectent aux outils côté serveur, AppFunctions fournit le même mécanisme pour les applications Android. Cela vous permet d'exposer les fonctionnalités de votre application en tant qu'"outils" orchestrables que les applications autorisées (appelants) peuvent découvrir et exécuter pour répondre aux intentions des utilisateurs. Les appelants doivent disposer de l'autorisation EXECUTE_APP_FUNCTIONS pour découvrir et exécuter des AppFunctions. Ils peuvent inclure des agents, des applications et des assistants IA tels que Gemini.

Les AppFunctions fonctionnent avec les appareils équipés d'Android 16 ou version ultérieure.

Exemples d'utilisation

Les AppFunctions constituent un mécanisme puissant pour automatiser les tâches et simplifier les interactions utilisateur. En exposant les capacités de votre application, vous permettez aux utilisateurs d'atteindre des objectifs complexes en langage naturel, en évitant souvent d'avoir à naviguer manuellement dans votre UI, étape par étape.

Les scénarios suivants illustrent comment AppFunctions peut être utilisé pour générer des expériences dans différentes catégories d'applications :

• Gestion des tâches et productivité
  • Demande de l'utilisateur : "Rappelle-moi de récupérer mon colis au travail aujourd'hui à 17h".
  • Action AppFunction : l'appelant identifie l'application de gestion des tâches appropriée et appelle une fonction pour créer une tâche, en renseignant automatiquement les champs "Titre", "Heure" et "Lieu" en fonction de la requête de l'utilisateur.
• Multimédia et divertissement
  • Demande de l'utilisateur : Crée une playlist avec les meilleurs albums de jazz de cette année.
  • Action AppFunction : l'appelant exécute une fonction de création de playlist dans une application musicale, en transmettant un contexte tel que "meilleurs albums de jazz de 2026" comme requête pour générer et lancer le contenu immédiatement.
• Workflows multi-applications
  • Requête de l'utilisateur : Trouve la recette de nouilles dans l'e-mail de Lisa et ajoute les ingrédients à ma liste de courses.
  • Action AppFunction : cette requête utilise des fonctions provenant de plusieurs applications. Tout d'abord, l'appelant utilise la fonction de recherche d'une application de messagerie pour récupérer le contenu. Il extrait ensuite les ingrédients concernés et appelle la fonction d'une application de liste de courses pour remplir la liste de l'utilisateur.
• Agenda et planification
  • Demande de l'utilisateur : Ajoute l'anniversaire de maman à mon agenda pour lundi prochain à 18h.
  • Action AppFunction : l'application agentique approuvée appelle la fonction "créer un événement" de l'application Agenda, en analysant le contexte pertinent tel que "lundi prochain" et "18h" pour créer l'entrée sans que l'utilisateur ait besoin d'ouvrir manuellement l'agenda.

Fonctionnement d'AppFunctions

AppFunctions est une fonctionnalité de la plate-forme Android 16 et une bibliothèque Jetpack associée qui permet aux applications d'exposer des fonctions spécifiques pour que les appelants, tels que les applications d'agent, puissent y accéder et les exécuter sur l'appareil.

Le schéma suivant illustre le flux typique de partage des AppFunctions par les applications avec un agent, puis leur exécution. Les agents sont susceptibles de prendre en compte à la fois les outils MCP à distance côté serveur et les AppFunctions locales lorsqu'ils traitent les requêtes des utilisateurs. Voici le déroulement détaillé de l'utilisation des AppFunctions locales :

• Déclaration AppFunction : l'application Android est conçue pour exposer ses AppFunctions, telles que "Créer une note" ou "Envoyer un message".
• Génération de schéma : la bibliothèque Jetpack AppFunctions génère un fichier de schéma XML qui liste toutes les AppFunctions déclarées dans l'application. Ce fichier est utilisé par l'OS Android pour indexer les AppFunctions disponibles.
• Récupération des métadonnées : l'agent peut récupérer les métadonnées AppFunction en les interrogeant.
• Sélection et exécution d'AppFunction : en fonction des requêtes des utilisateurs, l'agent sélectionne et exécute l'AppFunction appropriée avec les paramètres adéquats.

La bibliothèque Jetpack AppFunctions simplifie l'exposition des fonctionnalités de votre application. Avec le processeur d'annotation, les développeurs annotent les fonctions qu'ils souhaitent exposer. Les appelants peuvent ensuite découvrir et appeler ces fonctions indexées à l'aide de AppFunctionManager.

Votre application n'a pas besoin de vérifier si la fonctionnalité AppFunction est prise en charge. Cette vérification est gérée automatiquement dans la bibliothèque Jetpack. Par exemple, AppFunctionManager peut vérifier si la fonctionnalité est prise en charge.

Voici un exemple d'AppFunctions pour une application de prise de notes avec des fonctionnalités permettant de créer, de modifier et de lister des notes.

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)
    }
}