Tutoriels

Créer des applications Android intelligentes : intégrer le système d'intelligence d'Android à l'aide d'AppFunctions

Temps de lecture : 6 min
Voir le profil de Ben Weiss
Ben Weiss Ingénieur Developer Relations

Bienvenue dans la série d'articles de blog Créer des applications Android intelligentes, dans laquelle nous transformons une application Android de base en une expérience personnalisée, intelligente et agentive. Dans notre article précédent, nous avons vu comment utiliser Firebase AI Logic pour créer des fonctionnalités d'IA hybrides et hébergées dans le cloud.

Les interfaces utilisateur mobiles traditionnelles sont idéales pour les tâches ciblées et pratiques, et le système d'intelligence Android introduit des fonctionnalités complémentaires pour faciliter encore plus les actions complexes en plusieurs étapes. En complétant les interfaces utilisateur traditionnelles, les AppFunctions offrent un nouveau point d'entrée puissant : un agent privilégié sur l'appareil peut accéder aux fonctionnalités de l'application en arrière-plan. Cela peut être particulièrement utile lorsque les utilisateurs conduisent, marchent ou effectuent d'autres tâches en même temps.

Dans cet article, nous allons vous montrer comment nous avons conçu et intégré ces fonctionnalités dans notre application de planification de voyage, JetPacker, à l'aide d'Android AppFunctions. Nous allons explorer les raisons qui ont motivé nos choix de fonctionnalités, discuter des outils spécialisés que nous avons utilisés pour accélérer le développement et examiner le code qui permet de faire fonctionner le tout.

Concevoir des fonctionnalités prêtes pour l'IA : faire des choix qui comptent pour vos utilisateurs

Pour sélectionner les fonctionnalités à fournir au système d'intelligence, nous avons recherché des tâches pour lesquelles une commande vocale ou textuelle est objectivement plus rapide que d'appuyer sur des écrans. Cet enregistrement d'écran côte à côte illustre parfaitement ce contraste : à gauche, un utilisateur appuie sur plusieurs écrans pour enregistrer une dépense ; à droite, la même tâche est effectuée instantanément en arrière-plan via un agent privilégié.

Notre premier choix s'est porté sur le suivi des dépenses. Enregistrer une dépense de café pendant un voyage nécessite généralement plusieurs actions : déverrouiller le téléphone, ouvrir l'application, trouver le voyage actif, accéder à l'onglet des dépenses, appuyer sur le bouton d'ajout, prendre une photo du reçu et vérifier le résultat. En fournissant les fonctionnalités addExpense et getExpenses en tant qu'AppFunctions, l'agent système se charge des tâches complexes. Lorsque l'utilisateur dit "Ajoute une dépense de 5 $ pour un café à mon voyage à Paris", l'agent recherche automatiquement l'ID du voyage en arrière-plan et insère la dépense, en ignorant complètement le flux d'UI manuel.

Nous avons également donné la priorité à la gestion des itinéraires. Pour trouver l'activité suivante sur un itinéraire de voyage chargé, il faut généralement faire défiler une vue chronologique dense. En fournissant getItinerary et addItineraryEvent au système, l'utilisateur peut simplement demander "Que dois-je faire ensuite à Paris ?" et obtenir une réponse immédiate.

Enfin, nous nous sommes concentrés sur la prise de notes mains libres. Saisir des rappels ou des notes tout en marchant dans une rue bondée est difficile et dangereux. En exposant une fonctionnalité de note vocale, l'utilisateur peut dire "Le vol était incroyable, j'ai vu un magnifique coucher de soleil et j'ai réussi à bien dormir". L'agent privilégié transcrit et enregistre automatiquement cette note directement dans la base de données de voyage à l'aide de l'AppFunction addVoiceNote.

Android MCP optimisé par AppFunctions

Toute cette expérience est basée sur Android MCP. Dans cette conception, l'application agit en tant que serveur MCP local. Plutôt que d'utiliser des API distantes, vous fournissez les fonctionnalités de votre application directement au système d'intelligence sur l'appareil.

Android AppFunctions est l'API qui concrétise ce concept. Il lit les fonctions Kotlin annotées et les compile en définitions d'outils sécurisées et en bac à sable que l'agent privilégié peut découvrir et appeler localement sur l'appareil.

Android MCP diagram.png
Diagramme mettant en évidence la coordination des AppFunctions par nos applications, la plate-forme Android et les agents système.

Dans le modèle MCP Android, votre application agit comme un serveur MCP local qui expose des outils structurés, tandis que la plate-forme Android sert de registre d'outils central. Côté client MCP, les applications d'agent sont enregistrées auprès du système d'intelligence après avoir reçu des autorisations privilégiées du système pour accéder au registre.

Lorsqu'un utilisateur interagit avec un agent enregistré, son LLM détermine si la requête peut être traitée par une AppFunction, interroge les métadonnées de la plate-forme et exécute les fonctions enregistrées appropriées en arrière-plan. Cette conception client-serveur MCP locale vous offre un contrôle total : vous choisissez exactement les fonctionnalités accessibles à l'agent, tout en préservant la confidentialité du reste des données de votre application.

Comment nous avons accéléré le développement grâce aux compétences Android

Pour simplifier le processus d'intégration, nous avons utilisé la compétence de développement AppFunctions. La compétence de développement AppFunctions est un compagnon de développement complet. Il nous a guidés tout au long du cycle de vie : mappage des classes de données Kotlin pour sérialiser les paramètres, génération des points d'entrée Service nécessaires, affinement de notre documentation KDoc pour s'assurer que le LLM comprend les limites des paramètres et configuration de tests automatisés à l'aide d'ADB.

Fournir des fonctionnalités d'application au système d'intelligence

Assez de théorie, passons à l'implémentation.

Configuration et configuration des dépendances

Nous commençons par ajouter les dépendances AppFunctions. Une pour l'API et une pour le compilateur Kotlin Symbol Processing.

implementation("androidx.appfunctions:appfunctions:1.0.0-alpha10")
ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha10")

Modéliser des types de données personnalisés

Tout objet personnalisé échangé avec l'agent doit être annoté avec @AppFunctionSerializable. Dans notre fichier TripSerializable.kt, nous définissons notre modèle de données de trajet :

@AppFunctionSerializable(isDescribedByKDoc = true)
data class TripSerializable(
    /** The trip's unique identifier. */
    val id: String,
    /** The trip's title. */
    val title: String,
    /** The trip's destination location. */
    val location: String,
    /** The trip's start date in milliseconds. */
    val startDate: Long,
    /** The trip's end date in milliseconds. */
    val endDate: Long,
    /** A list of participants. */
    val participants: List<String>,
)

Fournir des fonctionnalités à l'aide de l'annotation @AppFunction

Ensuite, la compétence a écrit les fonctions Kotlin qui effectuent les requêtes de base de données et les a annotées avec @AppFunction. Nous pouvons l'afficher dans searchTrip :

/**
 * Looks for trips based on optional filters like id, title (name), location, and dates.
 *
 * @param id The unique identifier of the trip.
 * @param title The title or name of the trip.
 * @param location The destination location.
 * @param startDate The minimum start date in milliseconds.
 * @param endDate The maximum end date in milliseconds.
 * @return A list of trips matching the filters.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun searchTrip(
    id: String? = null,
    title: String? = null,
    location: String? = null,
    startDate: Long? = null,
    endDate: Long? = null
): List<TripSerializable> {
    return withContext(Dispatchers.IO) {
    // implementation
}

Comme les AppFunctions s'exécutent par défaut sur le thread UI, nous utilisons withContext(Dispatchers.IO) pour passer à un coordinateur d'arrière-plan. Nous affinons également notre KDoc pour utiliser des verbes impératifs clairs et spécifier des contraintes de paramètres. Cette documentation est compilée directement dans le schéma de l'outil, que l'agent privilégié utilise pour résoudre les paramètres et gérer les erreurs d'exécution.

Point d'entrée du service et intégration de Hilt

Pour enregistrer ces caractéristiques auprès du système d'intelligence, nous créons une classe de base abstraite qui étend AppFunctionService. Nous l'annotons avec @AppFunctionServiceEntryPoint :

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "JetPackerAppFunctionService",
    appFunctionXmlFileName = "jetpacker_app_function_service"
)
abstract class BaseJetPackerAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var tripDao: TripDao
    // DAOs and database references are injected here...
}

Lors de la compilation, KSP génère la sous-classe de service concrète finale, JetPackerAppFunctionService, comme déclaré avec le paramètre serviceName. Nous enregistrons également app_metadata.xml dans le fichier manifeste de l'application. Ce fichier fournit des règles opérationnelles globales pour les AppFunctions déclarées de JetPacker.

Tester et valider vos AppFunctions

Une fois l'implémentation terminée, vous devez vérifier que vos AppFunctions sont enregistrées et fonctionnent correctement.

Sur les appareils ou émulateurs exécutant Android 17 ou une version ultérieure, vous pouvez utiliser des commandes ADB depuis votre terminal pour lister et appeler vos fonctions. L'exécution de adb shell cmd app_function list-app-functions affiche toutes les fonctions enregistrées pour votre package. Vous pouvez ensuite exécuter une fonction spécifique et tester son intégration à la base de données en exécutant adb shell cmd app_function execute-app-function tout en transmettant une chaîne de paramètres JSON brute.

Au lieu de ces commandes ADB, vous pouvez également utiliser l'agent de test AppFunctions pour inspecter votre configuration, lister et exécuter des AppFunctions, et même voir comment vos AppFunctions se comportent dans un flux de conversation réel.

Conclure

Lorsque vous réfléchissez aux fonctionnalités d'application qui peuvent être fournies au système d'intelligence à l'aide d'AppFunctions, vous devez légèrement modifier votre façon de penser au code et à la documentation. AppFunctions vous permet d'utiliser ce nouveau modèle d'interaction pour les applications, qui permet d'utiliser un agent pour accéder aux fonctionnalités de l'application.

Tout d'abord, la compétence de développement AppFunctions est un outil essentiel du cycle de vie, qui vous aide à découvrir des fonctionnalités, à implémenter et à affiner les AppFunctions pour vos applications. Deuxièmement, les commentaires KDoc sont un élément d'API compilé. Des descriptions de paramètres claires ont un impact direct sur la précision d'exécution de l'agent système. Enfin, Android MCP permet une exécution locale, ce qui permet aux applications de collaborer en toute sécurité avec des agents IA.

En fournissant des fonctionnalités d'application via AppFunctions, vous préparez votre application pour le système d'intelligence. Dites-nous comment vous adaptez vos applications à l'ère agentique.

En savoir plus

Découvrez les autres parties de cette série d'articles de blog :
Partie 1 : présentation de l'application et vue d'ensemble.
Partie 2 : intelligence sur l'appareil. Découvrez en détail les API d'IA générative de ML Kit et Gemini Nano pour créer des fonctionnalités axées sur la confidentialité, comme la synthèse d'itinéraires, l'analyse de reçus et le traitement audio local.
Partie 3 : Raisonnement hybride et cloud. Découvrez comment utiliser Firebase AI Logic pour ancrer les réponses des LLM dans des données réelles, comme Google Maps et le contexte Web.
Partie 4 (cet article) : Intégration de systèmes. Intégrer le système d'intelligence Android à l'aide d'AppFunctions.
Partie 5 (bientôt disponible) : Workflows agentiques intégrés à l'application. Étendre l'application avec un assistant de réservation de bout en bout optimisé par A2UI et ADK.

Vous souhaitez en savoir plus sur le développement Android ? Suivez Android Developers sur YouTube ou LinkedIn.

Tous les extraits de code de cet article de blog sont soumis à l'avis de droits d'auteur suivant :

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
Écrit par :
Continuer la lecture