สร้างแอป Android อัจฉริยะ: ผสานรวมเข้ากับระบบอัจฉริยะของ Android โดยใช้ AppFunctions

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

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

ในบทความนี้ เราจะแสดงวิธีที่เราออกแบบและผสานรวมความสามารถเหล่านี้เข้ากับแอปวางแผนการเดินทาง JetPacker โดยใช้ Android AppFunctions เราจะสำรวจเหตุผลเบื้องหลังการเลือกฟีเจอร์ อธิบายเครื่องมือเฉพาะที่เราใช้เพื่อเร่งการพัฒนา และเจาะลึกโค้ดที่ทำให้ทุกอย่างทำงานได้

การออกแบบฟีเจอร์ที่พร้อมใช้งานกับ AI: การเลือกสิ่งที่สำคัญต่อผู้ใช้

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

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

นอกจากนี้ เรายังให้ความสำคัญกับการจัดการแผนการเดินทางด้วย การค้นหากิจกรรมถัดไปในแผนการเดินทางที่ยุ่งมักจะต้องเลื่อนดูมุมมองไทม์ไลน์ที่หนาแน่น การนำเสนอ getItinerary และ addItineraryEvent ให้กับระบบจะช่วยให้ผู้ใช้เพียงแค่ถามว่า "ฉันจะทำอะไรต่อไปในปารีส" และได้รับคำตอบทันที

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

Android MCP ที่ขับเคลื่อนโดย AppFunctions

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

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

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

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

วิธีที่เราเร่งการพัฒนาด้วยทักษะ AppFunctions

เราใช้ประโยชน์จากทักษะการพัฒนา AppFunctions เพื่อเพิ่มความคล่องตัวในกระบวนการผสานรวม ทักษะการพัฒนา AppFunctions เป็นเครื่องมือที่ช่วยในการพัฒนาที่สมบูรณ์ โดยจะแนะนำเราตลอดวงจรชีวิตทั้งหมด ได้แก่ การแมปคลาสข้อมูล Kotlin เพื่อแปลงพารามิเตอร์เป็นอนุกรม การสร้างจุดเริ่มต้น Service ที่จำเป็น การปรับแต่งเอกสาร KDoc เพื่อให้แน่ใจว่า LLM เข้าใจขอบเขตของพารามิเตอร์ และการตั้งค่าการทดสอบอัตโนมัติโดยใช้ ADB

การนำเสนอฟีเจอร์ของแอปให้กับระบบอัจฉริยะ

พูดถึงทฤษฎีกันมาพอแล้ว มาดูการใช้งานจริงกันเลย

การตั้งค่าการกำหนดค่าและการตั้งค่าทรัพยากร Dependency

เราเริ่มต้นด้วยการเพิ่มการขึ้นต่อกันของ AppFunctions โดยเพิ่มการขึ้นต่อกันสำหรับ API และการขึ้นต่อกันสำหรับคอมไพเลอร์การประมวลผลสัญลักษณ์ Kotlin

implementation("androidx.appfunctions:appfunctions:1.0.0-alpha10")
ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha10")

การสร้างโมเดลประเภทข้อมูลที่กำหนดเอง

ออบเจ็กต์ที่กำหนดเองใดๆ ที่แลกเปลี่ยนกับ Agent ต้องมีคำอธิบายประกอบด้วย @AppFunctionSerializable ในไฟล์ TripSerializable.kt เราจะกำหนดโมเดลข้อมูลการเดินทางดังนี้

@AppFunctionSerializable(isDescribedByKDoc = true)
data class TripSerializable(
    /** The trip's unique identifier. */
    val id: String,
    /** The trip's title. */
    val title: String,
    /** The trip's destination location. */
    val location: String,
    /** The trip's start date in milliseconds. */
    val startDate: Long,
    /** The trip's end date in milliseconds. */
    val endDate: Long,
    /** A list of participants. */
    val participants: List<String>,
)

การนำเสนอฟีเจอร์โดยใช้คำอธิบายประกอบ @AppFunction

จากนั้น ทักษะจะเขียนฟังก์ชัน Kotlin ที่ทำการค้นหาฐานข้อมูลและใส่คำอธิบายประกอบด้วย @AppFunction เราสามารถดูฟังก์ชันนี้ได้ใน searchTrip

/**
 * Looks for trips based on optional filters like id, title (name), location, and dates.
 *
 * @param id The unique identifier of the trip.
 * @param title The title or name of the trip.
 * @param location The destination location.
 * @param startDate The minimum start date in milliseconds.
 * @param endDate The maximum end date in milliseconds.
 * @return A list of trips matching the filters.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun searchTrip(
    id: String? = null,
    title: String? = null,
    location: String? = null,
    startDate: Long? = null,
    endDate: Long? = null
): List<TripSerializable> {
    return withContext(Dispatchers.IO) {
    // implementation
}

เนื่องจาก AppFunctions ทำงานในเธรด UI โดยค่าเริ่มต้น เราจึงใช้ withContext(Dispatchers.IO) เพื่อเปลี่ยนไปใช้ Dispatcher ในเบื้องหลัง นอกจากนี้ เรายังปรับแต่ง KDoc ให้ใช้กริยาที่ชัดเจนและเป็นคำสั่ง รวมถึงระบุข้อจำกัดของพารามิเตอร์ เอกสารนี้จะคอมไพล์เป็นสคีมาของเครื่องมือโดยตรง ซึ่ง Agent ที่มีสิทธิ์จะใช้เพื่อแก้ปัญหาพารามิเตอร์และจัดการข้อผิดพลาดขณะรันไทม์

จุดเริ่มต้นของบริการและการผสานรวม Hilt

หากต้องการลงทะเบียนฟีเจอร์เหล่านี้กับระบบอัจฉริยะ เราจะสร้างคลาสพื้นฐานนามธรรมที่ขยาย AppFunctionService และใส่คำอธิบายประกอบด้วย @AppFunctionServiceEntryPoint

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "JetPackerAppFunctionService",
    appFunctionXmlFileName = "jetpacker_app_function_service"
)
abstract class BaseJetPackerAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var tripDao: TripDao
    // DAOs and database references are injected here...
}

ระหว่างการคอมไพล์ KSP จะสร้างคลาสย่อยของบริการที่เป็นรูปธรรมสุดท้าย JetPackerAppFunctionService ตามที่ประกาศไว้ด้วยพารามิเตอร์ serviceName นอกจากนี้ เรายังลงทะเบียน app_metadata.xml ในไฟล์ Manifest ของแอปด้วย ไฟล์นี้มีกฎการทำงานส่วนกลางสำหรับ AppFunctions ที่ประกาศไว้ของ JetPacker

การทดสอบและยืนยัน AppFunctions

เมื่อใช้งานแล้ว คุณควรตรวจสอบว่า AppFunctions ได้รับการลงทะเบียนและทำงานอย่างถูกต้อง

หากใช้อุปกรณ์หรือโปรแกรมจำลองที่ใช้ Android 17 ขึ้นไป คุณสามารถใช้คำสั่ง ADB จากเทอร์มินัลเพื่อแสดงรายการและเรียกใช้ฟังก์ชันได้ การเรียกใช้ adb shell cmd app_function list-app-functions จะแสดงฟังก์ชันที่ลงทะเบียนไว้ทั้งหมดสำหรับแพ็กเกจของคุณ จากนั้นคุณสามารถเรียกใช้ฟังก์ชันที่เฉพาะเจาะจงและทดสอบการผสานรวมฐานข้อมูลได้โดยเรียกใช้ adb shell cmd app_function execute-app-function ขณะส่งสตริงพารามิเตอร์ JSON ดิบ

นอกจากคำสั่ง ADB เหล่านี้แล้ว คุณยังใช้ Agent ทดสอบ AppFunctions เพื่อตรวจสอบการกำหนดค่า แสดงรายการและเรียกใช้ AppFunctions รวมถึงดูลักษณะการทำงานของ AppFunctions ในโฟลวการสนทนาจริงได้ด้วย

สรุป

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

ประการแรก ทักษะการพัฒนา AppFunctions เป็นเครื่องมือที่จำเป็นสำหรับวงจรชีวิตการพัฒนาแอป ซึ่งช่วยให้คุณค้นพบฟีเจอร์ต่างๆ รวมถึงใช้งานและปรับแต่ง AppFunctions สำหรับแอปของคุณ ประการที่สอง ความคิดเห็น KDoc เป็นชิ้นงาน API ที่คอมไพล์แล้ว คำอธิบายพารามิเตอร์ที่ชัดเจนจะส่งผลโดยตรงต่อความแม่นยำในการดำเนินการของ Agent ของระบบ สุดท้าย Android MCP จะให้การดำเนินการแบบ Local-First ซึ่งช่วยให้แอปทำงานร่วมกับ Agent AI ได้อย่างปลอดภัย

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

ดูข้อมูลเพิ่มเติม

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

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

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

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0