इस पेज का अनुवाद Cloud Translation API से किया गया है.

इंटेंट और इंटेंट फ़िल्टर

Intent एक मैसेज ऑब्जेक्ट है. इसका इस्तेमाल, किसी कार्रवाई का अनुरोध करने के लिए किया जा सकता है किसी दूसरे ऐप्लिकेशन कॉम्पोनेंट से हटाएं. इंटेंट, कॉम्पोनेंट के बीच कई तरीकों से कम्यूनिकेशन की सुविधा देते हैं. हालांकि, इनका इस्तेमाल करने के तीन मुख्य उदाहरण हैं:

कोई गतिविधि शुरू करना
Activity, किसी ऐप्लिकेशन में मौजूद एक स्क्रीन को दिखाता है. startActivity() को Intent भेजकर, Activity का नया इंस्टेंस शुरू किया जा सकता है. Intent शुरू करने से जुड़ी गतिविधि की जानकारी देती है. साथ ही, ज़रूरी डेटा को भी शामिल करती है.

अगर आपको गतिविधि पूरी होने पर नतीजा चाहिए, तो startActivityForResult() पर कॉल करें. आपकी गतिविधि को नतीजा, onActivityResult() कॉलबैक में अलग Intent ऑब्जेक्ट के तौर पर मिलता है. ज़्यादा जानकारी के लिए, गतिविधियां गाइड देखें.
सेवा शुरू करना
Service एक ऐसा कॉम्पोनेंट है जो यूज़र इंटरफ़ेस के बिना, बैकग्राउंड में काम करता है. Android 5.0 (एपीआई लेवल 21) और उसके बाद के वर्शन में, JobScheduler के साथ सेवा शुरू की जा सकती है. Reader Revenue Manager को सेट अप करने के बारे में JobScheduler के बारे में है. इसकी जानकारी देखें API-reference documentation.

Android 5.0 (एपीआई लेवल 21) से पहले के वर्शन के लिए, सेवा शुरू करने के लिए Service क्लास के तरीके. startService() को Intent भेजकर, एक बार में होने वाले किसी काम (जैसे, फ़ाइल डाउनलोड करना) के लिए सेवा शुरू की जा सकती है. Intent में, शुरू की जाने वाली सेवा के बारे में बताया गया है. साथ ही, इसमें ज़रूरी डेटा भी होता है.

अगर सेवा को क्लाइंट-सर्वर इंटरफ़ेस के साथ डिज़ाइन किया गया है, तो Intent को bindService() पर पास करके, किसी दूसरे कॉम्पोनेंट से सेवा को बाइंड किया जा सकता है. ज़्यादा जानकारी के लिए, सेवाएं गाइड देखें.
ब्रॉडकास्ट डिलीवर करना
ब्रॉडकास्ट, ऐसा मैसेज है जिसे कोई भी ऐप्लिकेशन पा सकता है. सिस्टम, सिस्टम इवेंट के लिए कई ब्रॉडकास्ट डिलीवर करता है. जैसे, जब सिस्टम बूट होता है या डिवाइस चार्ज होना शुरू होता है. Intent को पास करके, दूसरे ऐप्लिकेशन पर ब्रॉडकास्ट डिलीवर किया जा सकता है sendBroadcast() या sendOrderedBroadcast().

इस पेज के बाकी हिस्से में बताया गया है कि इंटेंट कैसे काम करते हैं और उन्हें कैसे इस्तेमाल किया जा सकता है. इस बारे में ज़्यादा जानने के लिए, दूसरे ऐप्लिकेशन के साथ इंटरैक्ट करना और कॉन्टेंट शेयर करना लेख पढ़ें.

इंटेंट के टाइप

इंटेंट दो तरह के होते हैं:

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

पहली इमेज में दिखाया गया है कि किसी गतिविधि को शुरू करते समय, इंटेंट का इस्तेमाल कैसे किया जाता है. जब Intent ऑब्जेक्ट, गतिविधि के किसी खास कॉम्पोनेंट का नाम साफ़ तौर पर दिखाता है, यानी सिस्टम का नाम उस कॉम्पोनेंट को तुरंत शुरू कर देता है.

पहला डायग्राम. इंप्लिसिट इंटेंट कोई अन्य गतिविधि शुरू करने के लिए, सिस्टम से भेजी जाती है: [1] गतिविधि A Intent ने कार्रवाई के बारे में जानकारी दी और उसे startActivity() को भेज दिया. [2] Android सिस्टम, इंटेंट से मैच करने वाले इंटेंट फ़िल्टर के लिए सभी ऐप्लिकेशन खोजता है. मेल मिलने पर, सिस्टम [3] इससे मिलती-जुलती गतिविधि (गतिविधि B) को शुरू करने के लिए, onCreate() तरीके का इस्तेमाल किया जाता है और उसे Intent पास किया जाता है.

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

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

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

इंटेंट बनाना

Intent ऑब्जेक्ट, वह जानकारी ले जाता है जिसका इस्तेमाल Android सिस्टम करता है यह तय करने के लिए कि कौनसा कॉम्पोनेंट शुरू करना है (जैसे कि कॉम्पोनेंट का सटीक नाम या कॉम्पोनेंट वह कैटगरी जिसे इंटेंट चाहिए), साथ ही वह जानकारी जिसमें मैसेज पाने वाला कॉम्पोनेंट इस्तेमाल करता है कार्रवाई करने के लिए ज़रूरी है. उदाहरण के लिए, कार्रवाई और डेटा जिस पर कार्रवाई की जानी है.

Intent में शामिल मुख्य जानकारी यह है:

कॉम्पोनेंट का नाम

शुरू किए जाने वाले कॉम्पोनेंट का नाम.

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

ध्यान दें: Service को शुरू करने पर, कॉम्पोनेंट का नाम हमेशा तय करता है. ऐसा न करने पर, आपको पक्के तौर पर नहीं पता चलेगा कि कौनसी सेवा इंटेंट पर जवाब देगा और उपयोगकर्ता यह नहीं देख सकेगा कि कौनसी सेवा शुरू होती है.

Intent का यह फ़ील्ड ComponentName ऑब्जेक्ट दिया गया है, जिसे पूरी तरह से इस्तेमाल करके तय किया जा सकता है टारगेट कॉम्पोनेंट की क्वालिफ़ाइड क्लास का नाम, जिसमें ऐप्लिकेशन का पैकेज नाम भी शामिल होगा. उदाहरण के लिए, com.example.ExampleActivity. कॉम्पोनेंट का नाम, setComponent(), setClass(), setClassName() या Intent कन्स्ट्रक्टर के साथ सेट किया जा सकता है.

कार्रवाई

एक स्ट्रिंग, जो सामान्य कार्रवाई के बारे में बताती है. जैसे, देखें या चुनें.

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

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

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

सामान्य कार्रवाइयों की जानकारी देने वाली ज़्यादा कॉन्स्टेंट के लिए, Intent क्लास का रेफ़रंस देखें. अन्य कार्रवाइयां तय की गई हैं जो Android फ़्रेमवर्क में कहीं और मौजूद हैं, जैसे कि कार्रवाइयों के लिए Settings में जो सिस्टम के सेटिंग ऐप्लिकेशन में खास स्क्रीन खोलते हैं.

setAction() या Intent कन्स्ट्रक्टर की मदद से, किसी इंटेंट के लिए कार्रवाई तय की जा सकती है.

अगर आपको अपनी कार्रवाइयां तय करनी हैं, तो प्रीफ़िक्स के तौर पर अपने ऐप्लिकेशन के पैकेज का नाम शामिल करना न भूलें. उदाहरण के लिए:

KotlinJava

const val ACTION_TIMETRAVEL = "com.example.action.TIMETRAVEL"

static final String ACTION_TIMETRAVEL = "com.example.action.TIMETRAVEL";

डेटा

यूआरआई (Uri ऑब्जेक्ट), जो उस डेटा का रेफ़रंस देता है जिस पर कार्रवाई की जानी है और/या उस डेटा का MIME टाइप. आम तौर पर, किस तरह का डेटा डिलीवर किया जाता है, यह इंटेंट की कार्रवाई से तय होता है. इसके लिए उदाहरण के लिए, अगर कार्रवाई ACTION_EDIT है, तो डेटा में बदलाव करने के लिए दस्तावेज़ का यूआरआई.

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

सिर्फ़ डेटा यूआरआई सेट करने के लिए, setData() को कॉल करें. सिर्फ़ MIME टाइप सेट करने के लिए, setType() पर कॉल करें. अगर ज़रूरी हो, तो setDataAndType() की मदद से दोनों को साफ़ तौर पर सेट किया जा सकता है.

चेतावनी: अगर आपको यूआरआई और MIME टाइप, दोनों सेट करने हैं, तो setData() और setType() को न कॉल करें. ऐसा इसलिए, क्योंकि दोनों में से किसी एक की वैल्यू सेट करने पर, दूसरी वैल्यू हट जाती है. यूआरआई और MIME टाइप, दोनों को सेट करने के लिए हमेशा setDataAndType() का इस्तेमाल करें.

कैटगरी

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

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

इनकी पूरी सूची के लिए, Intent क्लास का ब्यौरा देखें श्रेणियां.

addCategory() की मदद से, कोई कैटगरी दी जा सकती है.

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

अन्य कॉन्टेंट

ऐसे की-वैल्यू पेयर जिनमें अनुरोध की गई कार्रवाई को पूरा करने के लिए ज़रूरी अतिरिक्त जानकारी होती है. कुछ कार्रवाइयां, खास तरह के डेटा यूआरआई का इस्तेमाल करती हैं. कुछ कार्रवाइयां, खास तरह के एक्सट्रा का भी इस्तेमाल करती हैं.

अलग-अलग putExtra() तरीकों का इस्तेमाल करके, अतिरिक्त डेटा जोड़ा जा सकता है, हर एक के लिए दो पैरामीटर स्वीकार किए जाते हैं: कुंजी का नाम और वैल्यू. आपके पास सभी अतिरिक्त डेटा के साथ एक Bundle ऑब्जेक्ट बनाने का विकल्प भी है. इसके बाद, putExtras() की मदद से Intent में Bundle डालें.

उदाहरण के लिए, ACTION_SEND की मदद से ईमेल भेजने का इंटेंट बनाते समय, EXTRA_EMAIL बटन की मदद से ईमेल पाने वाले व्यक्ति का ईमेल पता और EXTRA_SUBJECT बटन की मदद से ईमेल का विषय डाला जा सकता है.

Intent क्लास, स्टैंडर्ड डेटा टाइप के लिए कई EXTRA_* कॉन्स्टेंट तय करती है. अगर आपको अपनी अतिरिक्त कुंजियों का एलान करना है (ऐसे इंटेंट के लिए आपके ऐप्लिकेशन को मिलता है), तो अपने ऐप्लिकेशन के पैकेज का नाम शामिल करना न भूलें जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

KotlinJava

const val EXTRA_GIGAWATTS = "com.example.EXTRA_GIGAWATTS"

static final String EXTRA_GIGAWATTS = "com.example.EXTRA_GIGAWATTS";

चेतावनी: ऐसा इंटेंट भेजते समय Parcelable या Serializable डेटा का इस्तेमाल न करें जिसे आपको किसी दूसरे ऐप्लिकेशन को भेजना है. अगर कोई ऐप्लिकेशन Bundle ऑब्जेक्ट में डेटा को ऐक्सेस करने की कोशिश करता है, लेकिन उसके पास पार्सल की गई या सीरियलाइज़ की गई क्लास का ऐक्सेस नहीं है, तो सिस्टम एक RuntimeException दिखाता है.

फ़्लैग

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

ज़्यादा जानकारी के लिए, setFlags() तरीका देखें.

एक्सप्लिसिट इंटेंट का उदाहरण

एक्सप्लिसिट इंटेंट का इस्तेमाल, किसी खास ऐप्लिकेशन कॉम्पोनेंट को लॉन्च करने के लिए किया जाता है. जैसे, आपके ऐप्लिकेशन में कोई खास गतिविधि या सेवा. एक्सप्लिसिट इंटेंट बनाने के लिए, Intent ऑब्जेक्ट के लिए कॉम्पोनेंट का नाम तय करें. इंटेंट की अन्य सभी प्रॉपर्टी का इस्तेमाल करना ज़रूरी नहीं है.

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

KotlinJava

// Executed in an Activity, so 'this' is the Context
// The fileUrl is a string URL, such as "http://www.example.com/image.png"
val downloadIntent = Intent(this, DownloadService::class.java).apply {
    data = Uri.parse(fileUrl)
}
startService(downloadIntent)

// Executed in an Activity, so 'this' is the Context
// The fileUrl is a string URL, such as "http://www.example.com/image.png"
Intent downloadIntent = new Intent(this, DownloadService.class);
downloadIntent.setData(Uri.parse(fileUrl));
startService(downloadIntent);

Intent(Context, Class) कंस्ट्रक्टर, ऐप्लिकेशन Context और Class ऑब्जेक्ट कॉम्पोनेंट को जोड़ना. इसलिए, यह इंटेंट ऐप्लिकेशन में DownloadService क्लास को साफ़ तौर पर शुरू करता है.

कोई सेवा बनाने और उसे शुरू करने के बारे में ज़्यादा जानकारी के लिए, देखें सेवाएँ गाइड.

इंप्लिसिट इंटेंट का उदाहरण

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

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

KotlinJava

// Create the text message with a string.
val sendIntent = Intent().apply {
    action = Intent.ACTION_SEND
    putExtra(Intent.EXTRA_TEXT, textMessage)
    type = "text/plain"
}

// Try to invoke the intent.
try {
    startActivity(sendIntent)
} catch (e: ActivityNotFoundException) {
    // Define what your app should do if no activity can handle the intent.
}

// Create the text message with a string.
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
sendIntent.setType("text/plain");

// Try to invoke the intent.
try {
    startActivity(sendIntent);
} catch (ActivityNotFoundException e) {
    // Define what your app should do if no activity can handle the intent.
}

startActivity() को कॉल करने पर, सिस्टम यह तय करने के लिए इंस्टॉल किए गए सभी ऐप्लिकेशन की जांच करता है कि इस तरह के इंटेंट को कौन मैनेज कर सकता है ( इंटेंट के साथ ACTION_SEND कार्रवाई और जिसमें "टेक्स्ट/सादा" शामिल है डेटा). अगर कोई एक ऐप्लिकेशन है जो इसे हैंडल कर सकता है, तो वह ऐप्लिकेशन तुरंत खुल जाता है और उसे इंटेंट. अगर कोई दूसरा ऐप्लिकेशन इसे मैनेज नहीं कर सकता, तो आपका ऐप्लिकेशन ActivityNotFoundException होता है. अगर एक से ज़्यादा ऐक्टिविटी इंटेंट को स्वीकार करती हैं, तो सिस्टम ऐसा डायलॉग दिखाता है जैसा कि दूसरी इमेज में दिखाया गया है. इससे उपयोगकर्ता यह चुन सकता है कि किस ऐप्लिकेशन का इस्तेमाल करना है.

गाइड में अन्य ऐप्लिकेशन लॉन्च करने के बारे में भी ज़्यादा जानकारी दी गई है इसके बारे में उपयोगकर्ता को कोई दूसरा ऐप्लिकेशन.

दूसरी इमेज. चुनने के लिए डायलॉग बॉक्स.

ऐप्लिकेशन चुनने वाला टूल इस्तेमाल करना

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

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

चुनने वाले को दिखाने के लिए, createChooser() का इस्तेमाल करके Intent बनाएं और उसे startActivity() को पास करें, जैसा कि इस उदाहरण में दिखाया गया है. इस उदाहरण में, createChooser() तरीके में पास किए गए इंटेंट का जवाब देने वाले ऐप्लिकेशन की सूची वाला डायलॉग दिखाया गया है. साथ ही, इसमें दिए गए टेक्स्ट का इस्तेमाल डायलॉग के टाइटल के तौर पर किया गया है.

KotlinJava

val sendIntent = Intent(Intent.ACTION_SEND)
...

// Always use string resources for UI text.
// This says something like "Share this photo with"
val title: String = resources.getString(R.string.chooser_title)
// Create intent to show the chooser dialog
val chooser: Intent = Intent.createChooser(sendIntent, title)

// Verify the original intent will resolve to at least one activity
if (sendIntent.resolveActivity(packageManager) != null) {
    startActivity(chooser)
}

Intent sendIntent = new Intent(Intent.ACTION_SEND);
...

// Always use string resources for UI text.
// This says something like "Share this photo with"
String title = getResources().getString(R.string.chooser_title);
// Create intent to show the chooser dialog
Intent chooser = Intent.createChooser(sendIntent, title);

// Verify the original intent will resolve to at least one activity
if (sendIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(chooser);
}

असुरक्षित इंटेंट लॉन्च का पता लगाएं

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

अगर आपका ऐप्लिकेशन यहां दी गई दोनों कार्रवाइयां करता है, तो सिस्टम को असुरक्षित इंटेंट लॉन्च का पता चलता है और StrictMode का उल्लंघन होता है:

आपका ऐप्लिकेशन, डिलीवर किए गए इंटेंट के अतिरिक्त हिस्सों में से नेस्ट किए गए इंटेंट को पार्स करता है.
आपका ऐप्लिकेशन तुरंत ऐप्लिकेशन को शुरू कर देता है कॉम्पोनेंट, उस नेस्ट किए गए इंटेंट का इस्तेमाल करके, उदाहरण के लिए, startActivity(), startService(), या bindService().

इस स्थिति की पहचान करने और अपने ऐप्लिकेशन में बदलाव करने के तरीके के बारे में ज़्यादा जानने के लिए, Medium पर Android नेस्टिंग इंटेंट के बारे में ब्लॉग पोस्ट पढ़ें.

असुरक्षित इंटेंट लॉन्च की जांच करना

अपने ऐप्लिकेशन में असुरक्षित इंटेंट लॉन्च होने का पता लगाने के लिए, detectUnsafeIntentLaunch() जब आप अपना VmPolicy कॉन्फ़िगर करते हैं, जैसा कि नीचे दिए गए कोड स्निपेट में दिखाया गया है. अगर आपके ऐप्लिकेशन में StrictMode के उल्लंघन का पता चलता है, तो संवेदनशील जानकारी को सुरक्षित रखने के लिए, ऐप्लिकेशन को बंद किया जा सकता है.

KotlinJava

fun onCreate() {
    StrictMode.setVmPolicy(VmPolicy.Builder()
        // Other StrictMode checks that you've previously added.
        // ...
        .detectUnsafeIntentLaunch()
        .penaltyLog()
        // Consider also adding penaltyDeath()
        .build())
}

protected void onCreate() {
    StrictMode.setVmPolicy(new VmPolicy.Builder()
        // Other StrictMode checks that you've previously added.
        // ...
        .detectUnsafeIntentLaunch()
        .penaltyLog()
        // Consider also adding penaltyDeath()
        .build());
}

इंटेंट का ज़्यादा ज़िम्मेदारी से इस्तेमाल करना

असुरक्षित इंटेंट लॉन्च की संभावना और StrictMode के उल्लंघन की संभावना को कम करने के लिए, ये सबसे सही तरीके अपनाएं.

इंटेंट के अंदर सिर्फ़ ज़रूरी अतिरिक्त चीज़ों को कॉपी करें और सभी ज़रूरी काम करें साफ़-सफ़ाई और पुष्टि के तरीके. आपका ऐप्लिकेशन, एक्सट्रा एलिमेंट को एक इंटेंट से दूसरे इंटेंट में कॉपी कर सकता है. इस इंटेंट का इस्तेमाल, नए कॉम्पोनेंट को लॉन्च करने के लिए किया जाता है. ऐसा तब होता है, जब आपके ऐप्लिकेशन कॉल putExtras(Intent) या putExtras(Bundle). अगर आपका ऐप्लिकेशन इनमें से कोई एक कार्रवाई करता है, तो सिर्फ़ उन अतिरिक्त कार्रवाइयों को कॉपी करें जो मिलने वाले कॉम्पोनेंट की उम्मीद करता है. अगर कॉपी पाने वाला दूसरा इंटेंट, एक्सपोर्ट नहीं किया गया कॉम्पोनेंट लॉन्च करता है, तो कॉम्पोनेंट लॉन्च करने वाले इंटेंट में कॉपी करने से पहले, एक्सट्रा एलिमेंट को साफ़ करें और उनकी पुष्टि करें.

अपने ऐप्लिकेशन के कॉम्पोनेंट को ज़रूरत के बिना एक्सपोर्ट न करें. उदाहरण के लिए, अगर आपको किसी इंटरनल नेस्ट किए गए इंटेंट का इस्तेमाल करके ऐप्लिकेशन कॉम्पोनेंट लॉन्च करना है, तो उस कॉम्पोनेंट के android:exported एट्रिब्यूट को false पर सेट करें.

नेस्ट किए गए इंटेंट के बजाय, PendingIntent का इस्तेमाल करें. इस तरह, जब कोई दूसरा ऐप्लिकेशन अपने Intent में मौजूद PendingIntent को अनपैक करता है, तो वह आपके ऐप्लिकेशन की पहचान का इस्तेमाल करके PendingIntent को लॉन्च कर सकता है. इस कॉन्फ़िगरेशन की मदद से, दूसरा ऐप्लिकेशन आपके ऐप्लिकेशन में मौजूद किसी भी कॉम्पोनेंट को सुरक्षित तरीके से लॉन्च कर सकता है. इसमें, एक्सपोर्ट नहीं किया गया कॉम्पोनेंट भी शामिल है.

दूसरे डायग्राम में दिखाया गया है कि सिस्टम, आपके (क्लाइंट) ऐप्लिकेशन से कंट्रोल को दूसरे (सेवा) ऐप्लिकेशन पर कैसे भेजता है और फिर आपके ऐप्लिकेशन पर वापस कैसे लाता है:

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

दूसरी इमेज. नेस्ट किए गए 'मंज़ूरी बाकी' को इस्तेमाल करने पर इंटर-ऐप्लिकेशन कम्यूनिकेशन का डायग्राम इंटेंट.

इंप्लिसिट इंटेंट पाना

यह बताने के लिए कि आपके ऐप्लिकेशन को कौनसे इंप्लिसिट इंटेंट मिल सकते हैं, अपनी मेनिफ़ेस्ट फ़ाइल में <intent-filter> एलिमेंट के साथ, अपने हर ऐप्लिकेशन कॉम्पोनेंट के लिए एक या उससे ज़्यादा इंटेंट फ़िल्टर का एलान करें. हर इंटेंट फ़िल्टर, इंटेंट की कार्रवाई, डेटा, और कैटगरी के आधार पर यह तय करता है कि वह किस तरह के इंटेंट स्वीकार करता है. सिस्टम आपके ऐप्लिकेशन कॉम्पोनेंट को सिर्फ़ तब इम्प्लीसिट इंटेंट डिलीवर करता है, जब वह इंटेंट आपके किसी इंटेंट फ़िल्टर से पास हो सकता है.

ध्यान दें: एक्सप्लिसिट इंटेंट हमेशा अपने टारगेट को डिलीवर किया जाता है. भले ही, कॉम्पोनेंट ने किसी भी इंटेंट फ़िल्टर का एलान किया हो.

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

हर इंटेंट फ़िल्टर को <intent-filter> से तय किया जाता है ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल में मौजूद एलिमेंट को, संबंधित ऐप्लिकेशन कॉम्पोनेंट में नेस्ट किया गया होगा (जैसे <activity> के तौर पर एलिमेंट).

<intent-filter> एलिमेंट वाले हर ऐप्लिकेशन कॉम्पोनेंट में, android:exported के लिए साफ़ तौर पर वैल्यू सेट करें. इस एट्रिब्यूट से पता चलता है कि ऐप्लिकेशन कॉम्पोनेंट को दूसरे ऐप्लिकेशन ऐक्सेस कर सकते हैं या नहीं. कुछ उदाहरण के लिए, ऐसी गतिविधियां जिनके इंटेंट फ़िल्टर में LAUNCHER कैटगरी है, तो इस एट्रिब्यूट को true पर सेट करना मददगार होता है. या फिर, इस एट्रिब्यूट को false पर सेट करना सुरक्षित है.

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

<intent-filter> में, इन तीन एलिमेंट में से किसी एक या एक से ज़्यादा का इस्तेमाल करके, स्वीकार किए जाने वाले इंटेंट का टाइप बताया जा सकता है:

<action>: name एट्रिब्यूट में स्वीकार की गई इंटेंट कार्रवाई के बारे में बताता है. वैल्यू यह किसी कार्रवाई की लिटरल स्ट्रिंग वैल्यू होनी चाहिए, न कि क्लास कॉन्सटेंट.
<data>: स्वीकार किए जाने वाले डेटा के टाइप की जानकारी देता है. इसके लिए, एक या एक से ज़्यादा एट्रिब्यूट इस्तेमाल किए जाते हैं. साथ ही, कई एट्रिब्यूट के बारे में बताया जाता है डेटा यूआरआई (scheme, host, port, path) और MIME टाइप शामिल हैं.
<category>: name एट्रिब्यूट में, स्वीकार की गई इंटेंट कैटगरी की जानकारी देता है. वैल्यू, किसी ऐक्शन की लिटरल स्ट्रिंग वैल्यू होनी चाहिए, न कि क्लास कॉन्स्टेंट.
ध्यान दें: इंप्लिसिट इंटेंट पाने के लिए, आपको इंटेंट फ़िल्टर में CATEGORY_DEFAULT कैटगरी शामिल करनी होगी. तरीके startActivity() और startActivityForResult() सभी इंटेंट का इस्तेमाल करता है जैसे कि उन्होंने CATEGORY_DEFAULT कैटगरी का एलान किया हो. अगर आपने इंटेंट फ़िल्टर में इस कैटगरी का एलान नहीं किया है, तो कोई इंप्लिसिट इंटेंट आपकी गतिविधि.

उदाहरण के लिए, यहां गतिविधि के बारे में एलान दिया गया है. इसमें इंटेंट फ़िल्टर को भी शामिल किया गया है, ताकि डेटा टाइप, टेक्स्ट होने पर ACTION_SEND इंटेंट:

<activity android:name="ShareActivity" android:exported="false">
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain"/>
    </intent-filter>
</activity>

आपके पास ऐसा फ़िल्टर बनाने का विकल्प है जिसमें एक से ज़्यादा <action>, <data> या <category> शामिल हों. अगर ऐसा किया जाता है, तो आपको यह पक्का करना होगा कि कॉम्पोनेंट इनमें से किसी एक या सभी को हैंडल कर सकता है इन फ़िल्टर एलिमेंट का एक साथ इस्तेमाल किया जा सकता है.

अगर आपको कई तरह के इंटेंट मैनेज करने हैं, लेकिन सिर्फ़ कार्रवाई, डेटा, और कैटगरी टाइप के खास कॉम्बिनेशन में, तो आपको कई इंटेंट फ़िल्टर बनाने होंगे.

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

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

इसी तरह, किसी दूसरे ऐप्लिकेशन का Serviceगलती से चालू होने से बचने के लिए, अपनी सेवा शुरू करने के लिए हमेशा साफ़ तौर पर इंटेंट का इस्तेमाल करें.

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

फ़िल्टर के उदाहरण

इंटेंट फ़िल्टर के कुछ काम करने के तरीके दिखाने के लिए, यहां सोशल-शेयरिंग ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल का उदाहरण दिया गया है:

<activity android:name="MainActivity" android:exported="true">
    <!-- This activity is the main entry, should appear in app launcher -->
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<activity android:name="ShareActivity" android:exported="false">
    <!-- This activity handles "SEND" actions with text data -->
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain"/>
    </intent-filter>
    <!-- This activity also handles "SEND" and "SEND_MULTIPLE" with media data -->
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <action android:name="android.intent.action.SEND_MULTIPLE"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="application/vnd.google.panorama360+jpg"/>
        <data android:mimeType="image/*"/>
        <data android:mimeType="video/*"/>
    </intent-filter>
</activity>

पहली ऐक्टिविटी, MainActivity, ऐप्लिकेशन का मुख्य एंट्री पॉइंट है. यह वह ऐक्टिविटी है जो उपयोगकर्ता के लॉन्चर आइकॉन से ऐप्लिकेशन को शुरू करने पर खुलती है:

ACTION_MAIN कार्रवाई इससे पता चलता है कि यह मुख्य एंट्री पॉइंट है और इससे इंटेंट डेटा की उम्मीद नहीं की जाती.
CATEGORY_LAUNCHER कैटगरी से पता चलता है कि इस गतिविधि का आइकॉन, सिस्टम के ऐप्लिकेशन लॉन्चर में रखा जाना चाहिए. अगर <activity> एलिमेंट icon वाले आइकॉन के बारे में नहीं बताता है. इसके बाद, सिस्टम <application> से आइकॉन का इस्तेमाल करता है एलिमेंट.

ऐप्लिकेशन लॉन्चर में गतिविधि दिखाई देने के लिए इन दोनों को एक साथ जोड़ा जाना चाहिए.

दूसरी गतिविधि, ShareActivity का मकसद टेक्स्ट और मीडिया कॉन्टेंट शेयर करना है. उपयोगकर्ता, MainActivity से इस गतिविधि पर जाकर इसमें शामिल हो सकते हैं. हालांकि, वे सीधे किसी दूसरे ऐप्लिकेशन से भी ShareActivity में शामिल हो सकते हैं. यह ऐप्लिकेशन, दो इंटेंट फ़िल्टर में से किसी एक से मैच करने वाला इंप्लिसिट इंटेंट जारी करता है.

ध्यान दें: एमआईएम टाइप, application/vnd.google.panorama360+jpg एक खास डेटा टाइप है. इससे पैनोरामिक फ़ोटो के बारे में पता चलता है. इन्हें Google panorama एपीआई की मदद से मैनेज किया जा सकता है.

इंटेंट को अन्य ऐप्लिकेशन के इंटेंट फ़िल्टर से मैच करना

अगर कोई दूसरा ऐप्लिकेशन, Android 13 (एपीआई लेवल 33) या उसके बाद के वर्शन को टारगेट करता है, तो वह आपके ऐप्लिकेशन के इंटेंट को सिर्फ़ तब मैनेज कर सकता है, जब आपका इंटेंट उस दूसरे ऐप्लिकेशन के <intent-filter> एलिमेंट की कार्रवाइयों और कैटगरी से मेल खाता हो. अगर सिस्टम को कोई मैच नहीं मिलता है, तो वह ActivityNotFoundException दिखाता है. ईमेल भेजने वाले ऐप्लिकेशन को इसे मैनेज करना होगा यह अपवाद.

इसी तरह, अगर आपने अपने ऐप्लिकेशन को अपडेट किया है, ताकि वह Android 13 को टारगेट करे या ज़्यादा, बाहरी ऐप्लिकेशन से जनरेट होने वाले सभी इंटेंट आपके ऐप्लिकेशन का एक्सपोर्ट किया गया कॉम्पोनेंट सिर्फ़ तब ही होगा, जब वह इंटेंट कार्रवाइयों से मेल खाता हो और <intent-filter> एलिमेंट की ऐसी कैटगरी जिनके बारे में आपका ऐप्लिकेशन एलान करता है. यह समस्या, ईमेल भेजने वाले ऐप्लिकेशन के टारगेट किए जा रहे SDK टूल के वर्शन के बावजूद होती है.

इन मामलों में, इंटेंट मैचिंग को लागू नहीं किया जाता:

ऐसे कॉम्पोनेंट को डिलीवर किए गए इंटेंट जिनमें इंटेंट फ़िल्टर का एलान नहीं किया गया है.
एक ही ऐप्लिकेशन से शुरू होने वाले इंटेंट.
सिस्टम से मिलने वाले इंटेंट; यानी, इंटेंट "सिस्टम का यूआईडी" (uid=1000) है. सिस्टम ऐप्लिकेशन में system_server और सेट किए गए ऐप्लिकेशन शामिल हैं android.uid.system के लिए android:sharedUserId.
रूट से आने वाले इंटेंट.

इंटेंट मैचिंग के बारे में ज़्यादा जानें.

पेंडिंग इंटेंट का इस्तेमाल करना

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

पेंडिंग इंटेंट के इस्तेमाल के मुख्य उदाहरणों में ये शामिल हैं:

जब उपयोगकर्ता आपकी सूचना के ज़रिए कोई कार्रवाई करता है, तब उसे लागू करने के लिए इंटेंट का एलान करना (Android सिस्टम का NotificationManager Intent को लागू करता है).
जब उपयोगकर्ता आपके ऐप्लिकेशन विजेट पर कोई कार्रवाई करता है, तब उसे लागू करने के लिए इंटेंट का एलान करना (होम स्क्रीन ऐप्लिकेशन, Intent को लागू करता है).
तय किए गए समय पर लागू किए जाने वाले इंटेंट का एलान करना (Android सिस्टम का AlarmManager, Intent को लागू करता है).

जिस तरह हर Intent ऑब्जेक्ट को किसी खास तरह के ऐप्लिकेशन कॉम्पोनेंट (Activity, Service या BroadcastReceiver) से मैनेज करने के लिए डिज़ाइन किया गया है उसी तरह PendingIntent को भी इसी तरह बनाया जाना चाहिए. अगर किसी पेंडिंग इंटेंट का इस्तेमाल किया जाता है, तो आपका ऐप्लिकेशन startActivity() जैसे कॉल के साथ इंटेंट को लागू नहीं करता. इसके बजाय, आपको PendingIntent को क्रिएटर तरीके से कॉल करने के लिए यह तरीका अपनाएं:

Intent के लिए PendingIntent.getActivity(), जो Activity शुरू करता है.
Intent से शुरू होने वाले Service के लिए PendingIntent.getService().
PendingIntent.getBroadcast() BroadcastReceiver शुरू करने वाला Intent.

जब तक आपका ऐप्लिकेशन अन्य ऐप्लिकेशन से रुके हुए इंटेंट नहीं ले रहा हो, तब तक PendingIntent बनाने के लिए ऊपर दिए गए तरीके शायद PendingIntent तरीकों की ज़रूरत पड़ेगी.

हर तरीके के लिए मौजूदा ऐप्लिकेशन Context का इस्तेमाल किया जाता है, Intent जिसे रैप करना है और एक या एक से ज़्यादा फ़्लैग इंटेंट का इस्तेमाल कैसे किया जाना चाहिए (जैसे, इंटेंट का एक से ज़्यादा बार इस्तेमाल किया जा सकता है या नहीं).

इंतज़ार में मौजूद इंटेंट का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, इस्तेमाल के हर उदाहरण के लिए दस्तावेज़ देखें. जैसे, सूचनाएं और ऐप्लिकेशन विजेट एपीआई गाइड.

म्यूटेबिलिटी की जानकारी देना

अगर आपका ऐप्लिकेशन Android 12 या उसके बाद के वर्शन को टारगेट करता है, तो आपको अपने ऐप्लिकेशन के बनाए गए हर PendingIntent ऑब्जेक्ट के लिए, म्यूटेबिलिटी की जानकारी देनी होगी. यह एलान करने के लिए दिया गया PendingIntent ऑब्जेक्ट बदला जा सकता है या नहीं बदला जा सकता, इसलिए PendingIntent.FLAG_MUTABLE या PendingIntent.FLAG_IMMUTABLE फ़्लैग का इस्तेमाल करें.

अगर आपका ऐप्लिकेशन, PendingIntent ऑब्जेक्ट बनाने की कोशिश करता है म्यूटेबिलिटी फ़्लैग सेट किए बिना, सिस्टम IllegalArgumentException, और Logcat में यह मैसेज दिखता है:

PACKAGE_NAME: Targeting S+ (version 31 and above) requires that one of \
FLAG_IMMUTABLE or FLAG_MUTABLE be specified when creating a PendingIntent.

Strongly consider using FLAG_IMMUTABLE, only use FLAG_MUTABLE if \
some functionality depends on the PendingIntent being mutable, e.g. if \
it needs to be used with inline replies or bubbles.

जब भी मुमकिन हो, तब ऐसे इंटेंट बनाएं जिन्हें बदला नहीं जा सकता

ज़्यादातर मामलों में, आपके ऐप्लिकेशन को इस तरह से नहीं बदले जा सकने वाले PendingIntent ऑब्जेक्ट बनाने चाहिए, जो नीचे दिए गए कोड स्निपेट में दिखाए गए हैं. अगर कोई PendingIntent ऑब्जेक्ट बदला नहीं जा सकता, तो अन्य ऐप्लिकेशन, इंटेंट को ट्रिगर करने के नतीजे में बदलाव करने के लिए, इंटेंट में बदलाव नहीं कर सकते.

KotlinJava

val pendingIntent = PendingIntent.getActivity(applicationContext,
        REQUEST_CODE, intent,
        /* flags */ PendingIntent.FLAG_IMMUTABLE)

PendingIntent pendingIntent = PendingIntent.getActivity(getApplicationContext(),
        REQUEST_CODE, intent,
        /* flags */ PendingIntent.FLAG_IMMUTABLE);

हालांकि, इस्तेमाल के कुछ उदाहरणों में, बदलाव किए जा सकने वाले PendingIntent ऑब्जेक्ट की ज़रूरत होती है:

सूचनाओं में सीधे जवाब देने की सुविधा काम कर रही है. कॉन्टेंट बनाने सीधे तौर पर जवाब देने के लिए, PendingIntent ऑब्जेक्ट के क्लिप डेटा में बदलाव करना ज़रूरी है जो जवाब से जुड़ा हो. आम तौर पर, इस बदलाव का अनुरोध करने के लिए, fillIn() तरीके के लिए FILL_IN_CLIP_DATA को फ़्लैग के तौर पर पास किया जाता है.
इन इंस्टेंस का इस्तेमाल करके, सूचनाओं को Android Auto फ़्रेमवर्क से जोड़ना CarAppExtender.
PendingIntent के इंस्टेंस का इस्तेमाल करके, बातचीत को बबल में डालना. बदलाव किया जा सकने वाला PendingIntent ऑब्जेक्ट, सिस्टम को लागू करने की अनुमति देता है सही फ़्लैग, जैसे कि FLAG_ACTIVITY_MULTIPLE_TASK और FLAG_ACTIVITY_NEW_DOCUMENT.
कॉल करके डिवाइस की जगह की जानकारी मांगी जा रही है requestLocationUpdates() का इस्तेमाल किया जा सकता है. बदला जा सकने वाला PendingIntent ऑब्जेक्ट, सिस्टम को इंटेंट एक्स्ट्रा का इस्तेमाल करें, जो जगह के लाइफ़साइकल इवेंट को दिखाते हैं. इन इवेंट में शामिल है: जगह में बदलाव और सेवा देने वाली कंपनी का उपलब्ध होना.
AlarmManager का इस्तेमाल करके, अलार्म शेड्यूल किए जा रहे हैं. बदला जा सकने वाला PendingIntent ऑब्जेक्ट, सिस्टम को EXTRA_ALARM_COUNT एक से ज़्यादा इंटेंट पर क्लिक करें. इस एक्सट्रा से पता चलता है कि बार-बार बजने वाला अलार्म कितनी बार ट्रिगर हुआ. इस अतिरिक्त जानकारी की मदद से, इंटेंट किसी ऐप्लिकेशन को सटीक जानकारी दे सकता है कि बार-बार बजने वाला अलार्म कई बार ट्रिगर हुआ है या नहीं. जैसे, जब डिवाइस स्लीप मोड में था.

अगर आपका ऐप्लिकेशन, बदला जा सकने वाला PendingIntent ऑब्जेक्ट बनाता है, तो हमारा सुझाव है कि साफ़ तौर पर किया गया हो और अतिरिक्त जानकारी के साथ, ComponentName. इस तरह, जब भी कोई दूसरा ऐप्लिकेशन PendingIntent को ट्रिगर करता है और कंट्रोल को आपके ऐप्लिकेशन को वापस भेजता है, तो आपके ऐप्लिकेशन में वही कॉम्पोनेंट हमेशा शुरू होता है.

जिन इंटेंट को मंज़ूरी नहीं मिली है उनमें अश्लील इंटेंट का इस्तेमाल करना

यह बेहतर तरीके से तय करने के लिए कि दूसरे ऐप्लिकेशन, आपके ऐप्लिकेशन के वे इंटेंट कैसे इस्तेमाल कर सकते हैं जिन्हें अभी तक प्रोसेस नहीं किया गया है, हमेशा किसी साफ़ तौर पर बताए गए इंटेंट के साथ वे इंटेंट रैप करें. इस सबसे सही तरीके को अपनाने के लिए, यहां दिया गया तरीका अपनाएं:

देखें कि बेस इंटेंट के लिए कार्रवाई, पैकेज, और कॉम्पोनेंट वाले फ़ील्ड सेट किए गए हों.
FLAG_IMMUTABLE का इस्तेमाल करें, लंबित इंटेंट बनाने के लिए, Android 6.0 (एपीआई लेवल 23) में जोड़ा गया. यह फ़्लैग इससे उन ऐप्लिकेशन को रोका जाता है जिन्हें PendingIntent भरने से रोका जाता है ऐसी प्रॉपर्टी जिनमें अपने-आप जानकारी भरी नहीं होती. अगर आपके ऐप्लिकेशन का minSdkVersion 22 या उससे कम है, तो नीचे दिए गए कोड का इस्तेमाल करके, ऐप्लिकेशन के सुरक्षित और काम करने के बारे में एक साथ जानकारी दी जा सकती है:
```
if (Build.VERSION.SDK_INT >= 23) {
  // Create a PendingIntent using FLAG_IMMUTABLE.
} else {
  // Existing code that creates a PendingIntent.
}
```

इंटेंट रिज़ॉल्यूशन

जब सिस्टम को कोई गतिविधि शुरू करने के लिए इंप्लिसिट इंटेंट मिलता है, तो वह इंटेंट के लिए सबसे अच्छी गतिविधि की तुलना, तीन पहलुओं के आधार पर इंटेंट फ़िल्टर से करें:

ऐक्शन.
डेटा (यूआरआई और डेटा टाइप दोनों).
कैटगरी.

यहां दिए सेक्शन में बताया गया है कि इंटेंट को सही कॉम्पोनेंट से कैसे मैच किया जाता है .

ऐक्शन टेस्ट

स्वीकार की गई इंटेंट कार्रवाइयों के बारे में बताने के लिए, इंटेंट फ़िल्टर में शून्य या एक से ज़्यादा <action> एलिमेंट शामिल किए जा सकते हैं. उदाहरण के लिए:

<intent-filter>
    <action android:name="android.intent.action.EDIT" />
    <action android:name="android.intent.action.VIEW" />
    ...
</intent-filter>

इस फ़िल्टर को पास करने के लिए, Intent में बताई गई कार्रवाई, फ़िल्टर में दी गई किसी एक कार्रवाई से मेल खानी चाहिए.

अगर फ़िल्टर में किसी भी कार्रवाई को सूची में शामिल नहीं किया गया है, तो इंटेंट मैच नहीं करते हैं, इसलिए सभी इंटेंट टेस्ट में फ़ेल हो जाते हैं. हालांकि, अगर कोई Intent किसी कार्रवाई की जानकारी नहीं देता है, तो वह टेस्ट पास कर जाता है. ऐसा तब होता है, जब फ़िल्टर में कम से कम एक कार्रवाई शामिल हो.

कैटगरी टेस्ट

स्वीकार की गई इंटेंट कैटगरी बताने के लिए, इंटेंट फ़िल्टर शून्य या उससे ज़्यादा का एलान कर सकता है <category> एलिमेंट, जैसा कि इस उदाहरण में दिखाया गया है:

<intent-filter>
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    ...
</intent-filter>

किसी इंटेंट को कैटगरी टेस्ट पास करने के लिए, Intent में मौजूद हर कैटगरी, फ़िल्टर में मौजूद किसी कैटगरी से मेल खानी चाहिए. उलटा करना ज़रूरी नहीं है— इंटेंट फ़िल्टर हो सकता है Intent और Intent अब भी पास हो गया है. इसलिए, बिना किसी कैटगरी वाला इंटेंट हमेशा इस टेस्ट को पास कर लेता है, भले ही फ़िल्टर में किसी भी कैटगरी का एलान किया गया हो.

ध्यान दें: Android, startActivity() और startActivityForResult() को पास किए गए सभी इंप्लिसिट इंटेंट पर, CATEGORY_DEFAULT कैटगरी को अपने-आप लागू करता है. अगर आपको अपनी गतिविधि को इंप्लिसिट इंटेंट चाहिए, तो उसके इंटेंट फ़िल्टर में "android.intent.category.DEFAULT" के लिए कैटगरी शामिल करनी होगी, जैसा कि पिछले <intent-filter> उदाहरण में दिखाया गया है.

डेटा टेस्ट

स्वीकार किए गए इंटेंट डेटा की जानकारी देने के लिए, इंटेंट फ़िल्टर में शून्य या एक से ज़्यादा <data> एलिमेंट शामिल किए जा सकते हैं. उदाहरण के लिए:

<intent-filter>
    <data android:mimeType="video/mpeg" android:scheme="http" ... />
    <data android:mimeType="audio/mpeg" android:scheme="http" ... />
    ...
</intent-filter>

हर <data> एलिमेंट में यूआरआई स्ट्रक्चर और डेटा टाइप (एमआईएम मीडिया टाइप) की जानकारी दी जा सकती है. यूआरआई का हर हिस्सा एक अलग एट्रिब्यूट: scheme, host, port, और path:

<scheme>://<host>:<port>/<path>

नीचे दिए गए उदाहरण में, इन एट्रिब्यूट की संभावित वैल्यू दिखाई गई हैं:

content://com.example.project:200/folder/subfolder/etc

इस यूआरआई में, स्कीम content, होस्ट com.example.project, पोर्ट 200, और पाथ folder/subfolder/etc है.

<data> एलिमेंट में, इनमें से हर एट्रिब्यूट ज़रूरी नहीं है, हालांकि, लीनियर डिपेंडेंसी होती हैं:

अगर कोई स्कीम नहीं दी गई है, तो होस्ट को अनदेखा कर दिया जाता है.
अगर कोई होस्ट नहीं बताया गया है, तो पोर्ट को अनदेखा कर दिया जाता है.
अगर स्कीम और होस्ट, दोनों की जानकारी नहीं दी गई हो, तो पाथ को अनदेखा कर दिया जाता है.

जब किसी इंटेंट के यूआरआई की तुलना किसी फ़िल्टर के यूआरआई की खास बातों से की जाती है, तो इसकी तुलना सिर्फ़ फ़िल्टर में शामिल यूआरआई के हिस्सों से की जाती है. उदाहरण के लिए:

अगर कोई फ़िल्टर सिर्फ़ किसी स्कीम के बारे में बताता है, तो उस स्कीम के सभी यूआरआई मेल खाते हैं फ़िल्टर.
अगर कोई फ़िल्टर किसी स्कीम और संस्था के बारे में बताता है, लेकिन पाथ नहीं, तो सभी यूआरआई एक जैसी स्कीम और अधिकार से, फ़िल्टर को पास किया जाता है, भले ही उनका पाथ कुछ भी हो.
अगर किसी फ़िल्टर में स्कीम, अथॉरिटी, और पाथ की जानकारी दी गई है, तो सिर्फ़ उसी स्कीम, अथॉरिटी, और पाथ वाले यूआरआई ही फ़िल्टर को पास करते हैं.

ध्यान दें: पाथ स्पेसिफ़िकेशन से एक वाइल्डकार्ड तारा चिह्न (*) होना चाहिए, जिसके लिए पथ के नाम का केवल आंशिक मिलान आवश्यक हो.

डेटा टेस्ट, इंटेंट में मौजूद यूआरआई और MIME टाइप की तुलना, फ़िल्टर में बताए गए यूआरआई और MIME टाइप से करता है. ये नियम इस तरह के हैं:

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

ध्यान दें: अगर कोई इंटेंट यूआरआई या MIME टाइप तय करता है, तो डेटा टेस्ट अगर <intent-filter> में कोई <data> एलिमेंट नहीं है, तो फ़ेल हो जाएगा.

यह आखिरी नियम, नियम (d), उम्मीद के बारे में बताता है ये कॉम्पोनेंट किसी फ़ाइल या कॉन्टेंट देने वाले से लोकल डेटा ले सकते हैं. इसलिए, उनके फ़िल्टर में सिर्फ़ डेटा टाइप शामिल किया जा सकता है. साथ ही, content: और file: स्कीम का नाम साफ़ तौर पर बताने की ज़रूरत नहीं होती. नीचे दिए गए उदाहरण में एक सामान्य मामला दिखाया गया है. इसमें <data> एलिमेंट, Android को बताता है कि कॉम्पोनेंट, कॉन्टेंट उपलब्ध कराने वाली कंपनी से इमेज का डेटा पा सकता है और उसे दिखा सकता है:

<intent-filter>
    <data android:mimeType="image/*" />
    ...
</intent-filter>

डेटा टाइप के बारे में बताने वाले, लेकिन यूआरआई के बारे में नहीं बताने वाले फ़िल्टर सबसे आम होते हैं. ऐसा इसलिए है, क्योंकि ज़्यादातर उपलब्ध डेटा, कॉन्टेंट उपलब्ध कराने वाली कंपनियां उपलब्ध कराती हैं.

स्कीम और डेटा टाइप वाला फ़िल्टर, एक और सामान्य कॉन्फ़िगरेशन है. उदाहरण के लिए, नीचे दिए गए <data> एलिमेंट से Android को पता चलता है कि कॉम्पोनेंट, कार्रवाई करने के लिए नेटवर्क से वीडियो डेटा हासिल कर सकता है:

<intent-filter>
    <data android:scheme="http" android:mimeType="video/*" />
    ...
</intent-filter>

इंटेंट मैचिंग

इंटेंट का मिलान इंटेंट फ़िल्टर के साथ किया जाता है, न सिर्फ़ टारगेट को खोजने के लिए चलाने के लिए, लेकिन साथ ही सामग्री के सेट के बारे में कुछ कॉम्पोनेंट भी जोड़े जा सकते हैं. उदाहरण के लिए, Home ऐप्लिकेशन, ऐप्लिकेशन लॉन्चर में उन सभी गतिविधियों को भरता है जिनमें इंटेंट फ़िल्टर होते हैं. इन फ़िल्टर से ACTION_MAIN ऐक्शन और CATEGORY_LAUNCHER कैटगरी के बारे में पता चलता है. कोई मैच सिर्फ़ तब होता है, जब इंटेंट में मौजूद ऐक्शन और कैटगरी, IntentFilter क्लास के दस्तावेज़ में बताए गए फ़िल्टर से मैच करती हों.

आपका ऐप्लिकेशन, इंटेंट मैचिंग का इस्तेमाल उसी तरह कर सकता है जिस तरह Home ऐप्लिकेशन करता है. PackageManager में query...() का सेट है ऐसे तरीके जो किसी खास इंटेंट को स्वीकार कर सकने वाले सभी कॉम्पोनेंट को रिटर्न करते हैं और resolve...() विधियों की मिलती-जुलती सीरीज़, जो सबसे सही तरीके का पता लगाती है कॉम्पोनेंट का इस्तेमाल करता है. उदाहरण के लिए, queryIntentActivities(), उन सभी गतिविधियों की सूची दिखाता है जो परफ़ॉर्म कर सकती हैं इंटेंट को तर्क के तौर पर पास किया जाता है और queryIntentServices() मिलती-जुलती सेवाओं की सूची दिखाता है. इनमें से कोई भी तरीका कॉम्पोनेंट को चालू नहीं करता; वे सिर्फ़ वही जानकारी सूची में शामिल करते हैं जवाब दे सकते हैं. यह तरीका भी इससे मिलता-जुलता है, ब्रॉडकास्ट रिसीवर के लिए queryBroadcastReceivers().