Présentation d'AppFunctions

Les AppFunctions permettent à votre application Android de partager des fonctionnalités spécifiques que le système, ainsi que divers agents et assistants d'IA, peuvent découvrir et appeler. En définissant ces fonctions, vous permettez à votre application de fournir des services, des données et des actions au système d'exploitation Android, ce qui permet aux utilisateurs d'effectuer des tâches via 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 le MCP normalise traditionnellement la façon dont les agents se connectent aux outils côté serveur, les AppFunctions fournissent 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 intents des utilisateurs. Les appelants doivent disposer de l'autorisation EXECUTE_APP_FUNCTIONS pour découvrir et exécuter les AppFunctions. Ils peuvent inclure des agents, des applications, et des assistants d'IA comme Gemini.

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

Exemples d'utilisation

Les AppFunctions fournissent un mécanisme puissant pour automatiser les tâches et simplifier les interactions utilisateur. En exposant les fonctionnalité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 interface utilisateur.

Les scénarios suivants illustrent comment les AppFunctions peuvent être utilisées pour améliorer l'expérience dans différentes catégories d'applications :

  • Gestion des tâches et productivité
    • Requête utilisateur : "Rappelle-moi d'aller chercher mon colis au travail aujourd'hui à 17 h".
    • 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 remplissant automatiquement les champs de titre, d'heure et de lieu en fonction du prompt de l'utilisateur.
  • Multimédia et divertissement
    • Requête 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 immédiatement le contenu.
  • Workflows entre applications
    • Requête 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 de plusieurs applications. Tout d'abord, l'appelant utilise la fonction de recherche d'une application de messagerie pour récupérer le contenu. Ensuite, il extrait les ingrédients pertinents et appelle la fonction d'une application de liste de courses pour remplir la liste de l'utilisateur.
  • Agenda et planification
    • Requête utilisateur : "Ajoute l'anniversaire de maman à mon agenda pour lundi prochain à 18h".
    • Action AppFunction : l'application agentive 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 des 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 agentives, 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 lors du traitement des requêtes utilisateur. Le flux détaillé d'utilisation des AppFunctions locales est le suivant :

  • 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 le système d'exploitation 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 AppFunction : en fonction des prompts utilisateur, l'agent sélectionne et exécute l'AppFunction appropriée avec les paramètres appropriés.
Diagramme montrant le flux typique des AppFunctions, de l'exposition de l'application à l'exécution de l'agent.
Figure 1 : Flux typique d'exposition et d'exécution des AppFunctions par un agent.

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.

Avant d'appeler une fonction, les appelants doivent vérifier que l'appareil est compatible avec la fonctionnalité AppFunctions en tentant de récupérer une instance de AppFunctionManager. Une fois la compatibilité établie, les appelants peuvent vérifier si une fonction spécifique est activée dans une application cible à l'aide de isAppFunctionEnabled(packageName, functionId). L'interrogation de l'état des fonctions dans d'autres packages nécessite l' android.permission.EXECUTE_APP_FUNCTIONS permission.

Votre application n'a pas besoin de vérifier si la fonctionnalité AppFunction est compatible. Cette opération est gérée automatiquement dans la bibliothèque Jetpack. Par exemple, AppFunctionManager peut vérifier si la fonctionnalité est compatible ou non.

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

/**
 * 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

Questions fréquentes

La section suivante répond aux questions fréquentes sur les AppFunctions.

Je suis développeur d'applications. Puis-je implémenter des AppFunctions dès aujourd'hui ?

Oui, il est possible d'implémenter et de tester des AppFunctions dans votre application en suivant les instructions détaillées dans les sections précédentes.

J'ai implémenté des AppFunctions dans mon application. Pourquoi mon agent système ne peut-il pas y accéder ?

Les AppFunctions sont une fonctionnalité expérimentale. Pour évaluer soigneusement la qualité de l'expérience globale pendant cette phase expérimentale, seul un nombre limité d'applications et d'agents système peuvent accéder à l'ensemble du pipeline.

Comment préparer mon application à la disponibilité générale des AppFunctions ?

Réfléchissez aux fonctionnalités de votre application que vous souhaitez exposer à l'automatisation agentive. Vous pouvez implémenter des AppFunctions dans votre application. Pour ce faire, suivez les étapes décrites dans les sections précédentes de cette page et vérifiez qu'elles sont enregistrées sur l'appareil en appelant adb shell cmd app_function list-app-functions.

Puis-je bénéficier d'un accès anticipé à l'expérience de développement agentive de bout en bout ?

Nous menons un programme en accès anticipé (PAA) pour intégrer certaines applications afin de tester l'expérience de développement de bout en bout requise pour lancer les AppFunctions en production sur Android. Vous pouvez indiquer que vous souhaitez intégrer vos AppFunctions en remplissant ce formulaire d'inscription au PAA. En vous inscrivant, vous n'obtenez PAS automatiquement l'accès à l'intégration complète. Nous vous enverrons un e-mail si votre application est sélectionnée pour le PAA ou pour vous informer lorsque les AppFunctions seront disponibles publiquement.

Comment puis-je envoyer des commentaires sur les AppFunctions ?

Vous pouvez envoyer des commentaires sur l'API en signalant un problème et en indiquant que vous souhaitez participer au programme en accès anticipé.