AppFunctions est une API de plate-forme Android avec une bibliothèque Jetpack associée pour simplifier l'intégration d'Android MCP. Elle permet à vos applications de se comporter comme des serveurs MCP sur l'appareil, en fournissant des fonctions qui servent d'outils pour les fonctionnalités proactives, ainsi que pour les agents et les assistants, comme Google Gemini. Depuis mai 2026, l'intégration d'AppFunctions à Gemini est en version preview privée avec des testeurs de confiance. Vous pouvez commencer à préparer vos applications dès maintenant pour utiliser AppFunctions et les outils de développement.
En définissant ces AppFunctions, vous permettez à votre application de fournir des services, des données et des actions au registre intégré à l'OS Android, ce qui permet aux utilisateurs d'effectuer des tâches via des agents 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 (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.
AppFunctions est disponible sur les appareils équipés d'Android 16 ou version ultérieure.
Exemples de cas d'utilisation
Les AppFunctions fournissent un mécanisme puissant pour automatiser les tâches et simplifier les interactions utilisateur. En ouvrant les fonctionnalités de votre application, vous permettez aux utilisateurs d'atteindre des objectifs complexes en langage naturel, ce qui remplace souvent la nécessité d'une navigation manuelle étape par étape avec 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 de récupérer mon colis au travail aujourd'hui à 17 h".
- Action AppFunction : L'appelant identifie l'application de gestion des tâches pertinente 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.
/** * Create a new task or reminder with a title, due time, and location. * * @param context The execution context provided by the system. * @param title The descriptive title of the task (e.g., "Pick up my package"). * @param dueDateTime The specific date and time when the task should be completed. * @param location The physical location associated with the task (e.g., "Work"). * @return The created Task */ @AppFunction(isDescribedByKDoc = true) suspend fun createTask( context: AppFunctionContext, title: String, dueDateTime: LocalDateTime? = null, location: String? = null ) : TaskMultimé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 pour 2026" comme requête pour générer immédiatement la playlist.
/** * Create a new music playlist based on a natural language query. * * @param context The execution context provided by the system. * @param query The description used to generate the playlist (e.g., "top jazz albums from 2026"). * @return The final created playlist based on songs. */ @AppFunction(isDescribedByKDoc = true) suspend fun createPlaylistFromQuery( context: AppFunctionContext, query: String ): PlaylistWorkflows inter-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.
/** * Search for emails matching a query or sender name to retrieve content like recipes. * * @param context The execution context provided by the system. * @param query The search term or contact name (e.g., "Lisa noodle recipe"). * @return A list of matching email summaries containing the requested information. */ @AppFunction(isDescribedByKDoc = true) suspend fun searchEmails( context: AppFunctionContext, query: String ): List<EmailSummary> /** * Add a list of items or ingredients to the user's active shopping list. * * @param context The execution context provided by the system. * @param items The names of the ingredients or products to add to the list. * @return The final shopping list with new items added */ @AppFunction(isDescribedByKDoc = true) suspend fun addItemsToShoppingList( context: AppFunctionContext, items: List<String> ): ShoppingListAgenda 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.
/** * Schedule a new event on the user's primary calendar. * * @param context The execution context provided by the system. * @param title The name of the calendar event (e.g., "Mom's birthday party"). * @param startDateTime The specific date and time the event is scheduled to begin. * @return The created Event object. */ @AppFunction(isDescribedByKDoc = true) suspend fun createCalendarEvent( context: AppFunctionContext, title: String, startDateTime: LocalDateTime ): Event
Fonctionnement des AppFunctions
Le diagramme suivant illustre le flux typique de partage des AppFunctions par les applications avec un agent, puis de 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 utiliser les AppFunctions afin de rendre ses fonctionnalités disponibles, 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. Le système d'exploitation Android utilise ce fichier 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 prompts de l'utilisateur, l'agent sélectionne et exécute l'AppFunction appropriée avec les paramètres appropriés.
La bibliothèque Jetpack AppFunctions simplifie l'exposition des fonctionnalités de votre application.
Avec le processeur d'annotation, vous annotez les fonctions que vous souhaitez mettre à la disposition des agents. 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_FUNCTIONSpermission.
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 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
)
Exemples, compétence et agent de test
Nous avons mis à votre disposition les éléments suivants pour vous aider à développer vos compétences en matière d'AppFunctions :
- Explorez l'exemple AppFunctions pour vérifier et découvrir comment tout fonctionne sur vos appareils.
- La compétence AppFunctions découvre et recommande les fonctionnalités de votre application qui pourraient être implémentées en tant qu'AppFunctions. Elle peut également implémenter et affiner les AppFunctions existantes pour vous.
- Pour les tests de bout en bout, utilisez l'exemple d'application d'agent.
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.
Quelle est la différence entre les AppFunctions et le protocole MCP ?
Les deux permettent aux agents d'IA d'orchestrer des outils, mais présentent des différences importantes en termes d'architecture, de latence et d'efforts requis de la part des développeurs. Les AppFunctions sont des hooks intégrés au niveau du système d'exploitation, exclusifs à Android et qui s'exécutent localement. En revanche, un serveur MCP standard est une solution indépendante de la plate-forme qui repose sur l'exécution dans le cloud et les allers-retours réseau.
En bref, le développement avec les AppFunctions vous permet d'utiliser l'état existant de l'application directement sur l'appareil et ne nécessite pas de maintenir des services en dehors de votre application Android.
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 au cours de 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 d'accès anticipé pour intégrer certaines applications dans le test de 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 programme d'accès anticipé. En indiquant que vous êtes intéressé, 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 programme d'accès anticipé 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 d'accès anticipé.