Tworzenie inteligentnych aplikacji na Androida: Agentic Workflows w aplikacji
Czas czytania: 9 min
Witamy ponownie w serii postów na blogu „Tworzenie inteligentnych aplikacji na Androida”, w której przekształcamy podstawową aplikację na Androida w spersonalizowaną, inteligentną i agentową. W poprzednim poście dowiedzieliście się, jak połączyć się z systemem AI za pomocą funkcji AppFunctions.
Z tego posta dowiesz się, jak tworzyć autonomiczne Agentic Workflows działające w chmurze.
Czasami zadanie jest zbyt złożone, aby można je było wykonać podczas jednej sesji na urządzeniu. Na przykład rezerwacja pełnego planu podróży obejmuje koordynację godzin lotów, wybór pokoi hotelowych, rezerwację biletów do muzeów i rezerwację stolików w restauracjach. Jeśli uruchomisz ten wieloetapowy proces bezpośrednio na urządzeniu mobilnym, aplikacja może zostać zamknięta i możesz utracić postępy. Zarządzanie wszystkimi tymi krokami i danymi uwierzytelniającymi interfejsu API na telefonie również szybko staje się skomplikowane.
W przypadku tych długotrwałych, wieloetapowych przepływów pracy możesz użyć niestandardowego backendu hostowanego samodzielnie. Backend wykonuje agentów rezerwacji w tle, podczas gdy aplikacja na Androida łączy się z sesją, wizualizuje postęp i prosi użytkownika o dane wejściowe tylko wtedy, gdy jest to konieczne.
Korzystanie z backendu agentowego hostowanego w chmurze ma kilka zalet:
- Wykonywanie w tle: agenci rezerwacji działają autonomicznie w chmurze, więc postępy nie zostaną utracone, jeśli aplikacja mobilna przejdzie w tryb działania w tle lub straci połączenie z internetem.
- Złożona administracja wieloma agentami: agent koordynujący może delegować rezerwacje do wyspecjalizowanych subagentów i obsługiwać zależności między nimi.
- Renderowanie interfejsu niezależnie od klienta: backend dynamicznie opisuje strukturę interfejsu, co pozwala aktualizować układ interfejsu bez konieczności publikowania nowej wersji klienta.
Mając na uwadze te korzyści, dodaliśmy do Jetpackera asystenta rezerwacji, który koordynuje rezerwacje lotów, hoteli, muzeów i restauracji. Zobaczmy, jak stworzyliśmy system wieloagentowy oparty na pakiecie Agent Development Kit (ADK) z protokołem interakcji agenta z użytkownikiem (AG-UI) i protokołem interfejsu agenta z użytkownikiem (A2UI) do wysyłania i wyświetlania interaktywnych kart natywnie w Jetpack Compose.
Obsługa złożonych przepływów pracy za pomocą agentów ADK
Zamiast ręcznie koordynować przepływ orkiestracji za pomocą niestandardowych punktów końcowych REST lub złożonych gniazd internetowych, możesz użyć pakietu Agent Development Kit (ADK). Za pomocą ADK możesz definiować agentów i wyposażać ich w narzędzia funkcji Pythona do wysyłania zapytań do baz danych i realizowania rezerwacji.
Oto jak zdefiniować prostego agenta i uruchomić go za pomocą pakietu 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)Gdy uruchamiasz agenta przy użyciu tej konfiguracji, ADK zarządza krokami wykonywania. Automatycznie śledzi kontekst rozmowy, kieruje wiadomości między użytkownikiem a modelem i wykonuje zarejestrowane narzędzia, gdy model o nie prosi. Dzięki temu możesz skupić się na pisaniu przejrzystej logiki proceduralnej, podczas gdy platforma zajmuje się orkiestracją w tle.
Aby połączyć tego agenta backendu z naszą aplikacją Jetpacker, serwer musi mieć możliwość przesyłania strumieniowego aktualizacji w czasie rzeczywistym na urządzenie. Odbywa się to za pomocą protokołu AG-UI. Agent potrzebuje też ustrukturyzowanego sposobu opisywania i dynamicznego aktualizowania komponentów interaktywnych (takich jak selektory opcji i siatki miejsc) na telefonie. W tym celu używa protokołu A2UI.
Standaryzacja komunikacji między agentem a klientem za pomocą AG-UI
Uruchamianie agentów w chmurze i renderowanie interfejsu na Androidzie wymaga standardowego kanału komunikacji. W tym celu użyjesz protokołu AG-UI.
AG-UI to dwukierunkowy protokół warstwy transportowej, który standaryzuje typy wiadomości między agentami a klientami UI. Agent może informować klienta o zdarzeniach cyklu życia, SMS-ach, wywołaniach narzędzi i zarządzaniu stanem. Klient może z kolei wysyłać do agenta SMS-y, wyniki wywołań narzędzi i zdarzenia działań niestandardowych.
Po stronie serwera generuje aktualizacje sformatowane jako standardowe zdarzenia wysyłane przez serwer (np. event: TEXT_MESSAGE_CONTENT zawierające delta JSON). Na Androidzie pakiet SDK Kotlin nasłuchuje tego strumienia i automatycznie mapuje ładunki na zdarzenia klienta z zabezpieczeniami wpisywania:
// 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 } } }
Następnie możesz napisać interfejs, który będzie renderować te różne typy standardowych zdarzeń AG-UI. Dzięki temu uzyskasz typowe działanie „chatbota”:
Umożliwianie agentowi komunikacji z interfejsem za pomocą A2UI
Tradycyjne czatboty zwykle zwracają zwykły tekst lub niestandardowe ładunki JSON. Podczas tworzenia złożonych interfejsów aplikacja kliencka musi przeanalizować te ładunki i przypisać je do konkretnych, gotowych ekranów. Powoduje to powstanie zależności: za każdym razem, gdy dodajesz nową funkcję, zmieniasz układ lub obsługujesz nową interakcję użytkownika, musisz zaktualizować zarówno agenta backendu, jak i aplikację mobilną. Wymaga to opublikowania aktualizacji aplikacji i poczekania, aż użytkownicy ją zainstalują.
Aby rozwiązać ten problem, użyj protokołu A2UI. A2UI umożliwia agentom opisywanie komponentów interfejsu, które mają być renderowane dynamicznie na kliencie. Aplikacja kliencka deklaruje katalog obsługiwanych komponentów, a serwer wysyła ładunek JSON określający układ i właściwości komponentów:
{
"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"
}
}
]
}
}Serwer określa, które komponenty katalogu mają być renderowane, wraz z ich aktywnymi wartościami właściwości, co pozwala na oddzielenie szczegółów implementacji wizualnej klienta od stanu przepływu pracy agenta.
Projektowanie schematu interfejsu backendu
Aby agent mógł prawidłowo wygenerować te ładunki JSON, musi wiedzieć, które komponenty są dostępne i jakie właściwości akceptują.
Aby to zrobić, użyj integracji ADK A2UI. Zamiast ręcznie pisać instrukcje promptów dla każdego komponentu w naszym katalogu, A2uiSchemaManager kompiluje ich schematy JSON i instrukcje układu bezpośrednio w prompcie systemowym. Dzięki temu model uczy się dokładnej struktury i reguł formatowania, których musi przestrzegać, aby generować prawidłowe ładunki A2UI:
# 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"]
)Dzięki tej wygenerowanej instrukcji systemowej LLM jest oparty na układzie schematu i dokładnie wie, jak sformułować aktualizacje komponentów, które klient Androida może renderować.
Natywne renderowanie A2UI za pomocą Jetpack Compose
Aby renderować te drzewa komponentów natywnie na Androidzie, użyj nowej biblioteki Jetpack Compose A2UI Renderer.
Najpierw dodaj zależności do pliku build.gradle.kts modułu:
// 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") }
Każda klasa komponentu w katalogu (np. BookingStatusComponent) określa, jak mapować właściwości otrzymane z ładunku JSON na funkcję typu „composable” Jetpack Compose.
Zarejestruj komponenty niestandardowe w katalogu:
// 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() ) ) }
Wskazówka: Jetpacker implementuje komponenty niestandardowe (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus) dostosowane do procesów rezerwacji. Jeśli Twój agent używa standardowych elementów (takich jak tekst, karty, przyciski, wiersze, kolumny, pola wyboru i selektory daty i godziny), material3-a2ui udostępnia też materialA2uiBasicCatalogV1(...), co zapewnia gotowe do użycia implementacje Material 3 bez konieczności pisania niestandardowych komponentów.
Uwaga: aby zachować zgodność backendu i klienta mobilnego, oba te elementy korzystają z tego samego identyfikatora definicji katalogu (https://example.com/catalogs/booking_assistant/v1/catalog.json). Jeśli dodasz lub zmodyfikujesz właściwości w katalogu backendu, musisz zwiększyć numer wersji i zaktualizować odpowiednią klasę komponentu Kotlin, aby zapobiec błędom analizy.
W aplikacji BookingAssistantViewModel przetwórz wiadomości A2UI za pomocą A2uiMessageProcessor i zaktualizuj aktywne interfejsy:
// 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() } } // ... }
Na ekranie tworzenia wiadomości zbierz te platformy i wyrenderuj każdą z nich za pomocą oficjalnej funkcji kompozycyjnej A2uiSurface z androidx.compose.material3:material3-a2ui. A2uiSurface automatycznie obsługuje obserwację stanu komponentu reaktywnego, wskaźniki ładowania Material 3, błędy i animowane przejścia między aktualizacjami:
// 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() ) } } } }
Zobaczysz teraz kilka interfejsów wygenerowanych przez naszego agenta działającego w backendzie:
Wszystko w jednym miejscu
Dzięki hostowaniu przepływów pracy agentów w chmurze i jednoczesnemu korzystaniu z protokołów AG-UI i A2UI możemy tworzyć dynamiczne, natywne interfejsy Androida oparte bezpośrednio na modelach AI. AG-UI ustanawia dwukierunkowy kanał strumieniowania w czasie rzeczywistym dla wiadomości i zdarzeń cyklu życia, a A2UI umożliwia agentowi w chmurze dynamiczne opisywanie interaktywnych komponentów interfejsu, dzięki czemu aplikacja kliencka jest całkowicie odseparowana od logiki orkiestracji backendu krok po kroku.
Pełny kod źródłowy Jetpackera znajdziesz na GitHubie. Obejrzyj też film Tworzenie inteligentnych aplikacji na Androida za pomocą AI od Google, aby dowiedzieć się więcej o integrowaniu przepływów pracy opartych na agentach bezpośrednio z aplikacją.
Zapoznaj się z innymi częściami tej serii postów na blogu:
▪️ Część 1: wprowadzenie do aplikacji i ogólne omówienie.
📱 Część 2: funkcje AI na urządzeniu. Poznaj interfejsy GenAI API w ML Kit i Gemini Nano, aby tworzyć funkcje skoncentrowane na ochronie prywatności, takie jak podsumowywanie planu podróży, analizowanie paragonów i lokalne przetwarzanie dźwięku.
☁️ Część 3: wnioskowanie hybrydowe i w chmurze. Dowiedz się, jak używać Firebase AI Logic do ugruntowywania odpowiedzi LLM w danych ze świata rzeczywistego, takich jak Mapy Google i kontekst internetowy.
⚙️ Część 4. Integracja systemu. Integracja z systemem AI na Androidzie za pomocą AppFunctions.
🤖 Część 5 (ten post): Agentic Workflows w aplikacji. Rozszerz aplikację o kompleksowych asystentów rezerwacji opartych na interfejsie A2UI i pakiecie ADK.
Chcesz dowiedzieć się więcej o tworzeniu aplikacji na Androida? Obserwuj stronę dla deweloperów aplikacji na Androida na YouTube lub LinkedIn.
Wszystkie fragmenty kodu w tym poście na blogu są objęte tym powiadomieniem o prawach autorskich:
Copyright 2026 Google LLC. SPDX-License-Identifier: Apache-2.0
-
InstrukcjeWitamy ponownie w serii postów na blogu „Tworzenie inteligentnych aplikacji na Androida”, w której bierzemy podstawową aplikację na Androida i przekształcamy ją w spersonalizowane, inteligentne i agentowe środowisko.
Thomas Ezan, Jolanda Verhoef, Caren Chang • Czas czytania: 8 min -
InstrukcjeJetpacker to aplikacja techniczna, którą nasz zespół stworzył od podstaw na tegoroczną konferencję Google I/O (przy użyciu Antigravity). Jetpacker pomaga użytkownikom planować i odkrywać kolejne wielkie przygody oraz czerpać z nich radość.
Jolanda Verhoef • Czas czytania: 4 min -
InstrukcjeWitamy ponownie w serii postów na blogu „Tworzenie inteligentnych aplikacji na Androida”, w której bierzemy podstawową aplikację na Androida i przekształcamy ją w spersonalizowane, inteligentne i agentowe środowisko. W poprzednim poście przedstawiliśmy Jetpackera, aplikację demonstracyjną, której będziemy używać w tej serii.
Caren Chang • Czas czytania: 6 min
Otrzymuj co tydzień najnowsze informacje o tworzeniu aplikacji na Androida na swoją skrzynkę odbiorczą.