ברוכים השבים לסדרת הפוסטים בבלוג "פיתוח אפליקציות חכמות ל-Android", שבה אתם לוקחים אפליקציה בסיסית ל-Android והופכים אותה לחוויה מותאמת אישית, חכמה ופרואקטיבית. בפוסט הקודם הסברנו איך להתחבר למערכת החכמה באמצעות AppFunctions.
בפוסט הזה נסביר איך ליצור Agentic Workflows אוטונומיים באפליקציה שפועלים בענן.
לפעמים משימה מסוימת מורכבת מדי לסשן אחד במכשיר. לדוגמה, הזמנת מסלול נסיעה מלא לחופשה כוללת תיאום זמני טיסות, בחירת חדרים במלון, הזמנת כרטיסים למוזיאון והזמנת מקומות במסעדות. אם תפעילו את התהליך הזה ישירות במכשיר נייד, יכול להיות שהאפליקציה תיסגר וההתקדמות שלכם תאבד. גם ניהול כל השלבים האלה ופרטי הכניסה ל-API בטלפון הופך מהר מאוד למסובך.
בתהליכי עבודה כאלה, שכוללים כמה שלבים ונמשכים זמן רב, אתם יכולים להשתמש בקצה עורפי מותאם אישית באירוח עצמי. ה-backend מפעיל את סוכני ההזמנות ברקע, ואפליקציית Android מתחברת לסשן, מציגה את ההתקדמות ומבקשת קלט מהמשתמש רק כשצריך.
לשימוש בקצה עורפי מבוסס-סוכנים שמתארח בענן יש כמה יתרונות:
- הפעלה ברקע: סוכני ההזמנות פועלים באופן אוטונומי בענן, כך שההתקדמות אף פעם לא אובדת אם האפליקציה לנייד עוברת לרקע או מאבדת את החיבור לאינטרנט.
- תזמור מורכב של כמה סוכנים: סוכן מתאם יכול להקצות הזמנות לסוכני משנה ייעודיים ולטפל ביחסי התלות ביניהם.
- עיבוד ממשק משתמש ללא תלות בלקוח: ה-backend מתאר את מבנה הממשק באופן דינמי, ומאפשר לכם לעדכן את פריסה של ממשק המשתמש בלי להוציא גרסת לקוח חדשה.
בהתחשב ביתרונות האלה, הוספנו ל-Jetpacker עוזר אישי להזמנות שמתאם טיסות, מלונות, מוזיאונים והזמנות למסעדות. בואו נראה איך תזמרנו מערכת מרובת סוכנים שמופעלת על ידי ערכת פיתוח הסוכנים (ADK), עם פרוטוקול האינטראקציה בין הסוכן למשתמש (AG-UI) ופרוטוקול הממשק בין הסוכן למשתמש (A2UI) כדי לשלוח ולהציג כרטיסים אינטראקטיביים באופן מקורי ב-Jetpack Compose.
הפעלת תהליכי עבודה מורכבים באמצעות סוכני ADK
במקום לתאם את תהליך התיזמור באופן ידני באמצעות נקודות קצה מותאמות אישית של REST או שקעי אינטרנט מורכבים, אתם יכולים להשתמש בערכה לפיתוח סוכנים (ADK). באמצעות ADK, אתם יכולים להגדיר סוכנים ולצייד אותם בכלי פונקציות של Python כדי לשלוח שאילתות למסדי נתונים ולבצע הזמנות.
כך מגדירים סוכן פשוט ומפעילים אותו באמצעות 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)כשמפעילים סוכן באמצעות ההגדרה הזו, ה-ADK מנהל את שלבי הביצוע. הוא עוקב באופן אוטומטי אחרי ההקשר של השיחה, מנתב הודעות בין המשתמש למודל ומפעיל את הכלים הרשומים כשהמודל מבקש אותם. כך אתם יכולים להתמקד בכתיבת לוגיקה פרוצדורלית נקייה, בזמן שה-framework מטפלת בתזמור ברקע.
כדי לחבר את סוכן הקצה העורפי הזה לאפליקציית Jetpacker, השרת צריך דרך להעביר עדכונים בזמן אמת למכשיר, והתהליך הזה מטופל באמצעות פרוטוקול AG-UI. הנציג צריך גם דרך מובנית לתאר ולעדכן רכיבים אינטראקטיביים (כמו בוררי אפשרויות ורשתות מושבים) באופן דינמי בטלפון, וזה המקום שבו פרוטוקול A2UI נכנס לתמונה.
תקנון התקשורת בין הסוכן ללקוח באמצעות AG-UI
כדי להפעיל סוכנים בענן ולעבד את ממשק המשתמש ב-Android, צריך ערוץ תקשורת רגיל. לשם כך, צריך להשתמש בפרוטוקול AG-UI.
AG-UI הוא פרוטוקול שכבת תעבורה דו-כיווני שמבצע סטנדרטיזציה של סוגי ההודעות בין סוכנים לבין לקוחות ממשק משתמש. הנציג יכול להודיע ללקוח על אירועים במחזור החיים, הודעות SMS, קריאות API לכלי וניהול מצבים. הלקוח, בתורו, יכול לשלוח הודעות SMS של המשתמש, תוצאות של קריאות API לכלי ואירועים של פעולות בהתאמה אישית בחזרה לנציג.
בצד השרת, הוא מניב עדכונים בפורמט של אירועים רגילים שנשלחים מהשרת (כמו event: TEXT_MESSAGE_CONTENT שמכיל את הדלתא של ה-JSON). ב-Android, ערכת ה-SDK של Kotlin מאזינה לסטרימינג הזה וממפה באופן אוטומטי את המטענים הייעודיים (payloads) לאירועי לקוח עם מניעת שגיאות הקלדה:
// 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 } } }
לאחר מכן, אתם יכולים לכתוב ממשק משתמש כדי להציג את הסוגים השונים האלה של אירועי AG-UI סטנדרטיים. כך תקבלו את חוויית השימוש האופיינית בצ'אט בוט:
איך מאפשרים לסוכן לדבר עם ממשק המשתמש באמצעות A2UI
צ'אט בוטים מסורתיים בדרך כלל מחזירים טקסט פשוט או מטען ייעודי (payload) מותאם אישית של JSON. כשמפתחים ממשקים מורכבים, אפליקציית הלקוח צריכה לנתח את המידע הזה ולמפות אותו למסכים ספציפיים שנבנו מראש. כך נוצרת תלות: בכל פעם שמוסיפים תכונה חדשה, משנים את הפריסה או תומכים באינטראקציית משתמש חדשה, צריך לעדכן גם את הסוכן בקצה העורפי וגם את האפליקציה לנייד. כדי לעשות את זה, צריך לפרסם עדכון לאפליקציה ולחכות שהמשתמשים יתקינו אותו.
כדי לפתור את הבעיה, צריך להשתמש בפרוטוקול A2UI. A2UI מאפשר לנציגים לתאר את רכיבי ממשק המשתמש שיוצגו ללקוח באופן דינמי. אפליקציית הלקוח מצהירה על קטלוג של רכיבים שהיא תומכת בהם, והשרת שולח מטען ייעודי (payload) בפורמט JSON שמציין את הפריסה והמאפיינים של הרכיבים:
{
"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"
}
}
]
}
}השרת מציין אילו רכיבים בקטלוג צריך להציג, יחד עם ערכי המאפיינים הפעילים שלהם, ומפריד בצורה נקייה בין פרטי ההטמעה החזותית של הלקוח לבין מצב תהליך העבודה של הנציג.
תכנון הסכימה של ממשק המשתמש בקצה העורפי
כדי שהנציג ייצור את המטענים הייעודיים האלה ב-JSON בצורה נכונה, הוא צריך לדעת אילו רכיבים זמינים ואילו מאפיינים הם מקבלים.
כדי לעשות את זה, משתמשים בשילוב של ADK A2UI. במקום לכתוב באופן ידני הוראות להנחיות לכל רכיב בקטלוג, A2uiSchemaManager מקמפל את סכימות ה-JSON והוראות הפריסה שלהם ישירות להנחיית המערכת. כך המודל לומד את המבנה המדויק ואת כללי הפורמט שהוא צריך לפעול לפיהם כדי ליצור מטען ייעודי (payload) תקין של 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"]
)בעזרת הוראת המערכת שנוצרה, מודל ה-LLM מבוסס על פריסת הסכימה ויודע בדיוק איך לנסח עדכוני רכיבים שלקוח Android יכול לעבד.
עיבוד מקורי של A2UI באמצעות Jetpack Compose
כדי לעבד את עצי הרכיבים האלה באופן מקורי ב-Android, צריך להשתמש בספרייה החדשה Jetpack Compose A2UI Renderer.
קודם כול, מוסיפים את יחסי התלות לקובץ build.gradle.kts של המודול:
// 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") }
כל מחלקת רכיבים בקטלוג (כמו BookingStatusComponent) מגדירה איך למפות את המאפיינים שהתקבלו מהמטען הייעודי (payload) של ה-JSON לפונקציה קומפוזבילית של Jetpack Compose.
רושמים את הרכיבים בהתאמה אישית בקטלוג:
// 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() ) ) }
טיפ: Jetpacker מטמיע רכיבים בהתאמה אישית (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus) שמותאמים לתהליכי הזמנה. אם הנציג שלכם משתמש ברכיבים סטנדרטיים (כמו טקסט, כרטיסים, כפתורים, שורות, עמודות, תיבות סימון ובוררי תאריך ושעה), material3-a2ui מספק גם את materialA2uiBasicCatalogV1(...), ומאפשר לכם להשתמש בהטמעות של Material 3 בלי לכתוב רכיבים בהתאמה אישית.
הערה: כדי לשמור על התאמה בין הקצה העורפי לבין הלקוח בנייד, שניהם מסתמכים על אותו מזהה הגדרה של קטלוג (https://example.com/catalogs/booking_assistant/v1/catalog.json). אם מוסיפים או משנים מאפיינים בקטלוג של הקצה העורפי, צריך להגדיל את מספר הגרסה ולעדכן את מחלקת הרכיבים התואמת של Kotlin כדי למנוע שגיאות ניתוח.
ב-BookingAssistantViewModel, מעבדים את ההודעות של A2UI באמצעות A2uiMessageProcessor ומעדכנים את הפלטפורמות הפעילות שלנו:
// 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() } } // ... }
במסך Compose, אוספים את המשטחים האלה ומעבדים כל אחד מהם באמצעות ה-composable הרשמי A2uiSurface מ-androidx.compose.material3:material3-a2ui. A2uiSurface מטפל באופן אוטומטי בתצפית על מצב הרכיב הריאקטיבי, באינדיקטורים של טעינה ב-Material 3, באפשרויות חלופיות במקרה של שגיאה ובמעברים מונפשים בין עדכונים:
// 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() ) } } } }
עכשיו יופיעו כמה ממשקי משתמש שנוצרו על ידי הנציג שלנו שפועל בקצה העורפי:
מסכם הכול
כשמארחים תהליכי עבודה של סוכנים בענן ומשתמשים בפרוטוקולים AG-UI ו-A2UI ביחד, אפשר ליצור ממשקים דינמיים ונייטיב ב-Android שמופעלים ישירות על ידי מודלים של AI. AG-UI יוצר את ערוץ הסטרימינג הדו-כיווני בזמן אמת להודעות ולאירועים במחזור החיים, ו-A2UI מאפשר לסוכן בענן לתאר באופן דינמי רכיבי ממשק משתמש אינטראקטיביים, כך שאפליקציית הלקוח מנותקת לחלוטין מהלוגיקה של תזמור ה-backend שלב אחר שלב.
אתם יכולים לעיין בקוד המקור המלא של Jetpacker ב-GitHub, ולצפות בסרטון פיתוח אפליקציות חכמות ל-Android באמצעות ה-AI של Google כדי לקבל מידע נוסף על שילוב תהליכי עבודה מבוססי-סוכנים ישירות באפליקציה.
כדאי לקרוא את החלקים האחרים בסדרת הפוסטים הזו בבלוג:
▪️ חלק 1: מבוא לאפליקציה וסקירה כללית ברמה גבוהה.
📱 חלק 2: בינה מלאכותית במכשיר. התעמקו בממשקי ה-API של AI גנרטיבי ב-ML Kit וב-Gemini Nano כדי ליצור תכונות מוכוונות פרטיות, כמו סיכום מסלול נסיעה, ניתוח קבלות ועיבוד אודיו מקומי.
☁️ חלק 3: הסקת מסקנות היברידית ובענן. איך משתמשים ב-Firebase AI Logic כדי לבסס תשובות של מודל שפה גדול (LLM) על נתונים מהעולם האמיתי, כמו מפות Google והקשר מהאינטרנט.
⚙️ חלק 4: שילוב מערכות. שילוב עם מערכת הבינה המלאכותית של Android באמצעות AppFunctions.
🤖 חלק 5 (הפוסט הזה!): תהליכי עבודה אג'נטיים באפליקציה. הרחבת האפליקציה באמצעות עוזרי הזמנות מקצה לקצה שמופעלים על ידי A2UI ו-ADK.
רוצים לדעת עוד על פיתוח ל-Android? כדאי לעקוב אחרי Android Developers ב-YouTube או ב-LinkedIn.
כל קטעי הקוד בפוסט הזה בבלוג כפופים להודעה הבאה על זכויות יוצרים:
Copyright 2026 Google LLC. SPDX-License-Identifier: Apache-2.0
-
מדריכיםברוכים השבים לסדרת הפוסטים בבלוג "פיתוח אפליקציות חכמות ל-Android", שבה אנחנו לוקחים אפליקציה בסיסית ל-Android והופכים אותה לחוויה מותאמת אישית, חכמה וסוכנית.
Thomas Ezan, Jolanda Verhoef, Caren Chang • משך הקריאה: 8 דקות -
מדריכיםJetpacker היא אפליקציה טכנית להדגמה שהצוות שלנו בנה מאפס לכנס Google I/O השנה (באמצעות Antigravity). המטרה העיקרית של Jetpacker היא לעזור למשתמשים לתכנן, לחקור וליהנות מההרפתקה הגדולה הבאה שלהם.
Jolanda Verhoef • משך הקריאה: 4 דקות -
מדריכיםברוכים השבים לסדרת הפוסטים בבלוג "פיתוח אפליקציות חכמות ל-Android", שבה אנחנו לוקחים אפליקציה בסיסית ל-Android והופכים אותה לחוויה מותאמת אישית, חכמה וסוכנית. בפוסט הקודם שלנו הצגנו את Jetpacker, אפליקציית ההדגמה שנשתמש בה לאורך הסדרה הזו.
Caren Chang • משך הקריאה: 6 דקות
רוצים לקבל טיפים עדכניים לפיתוח Android ישירות לאימייל כל שבוע?