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

Bienvenue dans la série d'articles de blog "Créer des applications Android intelligentes", dans laquelle nous prenons une application Android de base et la transformons en une expérience personnalisée, intelligente et agentique. Dans notre précédent article, nous avons exploré comment tirer parti de 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 pratiques ciblées, et le système d'intelligence Android introduit des fonctionnalités complémentaires pour simplifier encore plus les actions complexes en plusieurs étapes. En complément des interfaces utilisateur traditionnelles, AppFunctions fournit 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 voyages, JetPacker, à l'aide d'Android AppFunctions. Nous allons explorer la logique qui sous-tend 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 à tout cela de fonctionner.

Concevoir des fonctionnalités compatibles avec l'IA : faire des choix importants pour vos utilisateurs

Pour sélectionner les fonctionnalités à fournir au système d'intelligence, nous avons recherché les tâches pour lesquelles une commande vocale ou textuelle est objectivement plus rapide que d'appuyer sur l'écran. Dans cet enregistrement d'écran côte à côte, vous pouvez voir ce contraste parfaitement : à 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 a été le suivi des dépenses. Enregistrer une dépense de café pendant un voyage nécessite généralement plusieurs appuis : déverrouiller le téléphone, ouvrir l'application, trouver le voyage actif, accéder à l'onglet des dépenses, appuyer sur le bouton "Ajouter", 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 gère le travail lourd. Lorsque l'utilisateur dit "Ajoute une dépense de cinq euros pour un café à mon voyage à Paris", l'agent recherche automatiquement l'ID de voyage approprié en arrière-plan et insère la dépense, en ignorant complètement le flux manuel de l'interface utilisateur.

Nous avons également accordé la priorité à la gestion des itinéraires. Pour trouver l'activité suivante dans 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 "Qu'est-ce que je fais ensuite à Paris ?" et obtenir une réponse immédiate.

Enfin, nous nous sommes concentrés sur la capture de notes en mode mains libres. Il est difficile et dangereux de taper des rappels ou des notes en marchant dans une rue passante. L'exposition d'une fonctionnalité de note vocale permet à l'utilisateur de dire "Le vol était incroyable, j'ai vu un magnifique coucher de soleil et j'ai réussi à bien dormir", et l'agent privilégié le transcrit et l'enregistre automatiquement directement dans la base de données de voyage à l'aide de l'AppFunction addVoiceNote.

Android MCP optimisé par AppFunctions

L'ensemble de cette expérience repose sur Android MCP. Dans cette conception, l'application agit comme un serveur MCP local. Au lieu d'API à distance, vous fournissez directement les fonctionnalités de votre application au système d'intelligence sur l'appareil.

Android AppFunctions est l'API qui donne vie à ce concept. Elle 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.

Dans le modèle Android MCP, 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. Du 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 géré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, en gardant le reste des données de votre application privées.

Comment nous avons accéléré le développement avec les compétences Android

Pour simplifier le processus d'intégration, nous avons tiré parti de la compétence de développement AppFunctions. La compétence de développement AppFunctions est un compagnon de développement complet. Elle nous a guidés tout au long du cycle de vie : mapper les classes de données Kotlin pour sérialiser les paramètres, générer les points d'entrée Service nécessaires, affiner notre documentation KDoc pour nous assurer que le LLM comprend les limites des paramètres et configurer des 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 annote avec @AppFunction. Nous pouvons le voir 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
}

Étant donné qu'AppFunctions s'exécute par défaut sur le thread UI, nous utilisons withContext(Dispatchers.IO) pour passer à un répartiteur d'arrière-plan. De plus, nous affinons 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 fonctionnalités 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 vérifier vos AppFunctions

Une fois implémenté, 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 les 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 bruts.

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 ajoutées 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, ce 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 de cycle de vie essentiel qui vous aide à découvrir des fonctionnalités, à implémenter et à affiner les AppFunctions pour vos applications. Ensuite, les commentaires KDoc sont un élément d'API compilé ; des descriptions claires des paramètres ont un impact direct sur la précision d'exécution de l'agent système. Enfin, Android MCP fournit une exécution locale qui permet aux applications de collaborer en toute sécurité avec les agents d'IA.

L'ajout de fonctionnalités d'application via AppFunctions prépare votre application au système d'intelligence. Dites-nous comment vous adaptez vos applications à l'ère agentique.

En savoir plus

Consultez 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. Plongez-vous dans les API d'IA générative de ML Kit et Gemini Nano pour créer des fonctionnalités axées sur la confidentialité, telles que 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 LLM dans des données réelles telles que Google Maps et le contexte Web.
Partie 4 (cet article) Intégration de système. Intégration au système d'intelligence Android à l'aide d'AppFunctions.
Partie 5 (à venir) : Flux de travail agentiques dans l'application. Étendez 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 les développeurs Android 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