इंटेलिजेंट Android ऐप्लिकेशन बनाना: AppFunctions का इस्तेमाल करके, Android के इंटेलिजेंस सिस्टम में इंटिग्रेट करना

ब्लॉग पोस्ट की सीरीज़ "इंटेलिजेंट Android ऐप्लिकेशन बनाना" में आपका स्वागत है. इस सीरीज़ में, हम एक सामान्य Android ऐप्लिकेशन को, उपयोगकर्ता के हिसाब से बनाया गया, इंटेलिजेंट, और एजेंटिक अनुभव देने वाले ऐप्लिकेशन में बदलेंगे. अपनी पिछली पोस्ट में, हमने क्लाउड पर होस्ट की जाने वाली और हाइब्रिड एआई सुविधाएं बनाने के लिए, Firebase AI Logic का इस्तेमाल करने के तरीके के बारे में बताया था.

मोबाइल के पारंपरिक यूज़र इंटरफ़ेस (यूआई), फ़ोकस किए गए, हाथों से किए जाने वाले टास्क में बेहतर होते हैं. वहीं, Android का इंटेलिजेंस सिस्टम, पूरक सुविधाएं लॉन्च कर रहा है, ताकि कई चरणों वाली मुश्किल कार्रवाइयों को और भी आसान बनाया जा सके. AppFunctions, पारंपरिक यूज़र इंटरफ़ेस (यूआई) के साथ मिलकर काम करते हैं. साथ ही, ये एक नया और बेहतर एंट्री पॉइंट उपलब्ध कराते हैं: डिवाइस पर मौजूद, खास अधिकारों वाला एजेंट, बैकग्राउंड में ऐप्लिकेशन की सुविधाओं को ऐक्सेस कर सकता है. यह सुविधा, खास तौर पर तब काम की होती है, जब उपयोगकर्ता ड्राइविंग कर रहे हों, पैदल चल रहे हों या एक साथ कई काम कर रहे हों.

इस लेख में, हम आपको बताएंगे कि हमने Android AppFunctions का इस्तेमाल करके, अपने ट्रैवल प्लानर ऐप्लिकेशन JetPacker में इन सुविधाओं को कैसे डिज़ाइन और इंटिग्रेट किया. हम सुविधाओं को चुनने की वजहों के बारे में जानेंगे. साथ ही, डेवलपमेंट की प्रोसेस को तेज़ करने के लिए इस्तेमाल किए गए खास टूल के बारे में चर्चा करेंगे. इसके अलावा, हम उस कोड के बारे में भी जानेंगे जिसकी मदद से ये सुविधाएं काम करती हैं.

एआई के साथ काम करने वाली सुविधाएं डिज़ाइन करना: उपयोगकर्ताओं के लिए काम की सुविधाएं चुनना

इंटेलिजेंस सिस्टम को कौनसी सुविधाएं देनी हैं, यह तय करने के लिए, हमने ऐसे टास्क देखे जिनमें स्क्रीन पर टैप करने के बजाय, आवाज़ या टेक्स्ट वाले निर्देश का इस्तेमाल करना ज़्यादा तेज़ होता है. साइड-बाय-साइड स्क्रीन रिकॉर्डिंग में, आपको यह अंतर साफ़ तौर पर दिखेगा: बाईं ओर, एक उपयोगकर्ता खर्च लॉग करने के लिए कई स्क्रीन पर टैप कर रहा है. वहीं, दाईं ओर, खास अधिकारों वाले एजेंट की मदद से, वही टास्क बैकग्राउंड में तुरंत पूरा हो गया.

हमारी पहली पसंद, खर्च ट्रैक करने की सुविधा थी. आम तौर पर, यात्रा के दौरान कॉफ़ी का खर्च लॉग करने के लिए, कई बार टैप करना पड़ता है. जैसे—फ़ोन अनलॉक करना, ऐप्लिकेशन खोलना, चालू यात्रा ढूंढना, खर्च वाले टैब पर जाना, जोड़ें बटन पर टैप करना, रसीद की फ़ोटो लेना, और नतीजे देखना. addExpense और getExpenses सुविधाओं को AppFunctions के तौर पर उपलब्ध कराने से, सिस्टम एजेंट, मुश्किल टास्क को आसानी से मैनेज कर लेता है. जब उपयोगकर्ता कहता है, "मेरी पेरिस यात्रा में पांच डॉलर का कॉफ़ी का खर्च जोड़ो", तो एजेंट, बैकग्राउंड में सही यात्रा आईडी अपने-आप खोज लेता है और खर्च जोड़ देता है. इससे, यूज़र इंटरफ़ेस (यूआई) के ज़रिए मैन्युअल तरीके से खर्च जोड़ने की ज़रूरत नहीं पड़ती.

हमने यात्रा कार्यक्रम को मैनेज करने की सुविधा को भी प्राथमिकता दी. आम तौर पर, यात्रा के व्यस्त कार्यक्रम में अगली गतिविधि ढूंढने के लिए, टाइमलाइन व्यू को स्क्रोल करना पड़ता है. सिस्टम को getItinerary और addItineraryEvent की सुविधाएं देने से, उपयोगकर्ता सिर्फ़ यह पूछ सकता है, "पेरिस में मेरी अगली गतिविधि क्या है?" और उसे तुरंत जवाब मिल जाता है.

आखिर में, हमने बिना हाथ इस्तेमाल किए नोट कैप्चर करने की सुविधा पर फ़ोकस किया. किसी व्यस्त सड़क पर चलते समय, रिमाइंडर या नोट टाइप करना मुश्किल और असुरक्षित होता है. आवाज़ वाले नोट की सुविधा उपलब्ध कराने से, उपयोगकर्ता कह सकता है, "फ़्लाइट शानदार थी, मैंने एक खूबसूरत सनसेट देखा और मुझे अच्छी नींद आई." इसके बाद, खास अधिकारों वाला एजेंट, addVoiceNote AppFunction का इस्तेमाल करके, इसे अपने-आप ट्रांसक्राइब करता है और सीधे ट्रैवल डेटाबेस में सेव कर लेता है.

AppFunctions की मदद से काम करने वाला Android MCP

यह पूरा अनुभव, Android MCP पर आधारित है. इस डिज़ाइन के तहत, ऐप्लिकेशन, लोकल MCP सर्वर के तौर पर काम करता है. रिमोट एपीआई के बजाय, अपने ऐप्लिकेशन की सुविधाएं सीधे उपयोगकर्ता के डिवाइस पर मौजूद इंटेलिजेंस सिस्टम को दें.

Android AppFunctions, वह एपीआई है जो इस कॉन्सेप्ट को हकीकत में बदलता है. यह एनोटेट किए गए Kotlin फ़ंक्शन को पढ़ता है और उन्हें टाइप-सेफ़, सैंडबॉक्स वाले टूल की परिभाषाओं में कंपाइल करता है. खास अधिकारों वाला एजेंट, डिवाइस पर इन्हें स्थानीय तौर पर खोज सकता है और चालू कर सकता है.

Android MCP मॉडल के तहत, आपका ऐप्लिकेशन, लोकल MCP सर्वर के तौर पर काम करता है. यह स्ट्रक्चर्ड टूल उपलब्ध कराता है. वहीं, Android प्लैटफ़ॉर्म, सेंट्रल टूल रजिस्ट्री के तौर पर काम करता है. एमसीपी क्लाइंट साइड पर, एजेंट ऐप्लिकेशन को रजिस्ट्री ऐक्सेस करने के लिए, सिस्टम के खास अधिकारों वाली अनुमतियां मिलने के बाद, इंटेलिजेंस सिस्टम के साथ रजिस्टर किया जाता है.

जब कोई उपयोगकर्ता, रजिस्टर किए गए एजेंट के साथ इंटरैक्ट करता है, तो उसका एलएलएम यह तय करता है कि अनुरोध को AppFunction से मैनेज किया जा सकता है या नहीं. इसके बाद, यह प्लैटफ़ॉर्म के मेटाडेटा के लिए क्वेरी करता है और बैकग्राउंड में रजिस्टर किए गए ज़रूरी फ़ंक्शन को चालू करता है. लोकल एमसीपी क्लाइंट-सर्वर डिज़ाइन से, आपको पूरा कंट्रोल मिलता है: आप तय करते हैं कि एजेंट को किन सुविधाओं का ऐक्सेस मिलेगा. साथ ही, आपके ऐप्लिकेशन का बाकी डेटा निजी रहता है.

Android की सुविधाओं की मदद से, डेवलपमेंट की प्रोसेस को तेज़ करना

इंटिग्रेशन की प्रोसेस को आसान बनाने के लिए, हमने AppFunctions डेवलपमेंट स्किल का इस्तेमाल किया. AppFunctions डेवलपमेंट स्किल, डेवलपमेंट में पूरी मदद करती है. इसने हमें पूरी लाइफ़साइकल में गाइड किया: पैरामीटर को क्रम से लगाने के लिए, Kotlin डेटा क्लास को मैप करना, ज़रूरी Service एंट्री पॉइंट जनरेट करना, KDoc दस्तावेज़ को बेहतर बनाना, ताकि एलएलएम, पैरामीटर की सीमाओं को समझ सके, और ADB का इस्तेमाल करके, ऑटोमेटेड टेस्टिंग सेट अप करना.

इंटेलिजेंस सिस्टम को ऐप्लिकेशन की सुविधाएं उपलब्ध कराना

अब थ्योरी के बारे में काफ़ी बात हो गई. चलिए, अब इसे लागू करने के तरीके के बारे में जानते हैं.

कॉन्फ़िगरेशन और डिपेंडेंसी सेट अप करना

हम AppFunctions की डिपेंडेंसी जोड़कर शुरुआत करते हैं. एक एपीआई के लिए और एक 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, डिफ़ॉल्ट रूप से यूज़र इंटरफ़ेस (यूआई) थ्रेड पर चलते हैं. इसलिए, हम बैकग्राउंड डिस्पैचर पर स्विच करने के लिए, 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 को भी रजिस्टर करते हैं. इस फ़ाइल में, JetPacker के तय किए गए AppFunctions के लिए, ग्लोबल ऑपरेशनल नियम दिए जाते हैं.

अपने AppFunctions को टेस्ट करना और उनकी पुष्टि करना

इन्हें लागू करने के बाद, आपको यह पुष्टि करनी चाहिए कि आपके AppFunctions रजिस्टर हो गए हैं और सही तरीके से काम कर रहे हैं.

Android 17 या उससे नए वर्शन वाले डिवाइस या एम्युलेटर पर, अपने टर्मिनल से ADB कमांड का इस्तेमाल करके, अपने फ़ंक्शन की सूची देखी जा सकती है और उन्हें चालू किया जा सकता है. adb shell cmd app_function list-app-functions चलाने पर, आपके पैकेज के लिए रजिस्टर किए गए सभी फ़ंक्शन दिखते हैं. इसके बाद, किसी खास फ़ंक्शन को चालू किया जा सकता है और उसके डेटाबेस इंटिग्रेशन को टेस्ट किया जा सकता है. इसके लिए, रॉ JSON पैरामीटर स्ट्रिंग पास करते समय, adb shell cmd app_function execute-app-function चलाएं.

इन ADB कमांड के बजाय, AppFunctions Testing Agent का इस्तेमाल करके भी, अपने कॉन्फ़िगरेशन की जांच की जा सकती है. साथ ही, AppFunctions की सूची देखी जा सकती है, उन्हें चालू किया जा सकता है. इसके अलावा, यह भी देखा जा सकता है कि बातचीत के असल फ़्लो में, आपके AppFunctions कैसे काम करते हैं.

रैप अप

AppFunctions का इस्तेमाल करके, इंटेलिजेंस सिस्टम में योगदान देने के लिए, ऐप्लिकेशन की सुविधाओं के बारे में सोचते समय, हमें कोड और दस्तावेज़ के बारे में सोचने के तरीके में थोड़ा बदलाव करना पड़ता है. AppFunctions की मदद से, ऐप्लिकेशन के लिए इस नए इंटरैक्शन मॉडल का इस्तेमाल किया जा सकता है. इससे, एजेंट का इस्तेमाल करके ऐप्लिकेशन की सुविधाओं को ऐक्सेस किया जा सकता है.

पहला, AppFunctions डेवलपमेंट स्किल, लाइफ़साइकल का एक ज़रूरी टूल है. इससे आपको अपने ऐप्लिकेशन के लिए सुविधाएं ढूंढने, AppFunctions को लागू करने, और उन्हें बेहतर बनाने में मदद मिलती है. दूसरा, KDoc टिप्पणियां, कंपाइल किया गया एपीआई ऐसेट होती हैं. पैरामीटर की साफ़ तौर पर दी गई जानकारी से, सिस्टम एजेंट की परफ़ॉर्मेंस की सटीक जानकारी मिलती है. आखिर में, Android MCP, लोकल-फ़र्स्ट एक्ज़ीक्यूशन उपलब्ध कराता है. इससे ऐप्लिकेशन, एआई एजेंट के साथ सुरक्षित तरीके से मिलकर काम कर सकते हैं.

AppFunctions के ज़रिए, ऐप्लिकेशन की सुविधाएं उपलब्ध कराने से, आपका ऐप्लिकेशन, इंटेलिजेंस सिस्टम के लिए तैयार हो जाता है. हमें बताएं कि एजेंटिक युग के लिए, अपने ऐप्लिकेशन को कैसे अडैप्ट कर रहे हैं!

ज़्यादा जानें

ब्‍लॉग पोस्‍ट की इस सीरीज़ के अन्य हिस्से देखें:
पहला हिस्सा: ऐप्लिकेशन का परिचय और खास जानकारी.
दूसरा हिस्सा: उपयोगकर्ता के डिवाइस पर मौजूद इंटेलिजेंस. निजता को प्राथमिकता देने वाली सुविधाएं बनाने के लिए, ML Kit के GenAI API और Gemini Nano के बारे में ज़्यादा जानें. जैसे, यात्रा कार्यक्रम की खास जानकारी, रसीद पार्स करना, और लोकल ऑडियो प्रोसेसिंग.
तीसरा हिस्सा: हाइब्रिड और क्लाउड रीज़निंग. Firebase AI Logic का इस्तेमाल करके, एलएलएम के जवाबों को असल दुनिया के डेटा में शामिल करने का तरीका जानें. जैसे, Google Maps और वेब कॉन्टेक्स्ट.
चौथा हिस्सा (यह पोस्ट!): सिस्टम इंटिग्रेशन. AppFunctions का इस्तेमाल करके, Android के इंटेलिजेंस सिस्टम के साथ इंटिग्रेट करना.
पांचवा हिस्सा (जल्द ही उपलब्ध होगा): इन-ऐप्लिकेशन एजेंटिक वर्कफ़्लो. A2UI और ADK की मदद से, बुकिंग असिस्टेंट को ऐप्लिकेशन में जोड़ना. इससे, बुकिंग की प्रोसेस को पूरी तरह से मैनेज किया जा सकेगा.

क्या आपको Android डेवलपमेंट के बारे में ज़्यादा जानना है? YouTube या LinkedIn पर Android Developers को फ़ॉलो करें!

इस ब्लॉग पोस्ट में दिए गए सभी कोड स्निपेट, कॉपीराइट से जुड़े इस नोटिस का पालन करते हैं:

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