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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

เราใช้ทักษะการพัฒนา 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")

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

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

จุดแรกเข้าของบริการและการผสานรวม 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 ของแอปด้วย ไฟล์นี้มีกฎการปฏิบัติงานทั่วโลกสำหรับ AppFunction ที่ประกาศของ JetPacker

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

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

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

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

สรุป

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

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

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

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

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

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

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

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