Istruzioni

Crea app per Android intelligenti: Agentic Workflows in-app

Tempo di lettura: 9 min
Visualizza il profilo di Jolanda Verhoef
Jolanda Verhoef Developer Relations Engineer

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.
booking-assistant.png
L'assistente per le prenotazioni mostra tutti i progressi delle prenotazioni, organizzati per tipo di evento.

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.

diagram.png
L'app per Android invia i dati dell'itinerario della corsa corrente al server. L'agente coordinatore sceglie quali subagenti attivare. Ogni subagente fornisce i propri risultati a una coda di sessione condivisa che li trasmette all'app per Android.

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.

web_debug.png


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:

manage_bookings.png
Un'interfaccia di base che consente a un utente di chattare con un assistente.

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:

booking-assistant.png
Un assistente per le prenotazioni ben progettato che si basa sulla UI anziché sul testo per interagire con l'utente.

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
Scritto da:
Continua a leggere