วิธีการ

สร้างแอป Android อัจฉริยะ: เวิร์กโฟลว์แบบเป็น Agent ในแอป

ใช้เวลาอ่าน 9 นาที
ดูโปรไฟล์ของ Jolanda Verhoef
Jolanda Verhoef วิศวกรนักพัฒนาซอฟต์แวร์สัมพันธ์

ยินดีต้อนรับกลับสู่ชุดบล็อกโพสต์ "สร้างแอป Android อัจฉริยะ" ซึ่งคุณจะได้นำแอป Android พื้นฐานมาเปลี่ยนให้เป็นประสบการณ์การใช้งานที่ปรับเปลี่ยนในแบบของคุณ ชาญฉลาด และทำงานแบบ Agent ในโพสต์ก่อนหน้า คุณได้เรียนรู้วิธีเชื่อมต่อกับระบบอัจฉริยะโดยใช้ AppFunctions

ในโพสต์นี้ คุณจะได้เรียนรู้วิธีสร้างเวิร์กโฟลว์ Agentic ในแอปแบบอัตโนมัติที่ทำงานในระบบคลาวด์

บางครั้งงานก็ซับซ้อนเกินไปสำหรับเซสชันอุปกรณ์เดียว ตัวอย่างเช่น การจองแผนการเดินทางช่วงวันหยุดที่สมบูรณ์เกี่ยวข้องกับการประสานงานเวลาเที่ยวบิน การเลือกห้องพักโรงแรม การจองตั๋วพิพิธภัณฑ์ และการวางแผนจองร้านอาหาร หากคุณดำเนินการตามกระบวนการหลายขั้นตอนนี้บนมือถือโดยตรง แอปอาจปิดลงและความคืบหน้าอาจหายไป การจัดการขั้นตอนและข้อมูลเข้าสู่ระบบ API ทั้งหมดนี้ในโทรศัพท์อาจมีความซับซ้อนอย่างรวดเร็ว

สำหรับเวิร์กโฟลว์แบบหลายขั้นตอนที่ใช้เวลานานเหล่านี้ คุณสามารถใช้แบ็กเอนด์ที่โฮสต์เองที่กำหนดเองได้ แบ็กเอนด์จะเรียกใช้ตัวแทนการจองในเบื้องหลัง ขณะที่แอป Android จะเชื่อมต่อกับเซสชัน แสดงภาพความคืบหน้า และขอข้อมูลจากผู้ใช้เมื่อจำเป็นเท่านั้น

การใช้แบ็กเอนด์แบบ Agentic ที่โฮสต์ในระบบคลาวด์มีข้อดีหลายประการ ดังนี้

  • การดำเนินการในเบื้องหลัง: ตัวแทนการจองจะทำงานโดยอัตโนมัติในระบบคลาวด์ ดังนั้นความคืบหน้าจะไม่สูญหายหากแอปบนมือถือทำงานในเบื้องหลังหรือขาดการเชื่อมต่ออินเทอร์เน็ต
  • การจัดการ Agent หลายรายการที่ซับซ้อน: Agent ผู้ประสานงานสามารถมอบหมายการจองให้กับ Agent ย่อยที่เชี่ยวชาญและจัดการความสัมพันธ์ระหว่าง Agent เหล่านั้นได้
  • การแสดงผล UI ที่ไม่ขึ้นอยู่กับไคลเอ็นต์: แบ็กเอนด์จะอธิบายโครงสร้างอินเทอร์เฟซแบบไดนามิก ซึ่งช่วยให้คุณอัปเดตเลย์เอาต์ของ UI ได้โดยไม่ต้องเผยแพร่เวอร์ชันไคลเอ็นต์ใหม่
booking-assistant.png
ผู้ช่วยการจองจะแสดงความคืบหน้าของการจองทั้งหมด โดยจัดระเบียบตามประเภทกิจกรรม

เมื่อคำนึงถึงประโยชน์เหล่านี้ เราจึงเพิ่มผู้ช่วยการจองลงใน Jetpacker ซึ่งจะช่วยประสานงานเรื่องเที่ยวบิน โรงแรม พิพิธภัณฑ์ และการจองร้านอาหาร มาดูวิธีที่เราจัดระเบียบระบบแบบหลาย Agent ที่ขับเคลื่อนโดย Agent Development Kit (ADK) ด้วยโปรโตคอลการโต้ตอบระหว่าง Agent กับผู้ใช้ (AG-UI) และโปรโตคอลอินเทอร์เฟซระหว่าง Agent กับผู้ใช้ (A2UI) เพื่อส่งและแสดงการ์ดแบบอินเทอร์แอกทีฟใน Jetpack Compose โดยตรง

ขับเคลื่อนเวิร์กโฟลว์ที่ซับซ้อนด้วย Agent ของ ADK

คุณสามารถใช้ Agent Development Kit (ADK) แทนการประสานงานขั้นตอนการจัดเรียงด้วยตนเองโดยใช้ปลายทาง REST ที่กำหนดเองหรือเว็บซ็อกเก็ตที่ซับซ้อน ADK ช่วยให้คุณกำหนด Agent และติดตั้งเครื่องมือฟังก์ชัน Python เพื่อค้นหาฐานข้อมูลและดำเนินการจองได้

diagram.png
แอป Android จะส่งข้อมูลแผนการเดินทางปัจจุบันไปยังเซิร์ฟเวอร์ โดย Agent ผู้ประสานงานจะเลือก Agent ย่อยที่จะทริกเกอร์ โดยเอเจนต์ย่อยแต่ละรายการจะส่งผลลัพธ์ไปยังคิวเซสชันที่แชร์ซึ่งจะสตรีมผลลัพธ์กลับไปยังแอป Android

วิธีระบุ Agent แบบง่ายและเรียกใช้โดยใช้ 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)

เมื่อเรียกใช้ Agent โดยใช้การตั้งค่านี้ ADK จะจัดการขั้นตอนการดำเนินการให้คุณ โดยจะติดตามบริบทการสนทนา กำหนดเส้นทางข้อความระหว่างผู้ใช้กับโมเดล และเรียกใช้เครื่องมือที่ลงทะเบียนไว้เมื่อโมเดลขอโดยอัตโนมัติ ซึ่งจะช่วยให้คุณมุ่งเน้นที่การเขียนตรรกะเชิงกระบวนการที่สะอาดได้ ขณะที่เฟรมเวิร์กจะจัดการการประสานงานในเบื้องหลัง

web_debug.png


หากต้องการเชื่อมต่อเอเจนต์แบ็กเอนด์นี้กับแอป Jetpacker เซิร์ฟเวอร์ต้องมีวิธีสตรีมข้อมูลอัปเดตแบบเรียลไทม์ไปยังอุปกรณ์ ซึ่งจะจัดการโดยใช้โปรโตคอล AG-UI นอกจากนี้ ตัวแทนยังต้องมีวิธีที่มีโครงสร้างในการอธิบายและอัปเดตคอมโพเนนต์แบบอินเทอร์แอกทีฟ (เช่น ตัวเลือกและตารางที่นั่ง) แบบไดนามิกในโทรศัพท์ ซึ่งเป็นที่มาของโปรโตคอล A2UI

การกำหนดมาตรฐานการสื่อสารระหว่าง Agent กับไคลเอ็นต์ด้วย AG-UI

การเรียกใช้ Agent ในระบบคลาวด์และการแสดงผล UI ใน Android ต้องใช้ช่องทางการสื่อสารมาตรฐาน โดยคุณจะใช้โปรโตคอล AG-UI สำหรับการดำเนินการนี้

AG-UI เป็นโปรโตคอลเลเยอร์การรับส่งข้อมูลแบบ 2 ทิศทางที่กำหนดมาตรฐานประเภทข้อความระหว่าง Agent กับไคลเอ็นต์ UI โดย Agent สามารถแจ้งให้ไคลเอ็นต์ทราบเกี่ยวกับเหตุการณ์ในวงจร ข้อความ การเรียกใช้เครื่องมือ และการจัดการสถานะ ในทางกลับกัน ไคลเอ็นต์สามารถส่งข้อความของผู้ใช้ ผลการเรียกใช้เครื่องมือ และเหตุการณ์การกระทำที่กำหนดเองกลับไปยัง Agent ได้

ในฝั่งเซิร์ฟเวอร์ ระบบจะแสดงการอัปเดตที่จัดรูปแบบเป็น Server-Sent Events มาตรฐาน (เช่น event: TEXT_MESSAGE_CONTENT ที่มีเดลต้า JSON) ใน Android, Kotlin SDK จะคอยฟังการสตรีมนี้และแมปเพย์โหลดกับเหตุการณ์ฝั่งไคลเอ็นต์ที่มีความปลอดภัยในการกำหนดประเภทโดยอัตโนมัติ ดังนี้

// 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
            }
        }
    }

จากนั้นคุณสามารถเขียน UI เพื่อแสดงผลเหตุการณ์ AG-UI ที่ได้มาตรฐานประเภทต่างๆ เหล่านี้ ซึ่งจะมอบประสบการณ์การใช้งาน "แชทบ็อต" ต้นแบบให้คุณ ดังนี้

manage_bookings.png
อินเทอร์เฟซพื้นฐานที่ช่วยให้ผู้ใช้แชทกับผู้ช่วยได้

การอนุญาตให้ Agent พูด UI ด้วย A2UI

แชทบ็อตแบบดั้งเดิมมักจะแสดงผลเป็นข้อความธรรมดาหรือเพย์โหลด JSON ที่กำหนดเอง เมื่อสร้างอินเทอร์เฟซที่ซับซ้อน แอปพลิเคชันไคลเอ็นต์จะต้องแยกวิเคราะห์เพย์โหลดเหล่านี้และแมปกับหน้าจอที่สร้างไว้ล่วงหน้าโดยเฉพาะ ซึ่งจะสร้างความขึ้นต่อกัน กล่าวคือ ทุกครั้งที่คุณเพิ่มฟีเจอร์ใหม่ เปลี่ยนเลย์เอาต์ หรือรองรับการโต้ตอบของผู้ใช้ใหม่ คุณจะต้องอัปเดตทั้ง Agent แบ็กเอนด์และแอปพลิเคชันบนอุปกรณ์เคลื่อนที่ ซึ่งจะต้องเผยแพร่อัปเดตแอปและรอให้ผู้ใช้ติดตั้ง

วิธีแก้ปัญหานี้คือใช้โปรโตคอล A2UI A2UI ช่วยให้ตัวแทนอธิบายคอมโพเนนต์ UI เพื่อแสดงผลในไคลเอ็นต์แบบไดนามิกได้ แอปไคลเอ็นต์จะประกาศแคตตาล็อกของคอมโพเนนต์ที่รองรับ และเซิร์ฟเวอร์จะส่งเพย์โหลด 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"
        }
      }
    ]
  }
}

เซิร์ฟเวอร์จะระบุคอมโพเนนต์แคตตาล็อกที่จะแสดงผลพร้อมกับค่าพร็อพเพอร์ตี้ที่ใช้งานอยู่ ซึ่งจะแยกรายละเอียดการติดตั้งใช้งานภาพของไคลเอ็นต์ออกจากสถานะเวิร์กโฟลว์ของ Agent อย่างชัดเจน

การออกแบบสคีมา UI แบ็กเอนด์

เพื่อให้ Agent สร้างเพย์โหลด JSON เหล่านี้ได้อย่างถูกต้อง Agent ต้องทราบว่ามีคอมโพเนนต์ใดบ้างและยอมรับพร็อพเพอร์ตี้ใด

โดยใช้การผสานรวม ADK A2UI แทนที่จะเขียนคำสั่งพรอมต์สำหรับคอมโพเนนต์ทุกรายการในแคตตาล็อกด้วยตนเอง A2uiSchemaManager จะคอมไพล์สคีมา JSON และคำสั่งเลย์เอาต์ลงในพรอมต์ของระบบโดยตรง วิธีนี้ช่วยให้โมเดลเรียนรู้โครงสร้างและกฎการจัดรูปแบบที่แน่นอนซึ่งต้องปฏิบัติตามเพื่อสร้างเพย์โหลด 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 ใหม่

ก่อนอื่น ให้เพิ่มทรัพยากร Dependency ลงในไฟล์ 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) จะกำหนดวิธีแมปพร็อพเพอร์ตี้ที่ได้รับจากเพย์โหลด 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) ซึ่งปรับแต่งมาสำหรับขั้นตอนการจอง หาก Agent ของคุณใช้องค์ประกอบมาตรฐาน (เช่น ข้อความ, การ์ด, ปุ่ม, แถว, คอลัมน์, ช่องทำเครื่องหมาย และเครื่องมือเลือกวันที่และเวลา) 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 ให้รวบรวมพื้นผิวเหล่านี้และแสดงผลแต่ละรายการโดยใช้ A2uiSurface Composable อย่างเป็นทางการจาก 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()
                )
            }
        }
    }
}

ตอนนี้คุณจะเห็นแพลตฟอร์ม UI หลายรายการที่สร้างโดย Agent ของเราซึ่งทำงานในแบ็กเอนด์ ดังนี้

booking-assistant.png
ผู้ช่วยการจองที่ออกแบบมาอย่างดีซึ่งใช้ UI แทนข้อความเพื่อโต้ตอบกับผู้ใช้

รวมทุกสิ่งไว้ในที่เดียว

การโฮสต์เวิร์กโฟลว์ของ Agent ในระบบคลาวด์และการใช้โปรโตคอล AG-UI และ A2UI ร่วมกันช่วยให้เราสร้างอินเทอร์เฟซ Android แบบไดนามิกที่ขับเคลื่อนโดยโมเดล AI โดยตรงได้ AG-UI จะสร้างช่องทางสตรีมมิงแบบ 2 ทิศทางแบบเรียลไทม์สำหรับข้อความและเหตุการณ์ในวงจร ขณะที่ A2UI ช่วยให้ Agent ระบบคลาวด์อธิบายคอมโพเนนต์ UI แบบอินเทอร์แอกทีฟแบบไดนามิกได้ ซึ่งจะช่วยให้แอปพลิเคชันไคลเอ็นต์แยกออกจากตรรกะการจัดเรียงแบ็กเอนด์แบบทีละขั้นตอนได้อย่างสมบูรณ์

ดูซอร์สโค้ดทั้งหมดของ Jetpacker บน GitHub และดูวิดีโอสร้างแอป Android อัจฉริยะด้วย AI ของ Google เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีผสานรวมเวิร์กโฟลว์แบบ Agentic เข้ากับแอปของคุณโดยตรง

ดูส่วนอื่นๆ ของชุดบล็อกโพสต์นี้
▪️ ส่วนที่ 1: ข้อมูลเบื้องต้นเกี่ยวกับแอปและภาพรวมระดับสูง
📱 ส่วนที่ 2: ข้อมูลอัจฉริยะในอุปกรณ์ เจาะลึก GenAI API ของ ML Kit และ Gemini Nano เพื่อสร้างฟีเจอร์ที่ให้ความสำคัญกับความเป็นส่วนตัวเป็นอันดับแรก เช่น การสรุปแผนการเดินทาง การแยกวิเคราะห์ใบเสร็จ และการประมวลผลเสียงในเครื่อง
☁️ ส่วนที่ 3: การให้เหตุผลแบบไฮบริดและระบบคลาวด์ สำรวจวิธีใช้ Firebase AI Logic เพื่ออิงคำตอบของ LLM กับข้อมูลในชีวิตจริง เช่น Google Maps และบริบทของเว็บ
⚙️ ตอนที่ 4: การผสานรวมระบบ การผสานรวมกับระบบอัจฉริยะของ Android โดยใช้ AppFunctions
🤖 ส่วนที่ 5 (โพสต์นี้) เวิร์กโฟลว์แบบ Agentic ในแอป ขยายขีดความสามารถของแอปด้วยผู้ช่วยการจองแบบครบวงจรที่ทำงานด้วย A2UI และ ADK

หากสนใจดูข้อมูลเพิ่มเติมเกี่ยวกับการพัฒนา Android ติดตามนักพัฒนาแอป Android บน YouTube หรือ LinkedIn

ข้อมูลโค้ดทั้งหมดในบล็อกโพสต์นี้เป็นไปตามการแจ้งเตือนลิขสิทธิ์ต่อไปนี้

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
เขียนโดย
อ่านต่อ