AppFunctions est une API de plate-forme Android accompagnée d'une bibliothèque Jetpack pour simplifier l'intégration MCP Android. Il 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é à OS Android, ce qui permet aux utilisateurs d'accomplir des tâches par le biais d'agents et d'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 sous forme d'"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.
AppFunctions est disponible sur les appareils équipés d'Android 16 ou version ultérieure.
Exemples de cas d'utilisation
Les AppFunctions constituent 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 utilisant le langage naturel, ce qui remplace souvent la navigation manuelle étape par étape dans votre UI.
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 renseignant automatiquement les champs de titre, d'heure et de lieu en fonction de la requête 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
- 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 la playlist immédiatement.
/** * 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
- 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.
/** * 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
- 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.
/** * 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 d'AppFunctions
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 à distance côté serveur et les AppFunctions locales lors du traitement des requêtes utilisateur. Voici le déroulement détaillé de l'utilisation des AppFunctions locales :
- Déclaration AppFunction : l'application Android est conçue pour utiliser 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. L'OS 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 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, vous annotez les fonctions que vous souhaitez rendre disponibles pour les 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 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_FUNCTIONSpermission.
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
)
Questions fréquentes
La section suivante répond aux questions fréquentes sur AppFunctions.
Je suis développeur d'applications. Puis-je implémenter AppFunctions dès aujourd'hui ?
Oui, il est possible d'implémenter et de tester des AppFunctions dans votre application en suivant les conseils détaillés dans les sections précédentes.
Quelle est la différence entre AppFunctions et 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'effort de développement requis. Les AppFunctions sont des hooks intégrés au niveau de l'OS, exclusifs à Android, 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 AppFunctions vous permet d'utiliser l'état de l'application existante directement sur l'appareil et ne vous oblige pas à gérer 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 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 d'AppFunctions ?
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.
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é (PAA) pour intégrer certaines applications afin de 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 lorsque les AppFunctions seront disponibles publiquement.
Comment envoyer des commentaires sur AppFunctions ?
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 d'accès anticipé.