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

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

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

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

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

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

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

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

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

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

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

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

Android 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, serviceName पैरामीटर के साथ एलान किए गए फ़ाइनल कॉन्क्रीट सर्विस सबक्लास, JetPackerAppFunctionService को जनरेट करता है. हम ऐप्लिकेशन के मेनिफ़ेस्ट में app_metadata.xml को भी रजिस्टर करते हैं. इस फ़ाइल में, JetPacker के ऐप्लिकेशन में शामिल AppFunctions के लिए, ग्लोबल ऑपरेशनल नियम दिए गए हैं.

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

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

Android 17 या इसके बाद के वर्शन वाले डिवाइसों या एम्युलेटर पर, टर्मिनल से एडीबी कमांड का इस्तेमाल करके, अपने फ़ंक्शन की सूची देखी जा सकती है और उन्हें शुरू किया जा सकता है. Running 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 के बारे में ज़्यादा जानें. जैसे, यात्रा की योजना की खास जानकारी, रसीद पार्स करना, और स्थानीय ऑडियो प्रोसेसिंग.
तीसरा हिस्सा: हाइब्रिड और क्लाउड रीज़निंग. जानें कि एलएलएम के जवाबों को Google Maps और वेब कॉन्टेक्स्ट जैसे असल दुनिया के डेटा के आधार पर तैयार करने के लिए, Firebase के एआई लॉजिक का इस्तेमाल कैसे किया जाता है.
चौथा हिस्सा (यह पोस्ट!): सिस्टम इंटिग्रेशन. AppFunctions का इस्तेमाल करके, Android के इंटेलिजेंस सिस्टम के साथ इंटिग्रेट करना.
पांचवां हिस्सा (जल्द ही उपलब्ध होगा): ऐप्लिकेशन में एजेंटिक वर्कफ़्लो. A2UI और ADK की मदद से, बुकिंग की पूरी प्रोसेस में मदद करने वाले एआई को ऐप्लिकेशन में शामिल करें.

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

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

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