Présentation d'AppFunctions

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 agissent comme des outils à utiliser par des fonctionnalités proactives, ainsi que par des agents et des 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 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 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.

  /**
   * Create a new task or reminder with a title, due time, and location.
   *
   * @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(
      title: String,
      dueDateTime: LocalDateTime? = null,
      location: String? = null,
  ): Task = TODO()
  AppFunctionApiSnippets.kt

• 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 immédiatement la playlist.

  /**
   * Create a new music playlist based on a natural language query.
   *
   * @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(
      query: String,
  ): Playlist = TODO()
  AppFunctionApiSnippets.kt

• Workflows 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 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(
      query: String,
  ): List<EmailSummary> = TODO()
  
  /**
   * Add a list of items or ingredients to the user's active shopping list.
   *
   * @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(
      items: List<String>,
  ): ShoppingList = TODO()
  AppFunctionApiSnippets.kt

• 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.

  /**
   * Schedule a new event on the user's primary calendar.
   *
   * @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(
      title: String,
      startDateTime: LocalDateTime,
  ): Event = TODO()
  AppFunctionApiSnippets.kt

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. En plus des KDocs spécifiques aux fonctions, les développeurs peuvent définir des modèles opérationnels et des contraintes au niveau de l'application dans les métadonnées de l'application pour guider l'orchestration des agents sur plusieurs outils.
• 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 :

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "TaskAppFunctionService",
    appFunctionXmlFileName = "task_app_function_service",
)
abstract class BaseTaskAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var taskRepository: TaskRepository

    /**
     * Creates a task based on [createTaskParams].
     *
     * @param createTaskParams The parameter to describe how to create the task.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createTask(
        createTaskParams: CreateTaskParams,
    ): Task = withContext(Dispatchers.IO) {
        // Developers can use predefined exceptions to let the agent know
        // why it failed.
        if (createTaskParams.title == null && createTaskParams.content == null) {
            throw AppFunctionInvalidArgumentException("Title or content should be non-null")
        }

        val id = taskRepository.createTask(
            createTaskParams.title,
            createTaskParams.content
        )

        return@withContext taskRepository
            .getTask(id)
            ?.toTask()
            ?: throw AppFunctionElementNotFoundException("Task not found for ID = $id")
    }

    // Maps internal TaskEntity
    private fun TaskEntity.toTask() = Task(id = id, title = title, content = description)
}
AppFunctionApiSnippets.kt

/** The parameter to create the task. */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class CreateTaskParams(
    /** The title of the task. */
    val title: String?,
    /** The content of the task. */
    val content: String?,
)

/** The user-created task. */
@AppFunctionSerializable(isDescribedByKDoc = true)
data class Task(
    /** The ID of the task. */
    val id: String,
    /** The title of the task. */
    val title: String,
    /** The content of the task. */
    val content: String,
)
AppFunctionApiSnippets.kt

Exemples, compétences et outils 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.
• Utilisez la compétence d'agent AppFunctions pour accélérer le développement tout au long du cycle de vie en quatre étapes :
  • Découverte : analysez votre base de code pour identifier et recommander des fonctionnalités à forte valeur ajoutée pour l'orchestration de l'IA.
  • Implémentation et configuration : générez des implémentations Kotlin et configurez les métadonnées système et les dépendances de compilation.
  • Amélioration de KDoc : optimisez la documentation des fonctions et des propriétés pour les agents d'IA et Android MCP.
  • Tests et débogage : fournissez des commandes ADB pour l'évaluation et le débogage locaux sur l'appareil.
• Pour les tests et la validation en ligne de commande, utilisez des commandes ADB telles que adb shell cmd app_function ... comme moyen direct et léger de tester l'enregistrement des fonctions , d'inspecter les descriptions des métadonnées et d'exécuter des fonctions sur l'appareil.
• Pour découvrir Android MCP en action et tester des workflows de bout en bout sans avoir besoin de prompts, installez et utilisez l' application Android de l'agent de test AppFunctions sur votre appareil.

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 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 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 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é.