Ti diamo il bentornato alla serie di blog post "Crea app per Android intelligenti", in cui prendi un'app per Android di base e la trasformi in un'esperienza personalizzata, intelligente e agentica. Nel nostro post precedente hai imparato a connetterti al sistema di intelligence utilizzando AppFunctions.
In questo post imparerai a creare Agentic Workflows in-app autonomi in esecuzione nel cloud.
A volte un'attività è troppo complessa per una singola sessione del dispositivo. Ad esempio, la prenotazione di un itinerario di vacanza completo comporta il coordinamento degli orari dei voli, la selezione delle camere d'albergo, la prenotazione dei biglietti per i musei e la prenotazione dei ristoranti. Se esegui questa procedura in più passaggi direttamente su un dispositivo mobile, l'app potrebbe chiudersi e i tuoi progressi potrebbero andare persi. Anche la gestione di tutti questi passaggi e delle credenziali API su uno smartphone diventa rapidamente complicata.
Per questi workflow in più fasi e di lunga durata, puoi utilizzare un backend self-hosted personalizzato. Il backend esegue gli agenti di prenotazione in background, mentre l'app per Android si connette alla sessione, visualizza l'avanzamento e richiede l'input dell'utente solo quando necessario.
L'utilizzo di un backend agentico ospitato nel cloud offre alcuni vantaggi:
- Esecuzione in background: gli agenti di prenotazione vengono eseguiti autonomamente nel cloud, quindi i progressi non vengono mai persi se l'app mobile passa in background o perde la connessione a internet.
- Orchestrazione multi-agente complessa: un agente coordinatore può delegare le prenotazioni a subagenti specializzati e gestire le dipendenze tra di loro.
- Rendering della UI indipendente dal client: il backend descrive la struttura dell'interfaccia in modo dinamico, consentendoti di aggiornare il layout UI senza rilasciare una nuova versione del client.
Tenendo conto di questi vantaggi, abbiamo aggiunto un assistente per le prenotazioni a Jetpacker che coordina voli, hotel, musei e prenotazioni di ristoranti. Vediamo come abbiamo orchestrato un sistema multi-agente basato su Agent Development Kit (ADK), con il protocollo di interazione agente-utente (AG-UI) e il protocollo di interfaccia agente-utente (A2UI) per inviare e visualizzare schede interattive in modo nativo in Jetpack Compose.
Gestione di workflow complessi con gli agenti ADK
Anziché coordinare manualmente il flusso di orchestrazione utilizzando endpoint REST personalizzati o websocket complessi, puoi utilizzare l'Agent Development Kit (ADK). Con ADK, puoi definire gli agenti e dotarli di strumenti di funzioni Python per eseguire query sui database ed effettuare prenotazioni.
Ecco come definire un agente semplice ed eseguirlo utilizzando 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)Quando esegui un agente utilizzando questa configurazione, l'ADK gestisce i passaggi di esecuzione per te. Tiene traccia automaticamente del contesto della conversazione, instrada i messaggi tra l'utente e il modello ed esegue gli strumenti registrati quando il modello li richiede. In questo modo, puoi concentrarti sulla scrittura di una logica procedurale pulita, mentre il framework gestisce l'orchestrazione in background.
Per connettere questo agente di backend alla nostra app Jetpacker, il server deve essere in grado di trasmettere gli aggiornamenti in tempo reale al dispositivo, il che viene gestito utilizzando il protocollo AG-UI. L'agente ha anche bisogno di un modo strutturato per descrivere e aggiornare i componenti interattivi (come i selettori di opzioni e le griglie dei posti a sedere) in modo dinamico sullo smartphone, ed è qui che entra in gioco il protocollo A2UI.
Standardizzazione della comunicazione tra agente e cliente con AG-UI
L'esecuzione di agenti nel cloud e il rendering della UI su Android richiedono un canale di comunicazione standard. A questo scopo, utilizzerai il protocollo AG-UI.
AG-UI è un protocollo di livello di trasporto bidirezionale che standardizza i tipi di messaggi tra gli agenti e i client UI. L'agente può informare il client di eventi del ciclo di vita, messaggi, chiamate allo strumento e gestione dello stato. Il client, a sua volta, può inviare all'agente messaggi dell'utente, risultati delle chiamate allo strumento ed eventi di azioni personalizzate.
Sul lato server, genera aggiornamenti formattati come Server-Sent Events standard (ad esempio event: TEXT_MESSAGE_CONTENT contenente il delta JSON). Su Android, l'SDK Kotlin ascolta questo stream e mappa automaticamente i payload agli eventi client con sicurezza dei tipi:
// 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 } } }
Puoi quindi scrivere una UI per eseguire il rendering di questi diversi tipi di eventi AG-UI standardizzati. In questo modo, otterrai l'esperienza "Chatbot" prototipica:
Consentire all'agente di comunicare con la UI tramite A2UI
I chatbot tradizionali in genere restituiscono testo normale o payload JSON personalizzati. Quando si creano interfacce complesse, l'applicazione client deve analizzare questi payload e mapparli a schermate specifiche predefinite. Questo crea una dipendenza: ogni volta che aggiungi una nuova funzionalità, modifichi il layout o supporti una nuova interazione utente, devi aggiornare sia l'agente di backend sia l'applicazione mobile. Ciò richiede la pubblicazione di un aggiornamento dell'app e l'attesa che gli utenti lo installino.
Per risolvere il problema, utilizza il protocollo A2UI. A2UI consente agli agenti di descrivere i componenti della UI da visualizzare sul client in modo dinamico. L'app client dichiara un catalogo di componenti supportati e il server invia un payload JSON che specifica il layout e le proprietà dei componenti:
{
"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"
}
}
]
}
}Il server specifica quali componenti del catalogo eseguire il rendering insieme ai relativi valori delle proprietà attive, separando in modo netto i dettagli di implementazione visiva del client dallo stato del workflow dell'agente.
Progettazione dello schema della UI di backend
Affinché l'agente generi correttamente questi payload JSON, deve sapere quali componenti sono disponibili e quali proprietà accettano.
Per farlo, utilizza l'integrazione ADK A2UI. Invece di scrivere manualmente le istruzioni del prompt per ogni componente del nostro catalogo, A2uiSchemaManager compila i relativi schemi JSON e le istruzioni di layout direttamente nel prompt di sistema. In questo modo, il modello apprende la struttura esatta e le regole di formattazione che deve seguire per generare payload A2UI validi:
# 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"]
)Con questa istruzione di sistema generata, l'LLM si basa sul layout dello schema e sa esattamente come formulare gli aggiornamenti dei componenti che il client Android è in grado di visualizzare.
Rendering nativo di A2UI con Jetpack Compose
Per eseguire il rendering di questi alberi di componenti in modo nativo su Android, utilizza la nuova libreria Jetpack Compose A2UI Renderer.
Innanzitutto, aggiungi le dipendenze al file build.gradle.kts del nostro modulo:
// 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") }
Ogni classe di componenti nel catalogo (ad esempio BookingStatusComponent) definisce come mappare le proprietà ricevute dal payload JSON in una funzione componibile di Jetpack Compose.
Registra i componenti personalizzati in un catalogo:
// 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() ) ) }
Suggerimento: Jetpacker implementa componenti personalizzati (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus) personalizzati per i flussi di prenotazione. Se il tuo agente utilizza elementi standard (come testo, schede, pulsanti, righe, colonne, caselle di controllo e selettori di data e ora), material3-a2ui fornisce anche materialA2uiBasicCatalogV1(...), offrendoti implementazioni di Material 3 pronte all'uso senza scrivere componenti personalizzati.
Nota: per mantenere allineati il backend e il client mobile, entrambi si basano sullo stesso ID definizione del catalogo (https://example.com/catalogs/booking_assistant/v1/catalog.json). Se aggiungi o modifichi proprietà nel catalogo di backend, devi aumentare il numero di versione e aggiornare la classe del componente Kotlin corrispondente per evitare errori di analisi.
In BookingAssistantViewModel, elabora i messaggi A2UI utilizzando A2uiMessageProcessor e aggiorna le nostre piattaforme attive:
// 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() } } // ... }
Nella schermata di composizione, raccogli queste piattaforme ed esegui il rendering di ciascuna utilizzando il componibile A2uiSurface ufficiale di androidx.compose.material3:material3-a2ui. A2uiSurface gestisce automaticamente l'osservazione dello stato dei componenti reattivi, gli indicatori di caricamento di Material 3, i fallback degli errori e le transizioni animate tra gli aggiornamenti:
// 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() ) } } } }
Ora vedrai diverse superfici della UI generate dal nostro agente in esecuzione nel backend:
Riepilogo
Ospitando gli Agentic Workflows nel cloud e utilizzando i protocolli AG-UI e A2UI insieme, possiamo creare interfacce Android native e dinamiche basate direttamente sui modelli di AI. AG-UI stabilisce il canale di streaming bidirezionale in tempo reale per i messaggi e gli eventi del ciclo di vita, mentre A2UI consente all'agente cloud di descrivere dinamicamente i componenti UI interattivi, mantenendo l'applicazione client perfettamente disaccoppiata dalla logica di orchestrazione del backend passo passo.
Dai un'occhiata al codice sorgente completo di Jetpacker su GitHub e guarda il video Crea app per Android intelligenti con l'AI di Google per scoprire di più su come integrare gli Agentic Workflow direttamente nella tua app.
Dai un'occhiata alle altre parti di questa serie di blog post:
▪️ Parte 1: introduzione dell'app e panoramica generale.
📱 Parte 2: on-device intelligence. Approfondisci le API GenAI di ML Kit e Gemini Nano per creare funzionalità incentrate sulla privacy, come il riepilogo degli itinerari, l'analisi delle ricevute e l'elaborazione dell'audio locale.
☁️ Parte 3: ragionamento ibrido e cloud. Scopri come utilizzare Firebase AI Logic per basare le risposte degli LLM su dati reali, come Google Maps e il contesto web.
⚙️ Parte 4: integrazione del sistema. Integrazione con il sistema di intelligence di Android utilizzando AppFunctions.
🤖 Parte 5 (questo post): Workflow agentici in-app. Estendi l'app con assistenti di prenotazione end-to-end basati su A2UI e ADK.
Vuoi saperne di più sullo sviluppo Android? Segui Android Developers su YouTube o LinkedIn.
Tutti gli snippet di codice in questo blog post seguono la seguente nota sul copyright:
Copyright 2026 Google LLC. SPDX-License-Identifier: Apache-2.0
-
IstruzioniTi diamo il bentornato alla serie di blog post "Crea app per Android intelligenti", in cui prendiamo un'app per Android di base e la trasformiamo in un'esperienza personalizzata, intelligente e basata su agenti.
Thomas Ezan, Jolanda Verhoef, Caren Chang • Tempo di lettura: 8 min -
IstruzioniJetpacker è un'app di presentazione tecnica che il nostro team ha creato da zero per il Google I/O di quest'anno (utilizzando Antigravity). In sostanza, Jetpacker aiuta gli utenti a pianificare, esplorare e godersi la loro prossima grande avventura.
Jolanda Verhoef • Tempo di lettura: 4 min -
IstruzioniTi diamo il bentornato alla serie di blog post "Crea app per Android intelligenti", in cui prendiamo un'app per Android di base e la trasformiamo in un'esperienza personalizzata, intelligente e basata su agenti. Nel nostro post precedente abbiamo presentato Jetpacker, l'app demo che utilizzeremo in questa serie.
Caren Chang • Tempo di lettura: 6 min
Ricevi gli ultimi approfondimenti sullo sviluppo Android direttamente nella tua casella di posta ogni settimana.