Créer des applications Android intelligentes : workflows agentiques intégrés
Temps de lecture : 9 min
Bienvenue dans la série d'articles de blog "Créer des applications Android intelligentes", dans laquelle vous transformez une application Android de base en une expérience personnalisée, intelligente et agentive. Dans notre article précédent, vous avez appris à vous connecter au système d'intelligence à l'aide d'AppFunctions.
Dans cet article, vous allez apprendre à créer des workflows agentiques autonomes intégrés qui s'exécutent dans le cloud.
Il arrive qu'une tâche soit trop complexe pour une seule session sur l'appareil. Par exemple, réserver un séjour complet implique de coordonner les horaires des vols, de sélectionner des chambres d'hôtel, de réserver des billets de musée et de réserver des restaurants. Si vous exécutez ce processus en plusieurs étapes directement sur un appareil mobile, l'application risque de se fermer et vous risquez de perdre votre progression. La gestion de toutes ces étapes et des identifiants d'API sur un téléphone devient également vite compliquée.
Pour ces workflows longs et en plusieurs étapes, vous pouvez utiliser un backend personnalisé auto-hébergé. Le backend exécute les agents de réservation en arrière-plan, tandis que l'application Android se connecte à la session, visualise la progression et ne demande une intervention de l'utilisateur que si nécessaire.
L'utilisation d'un backend agentique hébergé dans le cloud présente plusieurs avantages :
- Exécution en arrière-plan : les agents de réservation s'exécutent de manière autonome dans le cloud. Ainsi, la progression n'est jamais perdue si l'application mobile passe en arrière-plan ou perd la connexion Internet.
- Orchestration multi-agents complexe : un agent coordinateur peut déléguer des réservations à des sous-agents spécialisés et gérer les dépendances entre eux.
- Rendu de l'interface utilisateur indépendant du client : le backend décrit la structure de l'interface de manière dynamique, ce qui vous permet de mettre à jour la mise en page de l'interface utilisateur sans publier de nouvelle version du client.
En gardant ces avantages à l'esprit, nous avons ajouté un assistant de réservation à Jetpacker qui coordonne les réservations de vols, d'hôtels, de musées et de restaurants. Voyons comment nous avons orchestré un système multi-agents optimisé par l'Agent Development Kit (ADK), avec le protocole d'interaction agent-utilisateur (AG-UI) et le protocole d'interface agent-utilisateur (A2UI) pour envoyer et afficher des fiches interactives de manière native dans Jetpack Compose.
Alimenter des workflows complexes avec des agents ADK
Plutôt que de coordonner manuellement le flux d'orchestration à l'aide de points de terminaison REST personnalisés ou de sockets Web complexes, vous pouvez utiliser l'Agent Development Kit (ADK). Avec l'ADK, vous pouvez définir des agents et les équiper d'outils de fonction Python pour interroger des bases de données et effectuer des réservations.
Voici comment définir un agent simple et l'exécuter à l'aide d'ADK :
# server/main.py
# Note: ADK supports many different coding languages. For now, we use the Python version as it includes support for A2UI which we'll use later in this blog post.
from google.adk import Agent
from google.adk.runners import InMemoryRunner
from google.adk.tools import FunctionTool
# Define custom tools to interact with database
def search_flights(destination: str, date: str) -> list[str]:
# In production, here you would query our flight database and return dynamic results
return ["10:00 AM", "2:00 PM"]
def reserve_flight(flight_time: str) -> str:
# In production, here you would save the reservation transaction
return "Reserved flight at " + flight_time
# Instantiate the booking agent with specialized tools
flight_agent = Agent(
name="Flight Booker",
model="gemini-3.1-flash-lite",
instruction="Help the user search for flights and book a reservation.",
tools=[
FunctionTool(search_flights),
FunctionTool(reserve_flight, require_confirmation=True)
]
)
# Run the agent in memory using a session ID
runner = InMemoryRunner(flight_agent)
async for event in runner.run_async(user_id=user_id, session_id=session_id):
if event.content:
print("Agent said:", event.content)Lorsque vous exécutez un agent à l'aide de cette configuration, ADK gère les étapes d'exécution à votre place. Il suit automatiquement le contexte de la conversation, achemine les messages entre l'utilisateur et le modèle, et exécute les outils enregistrés lorsque le modèle les demande. Vous pouvez ainsi vous concentrer sur l'écriture d'une logique procédurale propre, tandis que le framework gère l'orchestration en arrière-plan.
Pour connecter cet agent de backend à notre application Jetpacker, le serveur doit pouvoir diffuser des mises à jour en temps réel sur l'appareil, ce qui est géré à l'aide du protocole AG-UI. L'agent a également besoin d'un moyen structuré pour décrire et mettre à jour de manière dynamique les composants interactifs (comme les sélecteurs d'options et les plans de salle) sur le téléphone. C'est là qu'intervient le protocole A2UI.
Standardiser la communication entre l'agent et le client avec AG-UI
L'exécution d'agents dans le cloud et l'affichage de l'UI sur Android nécessitent un canal de communication standard. Pour cela, vous utiliserez le protocole AG-UI.
AG-UI est un protocole de couche transport bidirectionnel qui standardise les types de messages entre les agents et les clients d'interface utilisateur. L'agent peut informer le client des événements de cycle de vie, des messages, des appels d'outils et de la gestion de l'état. Le client peut à son tour renvoyer à l'agent des messages texte de l'utilisateur, des résultats d'appels d'outils et des événements d'action personnalisés.
Côté serveur, il génère des mises à jour au format standard des événements envoyés par le serveur (comme event: TEXT_MESSAGE_CONTENT contenant le delta JSON). Sur Android, le SDK Kotlin écoute ce flux et mappe automatiquement les charges utiles aux événements client de type sécurisé :
// BookingAssistantViewModel.kt import com.agui.client.agent.HttpAgent import com.agui.client.agent.HttpAgentConfig import com.agui.core.types.RunAgentInput import com.agui.core.types.UserMessage import com.agui.core.types.TextMessageStartEvent import com.agui.core.types.TextMessageContentEvent import com.agui.core.types.TextMessageEndEvent val config = HttpAgentConfig( agentId = "booking-assistant", threadId = threadId, url = "https://<your-backend-url>" ) val agent = HttpAgent(config, httpClient) // Set up the input with the session thread and user instruction val input = RunAgentInput( threadId = threadId, runId = runId, messages = listOf(UserMessage("Book a flight to Paris")) ) // Run the agent flow and collect lifecycle events agent.runAgentObservable(input) .collect { event -> when (event) { is TextMessageStartEvent -> { /* ... */ } is TextMessageContentEvent -> { /* ... */ } is TextMessageEndEvent -> { // Handle the completed message } } }
Vous pouvez ensuite écrire une UI pour afficher ces différents types d'événements AG-UI standardisés. Vous obtiendrez ainsi l'expérience "chatbot" classique :
Laisser l'agent générer l'UI avec A2UI
Les chatbots traditionnels renvoient généralement du texte brut ou des charges utiles JSON personnalisées. Lors de la création d'interfaces complexes, l'application cliente doit analyser ces charges utiles et les mapper à des écrans prédéfinis spécifiques. Cela crée une dépendance : chaque fois que vous ajoutez une fonctionnalité, modifiez la mise en page ou prenez en charge une nouvelle interaction utilisateur, vous devez mettre à jour l'agent de backend et l'application mobile. Pour cela, vous devez publier une mise à jour de l'application et attendre que les utilisateurs l'installent.
Pour résoudre ce problème, utilisez le protocole A2UI. A2UI permet aux agents de décrire les composants d'UI à afficher dynamiquement sur le client. L'application cliente déclare un catalogue de composants qu'elle accepte, et le serveur envoie une charge utile JSON spécifiant la mise en page et les propriétés des composants :
{
"version": "v0.9",
"updateComponents": {
"surfaceId": "Flight Reservation",
"components": [
{
"id": "flight_option_picker",
"component": "InteractiveOptionPicker",
"properties": {
"prompt": "Select a flight time:",
"options": [
"10:00 AM",
"2:00 PM"
],
"selectedIdx": null,
"confirmBtnText": "Confirm Flight"
}
}
]
}
}Le serveur spécifie les composants du catalogue à afficher ainsi que leurs valeurs de propriété actives, ce qui permet de dissocier clairement les détails de l'implémentation visuelle du client de l'état du workflow de l'agent.
Concevoir le schéma d'UI du backend
Pour que l'agent génère correctement ces charges utiles JSON, il doit savoir quels composants sont disponibles et quelles propriétés ils acceptent.
Pour ce faire, utilisez l'intégration ADK A2UI. Au lieu d'écrire manuellement des instructions de prompt pour chaque composant de notre catalogue, A2uiSchemaManager compile leurs schémas JSON et leurs instructions de mise en page directement dans le prompt système. Cela permet au modèle d'apprendre la structure exacte et les règles de mise en forme qu'il doit suivre pour générer des charges utiles A2UI valides :
# server/main.py
from a2ui.schema.manager import A2uiSchemaManager
from a2ui.schema.constants import VERSION_0_9
from a2ui.schema.catalog import CatalogConfig
from a2ui.basic_catalog.provider import BasicCatalog
# Initialize A2UI Schema Manager with custom booking component catalog
schema_manager = A2uiSchemaManager(
version=VERSION_0_9,
catalogs=[
BasicCatalog.get_config(version=VERSION_0_9),
CatalogConfig.from_path(
name="https://example.com/catalogs/booking_assistant/v1/catalog.json",
catalog_path="booking_catalog.json"
)
]
)
# Compile prompt instructions including the A2UI JSON schema
A2UI_SYSTEM_INSTRUCTION = schema_manager.generate_system_prompt(
role_description="You are a helpful travel booking assistant.",
ui_description="Use InteractiveOptionPicker for choices, SeatSelectionPicker for seat selection...",
include_schema=True,
include_examples=True,
allowed_components=["InteractiveOptionPicker", "SeatSelectionPicker", "BookingStatus"]
)Grâce à cette instruction système générée, le LLM est ancré dans la mise en page du schéma et sait exactement comment formuler les mises à jour des composants que le client Android est capable d'afficher.
Afficher l'A2UI de manière native avec Jetpack Compose
Pour afficher ces arborescences de composants de manière native sur Android, utilisez la nouvelle bibliothèque de moteur de rendu A2UI Jetpack Compose.
Commencez par ajouter les dépendances au fichier build.gradle.kts de notre module :
// android/feature/trip/booking_assistant/build.gradle.kts dependencies { implementation("androidx.a2ui:a2ui-model:1.0.0-alpha01") implementation("androidx.a2ui.compose:compose-runtime:1.0.0-alpha01") implementation("androidx.a2ui.compose:compose-ui:1.0.0-alpha01") implementation("androidx.compose.material3:material3-a2ui:1.0.0-alpha01") }
Chaque classe de composant du catalogue (comme BookingStatusComponent) définit comment mapper les propriétés reçues de la charge utile JSON dans une fonction composable Jetpack Compose.
Enregistrez les composants personnalisés dans un catalogue :
// CustomBookingAssistantCatalog.kt import androidx.a2ui.compose.ui.A2uiCatalog fun bookingAssistantCatalog(): A2uiCatalog { return A2uiCatalog( catalogId = "https://example.com/catalogs/booking_assistant/v1/catalog.json", components = listOf( InteractiveOptionPickerComponent(), SeatSelectionPickerComponent(), BookingStatusComponent() ) ) }
Conseil : Jetpacker implémente des composants personnalisés (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus) adaptés aux flux de réservation. Si votre agent utilise des éléments standards (tels que du texte, des fiches, des boutons, des lignes, des colonnes, des cases à cocher et des sélecteurs de date et d'heure), material3-a2ui fournit également materialA2uiBasicCatalogV1(...), ce qui vous permet d'obtenir des implémentations Material 3 prêtes à l'emploi sans avoir à écrire de composants personnalisés.
Remarque : Pour que le backend et le client mobile restent alignés, ils s'appuient tous deux sur le même ID de définition de catalogue (https://example.com/catalogs/booking_assistant/v1/catalog.json). Si vous ajoutez ou modifiez des propriétés dans le catalogue du backend, vous devez augmenter le numéro de version et mettre à jour la classe de composant Kotlin correspondante pour éviter les erreurs d'analyse.
Dans BookingAssistantViewModel, traitez les messages A2UI à l'aide de A2uiMessageProcessor et mettez à jour nos surfaces actives :
// BookingAssistantViewModel.kt import androidx.lifecycle.ViewModel import androidx.a2ui.model.processor.A2uiSurfaceModel import androidx.a2ui.compose.ui.A2uiMessageProcessor import kotlinx.coroutines.flow.StateFlow class BookingAssistantViewModel : ViewModel() { private val messageProcessor = A2uiMessageProcessor( catalogs = listOf(bookingAssistantCatalog()) ) val activeSurfaces: StateFlow<List<A2uiSurfaceModel>> = messageProcessor.activeSurfaces init { viewModelScope.launch(Dispatchers.Default) { processor.collectMessages() } } // ... }
Sur l'écran Compose, collectez ces surfaces et affichez chacune d'elles à l'aide du composable A2uiSurface officiel de androidx.compose.material3:material3-a2ui. A2uiSurface gère automatiquement l'observation de l'état des composants réactifs, les indicateurs de chargement Material 3, les solutions de remplacement en cas d'erreur et les transitions animées entre les mises à jour :
// BookingAssistantScreen.kt import androidx.compose.runtime.Composable import androidx.compose.runtime.collectAsState import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.material3.a2ui.A2uiSurface @Composable fun BookingAssistantScreen( viewModel: BookingAssistantViewModel, modifier: Modifier = Modifier ) { val activeSurfaces by viewModel.activeSurfaces.collectAsState() LazyColumn( modifier = modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(16.dp) ) { items(activeSurfaces) { surfaceModel -> Card(modifier = Modifier.fillMaxWidth()) { A2uiSurface( surfaceModel = surfaceModel, modifier = Modifier.fillMaxWidth().wrapContentHeight() ) } } } }
Vous verrez maintenant plusieurs surfaces d'UI générées par notre agent s'exécutant dans le backend :
Conclusion
En hébergeant les workflows agentiques dans le cloud et en utilisant conjointement les protocoles AG-UI et A2UI, nous pouvons créer des interfaces Android natives et dynamiques, directement pilotées par des modèles d'IA. AG-UI établit le canal de streaming bidirectionnel en temps réel pour les messages et les événements de cycle de vie, tandis qu'A2UI permet à l'agent cloud de décrire de manière dynamique les composants d'UI interactifs, ce qui permet de dissocier parfaitement l'application cliente de la logique d'orchestration du backend étape par étape.
Consultez le code source complet de Jetpacker sur GitHub et regardez la vidéo Build Intelligent Android apps with Google's AI (Créer des applications Android intelligentes avec l'IA de Google) pour découvrir comment intégrer des workflows agentiques directement dans votre application.
Consultez les autres parties de cette série d'articles de blog :
▪️ Partie 1 : Présentation de l'application et aperçu général
📱 Partie 2 : Intelligence sur l'appareil Découvrez en détail les API d'IA générative 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 : Intégration du système. Intégrer le système d'intelligence Android à l'aide d'AppFunctions
🤖 Partie 5 (cet article) : Workflows agentiques intégrés à l'application. Étendre l'application avec des assistants de réservation de bout en bout optimisés 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
-
TutorielsBienvenue 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 agentive.
Thomas Ezan, Jolanda Verhoef, Caren Chang • Temps de lecture : 8 min -
TutorielsJetpacker est une application de démonstration technique que notre équipe a créée de toutes pièces pour l'édition de cette année de Google I/O (à l'aide d'Antigravity). En substance, Jetpacker aide les utilisateurs à planifier, explorer et profiter de leur prochaine grande aventure.
Jolanda Verhoef • Temps de lecture : 4 min -
TutorielsBienvenue 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 agentive. Dans notre précédent article, nous avons présenté Jetpacker, l'application de démonstration que nous utiliserons tout au long de cette série.
Caren Chang • Temps de lecture : 6 min
Recevez chaque semaine les dernières informations sur le développement Android dans votre boîte de réception.