Membangun aplikasi Android cerdas: Mengintegrasikan ke dalam sistem kecerdasan Android menggunakan AppFunctions

Selamat datang kembali di seri postingan blog "Membangun aplikasi Android cerdas" tempat kita mengambil aplikasi Android dasar dan mengubahnya menjadi pengalaman yang dipersonalisasi, cerdas, dan agentik. Dalam postingan sebelumnya, kami membahas cara memanfaatkan Firebase AI Logic untuk membangun fitur AI hybrid dan yang dihosting di cloud.

UI seluler tradisional unggul dalam tugas yang fokus dan langsung, dan sistem kecerdasan Android memperkenalkan fitur pelengkap untuk mempermudah tindakan multi-langkah yang kompleks. Dengan melengkapi antarmuka pengguna tradisional, AppFunctions menyediakan titik entri baru yang efektif: Agen yang memiliki hak istimewa di perangkat dapat mengakses fitur aplikasi di latar belakang. Hal ini dapat sangat membantu saat pengguna sedang mengemudi, berjalan, atau melakukan multitasking.

Dalam artikel ini, kami akan menunjukkan cara kami mendesain dan mengintegrasikan kemampuan ini ke dalam aplikasi perencanaan perjalanan kami, JetPacker, menggunakan AppFunction Android. Kita akan mempelajari alasan di balik pilihan fitur kami, membahas alat khusus yang kami gunakan untuk mempercepat pengembangan, dan mempelajari kode yang membuat semuanya berfungsi.

Mendesain fitur yang siap AI: membuat pilihan yang penting bagi pengguna Anda

Untuk memilih fitur mana yang akan diberikan ke sistem kecerdasan, kami mencari tugas yang perintah suara atau teksnya secara objektif lebih cepat daripada mengetuk layar. Dalam rekaman layar berdampingan ini, Anda dapat melihat kontras ini dengan sempurna: di sebelah kiri, pengguna mengetuk beberapa layar untuk mencatat pengeluaran; di sebelah kanan, tugas yang sama diselesaikan secara instan di latar belakang melalui agen istimewa.

Pilihan pertama kami adalah pelacakan pengeluaran. Mencatat pengeluaran kopi selama perjalanan biasanya memerlukan beberapa ketukan—membuka kunci ponsel, membuka aplikasi, menemukan perjalanan aktif, membuka tab pengeluaran, mengetuk tombol tambah, mengambil foto tanda terima, dan memeriksa hasilnya. Dengan menyediakan fitur addExpense dan getExpenses sebagai AppFunction, agen sistem akan menangani pekerjaan beratnya. Saat pengguna mengatakan, "Tambahkan pengeluaran kopi lima dolar ke perjalanan saya ke Paris", agen akan otomatis menelusuri ID perjalanan yang benar di latar belakang dan memasukkan pengeluaran, sehingga sepenuhnya melewati alur UI manual.

Kami juga memprioritaskan pengelolaan itinerari. Menemukan aktivitas berikutnya dalam rencana perjalanan yang padat biasanya memerlukan penelusuran melalui tampilan linimasa yang padat. Dengan memberikan getItinerary dan addItineraryEvent ke sistem, pengguna dapat dengan mudah bertanya, "Apa yang akan saya lakukan selanjutnya di Paris?" dan mendapatkan jawaban langsung.

Terakhir, kami berfokus pada pengambilan catatan hands-free. Mengetik pengingat atau catatan sambil berjalan di jalan yang ramai akan sulit dan tidak aman. Mengekspos kemampuan catatan suara memungkinkan pengguna mengatakan, "Penerbangannya luar biasa, saya melihat matahari terbenam yang indah dan berhasil tidur nyenyak", dan agen istimewa secara otomatis mentranskripsikan dan menyimpannya langsung ke dalam database perjalanan  menggunakan addVoiceNote AppFunction.

MCP Android yang didukung oleh AppFunctions

Seluruh pengalaman ini dibangun di MCP Android. Dengan desain ini, aplikasi bertindak sebagai server MCP lokal. Daripada API jarak jauh, Anda menyediakan fitur aplikasi secara langsung ke sistem kecerdasan di perangkat.

Android AppFunctions adalah API yang mewujudkan konsep ini. Library ini membaca fungsi Kotlin yang diberi anotasi dan mengompilasinya menjadi definisi alat yang aman untuk jenis dan di-sandbox yang dapat ditemukan dan dipanggil oleh agen yang memiliki hak istimewa secara lokal di perangkat.

Dalam model MCP Android, aplikasi Anda bertindak sebagai server MCP lokal yang mengekspos alat terstruktur, sementara platform Android berfungsi sebagai pendaftaran alat pusat. Di sisi klien MCP, aplikasi agen didaftarkan ke sistem kecerdasan setelah diberi izin dengan akses sistem untuk mengakses registri.

Saat pengguna berinteraksi dengan agen terdaftar, LLM-nya akan menentukan apakah permintaan dapat ditangani oleh AppFunction, mengkueri metadata platform, dan mengeksekusi fungsi terdaftar yang sesuai di latar belakang. Desain client-server MCP lokal ini memberi Anda kontrol penuh: Anda dapat memilih fitur mana saja yang dapat diakses oleh agen, sehingga data aplikasi Anda yang lain tetap bersifat pribadi.

Cara kami mempercepat pengembangan dengan keterampilan Android

Untuk menyederhanakan proses integrasi, kami memanfaatkan keterampilan pengembangan AppFunctions. Keahlian pengembangan AppFunctions adalah pendamping pengembangan yang lengkap. Panduan ini memandu kami melalui seluruh siklus proses: memetakan class data Kotlin untuk membuat serialisasi parameter, membuat titik entri Service yang diperlukan, menyempurnakan dokumentasi KDoc untuk memastikan LLM memahami batas parameter, dan menyiapkan pengujian otomatis menggunakan ADB.

Menyediakan fitur aplikasi ke sistem kecerdasan

Cukup dengan teorinya, mari kita bahas penerapannya.

Penyiapan konfigurasi dan dependensi

Kita mulai dengan menambahkan dependensi AppFunctions. Satu untuk API dan satu untuk compiler Pemrosesan Simbol Kotlin.

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

Membuat model jenis data kustom

Setiap objek kustom yang dipertukarkan dengan agen harus diberi anotasi dengan @AppFunctionSerializable. Dalam file TripSerializable.kt, kita menentukan model data perjalanan:

@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>,
)

Menyediakan fitur menggunakan anotasi @AppFunction

Selanjutnya, skill menulis fungsi Kotlin yang melakukan kueri database dan menganotasinya dengan @AppFunction. Kita dapat melihatnya di 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
}

Karena AppFunctions berjalan di UI thread secara default, kita menggunakan withContext(Dispatchers.IO) untuk beralih ke dispatcher latar belakang. Selain itu, kami menyempurnakan KDoc kami untuk menggunakan kata kerja imperatif yang jelas dan menentukan batasan parameter. Dokumentasi ini dikompilasi langsung ke dalam skema alat, yang digunakan oleh agen istimewa untuk menyelesaikan parameter dan menangani error runtime.

Titik entri layanan dan integrasi Hilt

Untuk mendaftarkan fitur ini ke sistem kecerdasan, kita membuat class dasar abstrak yang memperluas AppFunctionService. Kita menganotasinya dengan @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...
}

Selama kompilasi, KSP menghasilkan subclass layanan konkret akhir, JetPackerAppFunctionService, seperti yang dideklarasikan dengan parameter serviceName. Kita juga mendaftarkan app_metadata.xml dalam manifes aplikasi. File ini menyediakan aturan operasional global untuk AppFunction yang dideklarasikan JetPacker.

Menguji dan memverifikasi AppFunctions

Setelah diimplementasikan, Anda harus memverifikasi bahwa AppFunctions Anda terdaftar dan berfungsi dengan benar.

Menjalankan perangkat atau emulator dengan Android 17 atau yang lebih baru, Anda dapat menggunakan perintah ADB dari terminal untuk mencantumkan dan memanggil fungsi. Menjalankan adb shell cmd app_function list-app-functions akan menampilkan semua fungsi terdaftar untuk paket Anda. Kemudian, Anda dapat menjalankan fungsi tertentu dan menguji integrasi databasenya dengan menjalankan adb shell cmd app_function execute-app-function sambil meneruskan string parameter JSON mentah.

Selain perintah ADB ini, Anda juga dapat menggunakan Agen Pengujian AppFunctions untuk memeriksa konfigurasi, mencantumkan dan menjalankan AppFunctions, serta melihat perilaku AppFunctions dalam alur percakapan yang sebenarnya.

Menyelesaikan

Saat memikirkan fitur aplikasi yang dapat disumbangkan ke sistem kecerdasan menggunakan AppFunctions, kita perlu sedikit mengubah cara kita memikirkan kode dan dokumentasi. AppFunctions memungkinkan Anda menggunakan model interaksi baru ini untuk aplikasi, yang memungkinkan penggunaan agen untuk mengakses fitur aplikasi.

Pertama, keterampilan pengembangan AppFunctions adalah alat siklus proses penting, yang membantu Anda menemukan fitur, menerapkan, dan menyempurnakan AppFunctions untuk aplikasi Anda. Kedua, komentar KDoc adalah aset API yang dikompilasi; deskripsi parameter yang jelas secara langsung memengaruhi akurasi eksekusi agen sistem. Terakhir, MCP Android menyediakan eksekusi yang mengutamakan lokalitas sehingga aplikasi dapat berkolaborasi dengan aman dengan agen AI.

Menyumbangkan fitur aplikasi melalui AppFunctions membuat aplikasi Anda siap untuk sistem kecerdasan. Beri tahu kami cara Anda mengadaptasi aplikasi untuk era agentik.

Pelajari lebih lanjut

Baca bagian lain dari rangkaian postingan blog ini:
Bagian 1: Pengenalan aplikasi dan ringkasan tingkat tinggi.
Bagian 2: Kecerdasan di perangkat. Pelajari lebih dalam API GenAI ML Kit dan Gemini Nano untuk membangun fitur yang mengutamakan privasi seperti ringkasan itinerari, penguraian tanda terima, dan pemrosesan audio lokal.
Bagian 3: Penalaran hybrid dan cloud. Pelajari cara menggunakan Firebase AI Logic untuk mendasarkan jawaban LLM pada data dunia nyata seperti Google Maps dan konteks web.
Bagian 4 (postingan ini): Integrasi sistem. Mengintegrasikan dengan sistem kecerdasan Android menggunakan AppFunctions.
Bagian 5 (segera hadir): Alur kerja agentik dalam aplikasi. Perluas aplikasi dengan asisten pemesanan menyeluruh yang didukung oleh A2UI dan ADK.

Tertarik dengan Pengembangan Android lainnya? Ikuti Android Developers di YouTube atau LinkedIn.

Semua cuplikan kode dalam postingan blog ini mengikuti pemberitahuan hak cipta berikut:

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