פיתוח אפליקציות חכמות ל-Android: שילוב במערכת החכמה של Android באמצעות AppFunctions

ברוכים השבים לסדרת הפוסטים בבלוג בנושא פיתוח אפליקציות חכמות ל-Android. בסדרה הזו אנחנו לוקחים אפליקציית Android בסיסית והופכים אותה לחוויה מותאמת אישית, חכמה ודינמית. בפוסט הקודם הסברנו איך להשתמש ב-Firebase AI Logic כדי ליצור תכונות AI שמתארחות בענן ותכונות AI היברידיות.

ממשקי משתמש מסורתיים לנייד מצטיינים במשימות ממוקדות ומעשיות, ומערכת ה-AI של Android מציגה תכונות משלימות כדי להקל עוד יותר על פעולות מורכבות שמורכבות מכמה שלבים. בנוסף לממשקי משתמש רגילים, AppFunctions מספקות נקודת כניסה חדשה ורבת-עוצמה: סוכן עם הרשאות במכשיר יכול לגשת לתכונות של האפליקציה ברקע. האפשרות הזו יכולה להיות שימושית במיוחד כשמשתמשים נוהגים, הולכים או מבצעים כמה משימות בו-זמנית.

במאמר הזה נסביר איך תכננו ושילבנו את היכולות האלה באפליקציה שלנו לתכנון נסיעות, JetPacker, באמצעות Android AppFunctions. נסביר את ההיגיון מאחורי הבחירות שלנו לגבי התכונות, נדון בכלים המיוחדים שבהם השתמשנו כדי להאיץ את הפיתוח ונצלול אל הקוד שגורם לכל זה לעבוד.

תכנון תכונות שמוכנות ל-AI: קבלת החלטות חשובות למשתמשים

כדי לבחור אילו תכונות לספק למערכת ה-AI, חיפשנו משימות שבהן פקודה קולית או פקודת טקסט מהירה יותר באופן אובייקטיבי מהקשה על המסך. בצילום המסך הזה, שבו רואים את שני הצדדים זה לצד זה, אפשר לראות את ההבדל בצורה ברורה: בצד ימין, משתמש מקיש על כמה מסכים כדי לרשום הוצאה; בצד שמאל, אותה משימה הושלמה באופן מיידי ברקע באמצעות סוכן עם הרשאות מיוחדות.

הבחירה הראשונה שלנו הייתה מעקב אחר הוצאות. כדי לרשום הוצאה על קפה במהלך נסיעה, בדרך כלל צריך לבצע כמה פעולות – לפתוח את הטלפון, לפתוח את האפליקציה, למצוא את הנסיעה הפעילה, לעבור לכרטיסיית ההוצאות, ללחוץ על לחצן ההוספה, לצלם את הקבלה ולבדוק את התוצאה. הסוכן של המערכת מטפל בעבודה הקשה, כי התכונות addExpense ו-getExpenses מסופקות כ-AppFunctions. כשהמשתמש אומר "תוסיף הוצאה של חמישה דולר על קפה לטיול שלי בפריז", הסוכן מחפש אוטומטית את מזהה הטיול הנכון ברקע ומוסיף את ההוצאה, בלי להשתמש בכלל בתהליך הממשק הידני.

נתנו עדיפות גם לניהול מסלול הנסיעה. כדי למצוא איזו פעילות מתוכננת בהמשך מסלול הנסיעה העמוס, בדרך כלל צריך לגלול בתצוגת ציר זמן צפופה. אם המשתמש מספק למערכת את getItinerary וaddItineraryEvent, הוא יכול פשוט לשאול "מה אני עושה עכשיו בפריז?" ולקבל תשובה מיידית.

בסוף, התמקדנו בתיעוד הערות ללא מגע. קשה ולא בטוח להקליד תזכורות או הערות בזמן הליכה ברחוב הומה. הוספת אפשרות לפתק עם אודיו מאפשרת למשתמש להגיד: "הטיסה הייתה מדהימה, ראיתי שקיעה יפה והצלחתי לישון טוב", והסוכן בעל ההרשאות מתמלל ושומר אותה אוטומטית ישירות במסד הנתונים של הנסיעות באמצעות הפונקציה addVoiceNote של האפליקציה.

‫Android MCP מופעל על ידי AppFunctions

כל החוויה הזו מבוססת על Android MCP. במסגרת העיצוב הזה, האפליקציה פועלת כשרת MCP מקומי. במקום ממשקי API מרחוק, אתם מספקים את התכונות של האפליקציה ישירות למערכת הבינה המלאכותית במכשיר.

Android AppFunctions הוא ה-API שמממש את הרעיון הזה. הוא קורא פונקציות Kotlin עם הערות ומקמפל אותן להגדרות כלים בטוחות מבחינת סוגים, שנמצאות בארגז חול. הסוכן עם ההרשאות יכול לגלות אותן ולהפעיל אותן באופן מקומי במכשיר.

במודל Android MCP, האפליקציה פועלת כשרת MCP מקומי שחושף כלים מובנים, בעוד פלטפורמת Android משמשת כמאגר מרכזי של כלים. בצד הלקוח של MCP, אפליקציות של סוכנים נרשמות במערכת המודיעין אחרי שניתנות להן הרשאות עם הרשאות מערכת לגישה לרישום.

כשמשתמש מקיים אינטראקציה עם סוכן רשום, מודל ה-LLM שלו קובע אם אפשר לטפל בבקשה באמצעות AppFunction, שולח שאילתות למטא-נתונים של הפלטפורמה ומבצע את הפונקציות הרשומות המתאימות ברקע. העיצוב המקומי של שרת-לקוח MCP מאפשר לכם שליטה מלאה: אתם בוחרים בדיוק אילו תכונות יהיו נגישות לסוכן, כך ששאר הנתונים באפליקציה יישארו פרטיים.

איך האצנו את הפיתוח בעזרת מיומנויות Android

כדי לייעל את תהליך השילוב, השתמשנו במיומנות הפיתוח AppFunctions. הכישורים לפיתוח AppFunctions הם כלי עזר מלא לפיתוח. הוא הנחה אותנו לאורך כל מחזור החיים: מיפוי מחלקות נתונים של Kotlin לסריאליזציה של פרמטרים, יצירת Service נקודות הכניסה הנדרשות, שיפור התיעוד של KDoc כדי להבטיח שה-LLM יבין את גבולות הפרמטרים והגדרת בדיקות אוטומטיות באמצעות ADB.

אספקת תכונות של האפליקציה למערכת ה-AI

מספיק עם התיאוריה, בואו נתחיל ליישם.

הגדרה והגדרת תלות

מתחילים בהוספת התלויות של AppFunctions. אחד בשביל ה-API ואחד בשביל מהדר Kotlin Symbol Processing.

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 במניפסט של האפליקציה. הקובץ הזה מספק כללים תפעוליים גלובליים ל-AppFunctions שהוצהרו ב-JetPacker.

בדיקה ואימות של AppFunctions

אחרי ההטמעה, צריך לוודא שפונקציות האפליקציה רשומות ופועלות בצורה תקינה.

במכשירים או באמולטורים עם Android 17 ואילך, אפשר להשתמש בפקודות ADB מהטרמינל כדי להציג את הפונקציות ולהפעיל אותן. הפעלת הפקודה adb shell cmd app_function list-app-functions מציגה את כל הפונקציות הרשומות בחבילה. אחר כך אפשר להריץ פונקציה ספציפית ולבדוק את השילוב שלה עם מסד הנתונים באמצעות הפקודה adb shell cmd app_function execute-app-function, תוך העברת מחרוזת פרמטרים של JSON גולמי.

במקום פקודות ה-ADB האלה, אפשר גם להשתמש ב-AppFunctions Testing Agent כדי לבדוק את ההגדרה, להציג רשימה של AppFunctions ולהפעיל אותן, ואפילו לראות איך ה-AppFunctions מתנהגות בזרימת שיחה אמיתית.

סיכום

כדי להשתמש ב-AppFunctions, צריך לשנות קצת את הגישה שלנו לגבי קוד ותיעוד. התכונה AppFunctions מאפשרת לכם להשתמש במודל האינטראקציה החדש הזה באפליקציות, וכך להשתמש בסוכן כדי לגשת לתכונות של האפליקציה.

קודם כל, הכלי AppFunctions לפיתוח הוא כלי חיוני למחזור החיים של האפליקציה. הוא עוזר לכם לגלות תכונות, להטמיע את AppFunctions באפליקציות ולשפר אותן. שנית, הערות KDoc הן נכס API שעובר קומפילציה. תיאורים ברורים של פרמטרים משפיעים ישירות על דיוק הביצוע של סוכן המערכת. לבסוף, Android MCP מספקת הרצה מקומית ראשונה שמאפשרת לאפליקציות לשתף פעולה בבטחה עם סוכני AI.

הוספת תכונות של אפליקציות באמצעות AppFunctions מאפשרת לאפליקציה שלכם להיות מוכנה למערכת ה-AI. נשמח לשמוע איך אתם מתאימים את האפליקציות שלכם לעידן סוכני ה-AI.

מידע נוסף

מומלץ לעיין בחלקים האחרים בסדרת הפוסטים הזו בבלוג:
חלק 1: מבוא לאפליקציה וסקירה כללית.
חלק 2: אינטליגנציה במכשיר. התעמקות בממשקי ה-API של AI גנרטיבי ב-ML Kit וב-Gemini Nano כדי ליצור תכונות שמתמקדות בשמירה על הפרטיות, כמו סיכום מסלול טיול, ניתוח קבלות ועיבוד אודיו מקומי.
חלק 3: היגיון היברידי והיגיון בענן. במאמר הזה נסביר איך להשתמש ב-Firebase AI Logic כדי להציג תשובות של מודלים גדולים של שפה (LLM) שמבוססות על נתונים מהעולם האמיתי, כמו נתונים מ-Google Maps ומהאינטרנט.
חלק 4 (המאמר הזה): שילוב מערכות. שילוב עם מערכת ה-AI של Android באמצעות AppFunctions.
חלק 5 (בקרוב): תהליכי עבודה של סוכנים בתוך האפליקציה. הרחבת האפליקציה באמצעות עוזר הזמנות מקצה לקצה שמבוסס על A2UI ו-ADK.

רוצים לקבל מידע נוסף על פיתוח ל-Android? אפשר לעקוב אחרי Android Developers ב-YouTube או ב-LinkedIn.

כל קטעי הקוד בפוסט הזה בבלוג כוללים את הודעת זכויות היוצרים הבאה:

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