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 le protocole MCP standardise 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 (appelantes) 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 améliorer l'expérience utilisateur 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 remplissant automatiquement les champs de titre, d'heure et de 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" en tant que requête pour générer et lancer le contenu immédiatement.
  • Workflows multi-applications
    • Demande 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 et d'exécution des AppFunctions par les applications avec un agent. Les agents sont susceptibles de prendre en compte à la fois les outils MCP distants côté serveur et les AppFunctions locales lorsqu'ils traitent les requêtes des utilisateurs. Voici le flux détaillé pour utiliser les 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.
Diagramme illustrant 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 fonctionnalité prise en charge, les appelants peuvent vérifier si une fonction spécifique est activée dans une application cible à l'aide de isAppFunctionEnabled(packageName, functionId). Pour interroger l'état des fonctions dans d'autres packages, vous devez disposer de android.permission.EXECUTE_APP_FUNCTIONS permission.

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 ou non.

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 :

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

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

R : Oui, il est possible d'implémenter et de tester AppFunctions dans votre application en suivant les conseils détaillés dans les sections précédentes.

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

A : Les AppFunctions sont une fonctionnalité expérimentale. Pour évaluer attentivement 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.

Q : Je développe un agent. Puis-je accéder aux AppFunctions fournies par les applications ?

R : Votre agent de test peut accéder à AppFunctions dans un environnement de développement. Pendant cette phase de test, seul un nombre limité d'agents système peuvent accéder aux AppFunctions et les exécuter en production.

Q : Quels agents système ont accès à AppFunctions ?

A : Seul un nombre limité d'agents système peut accéder à l'intégralité du pipeline, tandis que les AppFunctions sont expérimentales.

Q : Comment préparer mon application pour la disponibilité générale d'AppFunctions ?

A : réfléchissez aux fonctionnalités de votre application que vous souhaitez exposer à l'automatisation agentique. Vous pouvez implémenter AppFunctions dans votre application. Pour ce faire, suivez les étapes des 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.

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

R : Nous menons un programme d'accès anticipé pour intégrer certaines applications et tester l'expérience de développement de bout en bout requise pour lancer AppFunctions en production sur Android. Vous pouvez nous indiquer que vous souhaitez intégrer vos AppFunctions en remplissant ce formulaire d'inscription au PAA. En indiquant votre intérêt, vous n'obtenez PAS automatiquement accès à l'intégration complète. Nous vous enverrons un e-mail si votre application est sélectionnée pour le PAE ou pour vous informer de la disponibilité publique des AppFunctions.

Q : Comment puis-je envoyer des commentaires sur AppFunctions ?

R : Vous pouvez nous faire part de vos commentaires sur l'API en signalant un problème et en indiquant votre intérêt dans le formulaire du programme en accès anticipé.