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

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

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

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

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

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

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

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

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

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

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

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

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

כשמשתמש מקיים אינטראקציה עם סוכן רשום, מודל ה-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) כדי לעבור ל-dispatcher של הרקע. בנוסף, אנחנו משפרים את ה-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 development skill הוא כלי חיוני למחזור החיים של האפליקציה, שעוזר לכם לגלות תכונות, להטמיע ולשפר את AppFunctions באפליקציות שלכם. שנית, הערות KDoc הן נכס API שעובר קומפילציה. תיאורים ברורים של פרמטרים משפיעים ישירות על דיוק הביצוע של סוכן המערכת. לבסוף, Android MCP מספקת ביצוע מקומי ראשון שמאפשר לאפליקציות לשתף פעולה בבטחה עם סוכני AI.

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

מידע נוסף

מומלץ לעיין בחלקים האחרים בסדרת הפוסטים הזו בבלוג:
חלק 1: מבוא לאפליקציה וסקירה כללית.
חלק 2: טכנולוגיית AI במכשיר. הסבר מפורט על ממשקי ה-API של GenAI ב-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