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

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

  • कोई गतिविधि शुरू करना

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

    अगर आपको गतिविधि पूरी होने पर उसका नतीजा चाहिए, तो startActivityForResult() पर कॉल करें. आपकी गतिविधि के लिए, नतीजे को आपकी गतिविधि के Intent कॉलबैक में अलग Intent ऑब्जेक्ट के तौर पर दिखाया जाता है.onActivityResult() ज़्यादा जानकारी के लिए, गतिविधियां गाइड देखें.

  • सेवा शुरू करना

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

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

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

  • ब्रॉडकास्ट मैसेज डिलीवर करना

    ब्रॉडकास्ट, ऐसा मैसेज होता है जिसे कोई भी ऐप्लिकेशन पा सकता है. सिस्टम, सिस्टम इवेंट के लिए अलग-अलग ब्रॉडकास्ट डिलीवर करता है. जैसे, जब सिस्टम बूट अप होता है या डिवाइस चार्ज होना शुरू होता है. 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 कंस्ट्रक्टर के साथ तय किया जा सकता है.

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

Kotlin

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

Java

static final String ACTION_TIMETRAVEL = "com.example.action.TIMETRAVEL";
डेटा
यूआरआई (एक Uri ऑब्जेक्ट), जो उस डेटा का रेफ़रंस देता है जिस पर कार्रवाई करनी है और/या उस डेटा का MIME टाइप. आम तौर पर, इंटेंट की कार्रवाई के हिसाब से डेटा दिया जाता है. उदाहरण के लिए, अगर कार्रवाई ACTION_EDIT है, तो डेटा में बदलाव किए जाने वाले दस्तावेज़ का यूआरआई होना चाहिए.

इंटेंट बनाते समय, यूआरआई के साथ-साथ डेटा का टाइप (इसका एमआईएमई टाइप) तय करना भी ज़रूरी होता है. उदाहरण के लिए, ऐसी गतिविधि जो इमेज दिखा सकती है वह शायद ऑडियो फ़ाइल नहीं चला पाएगी. भले ही, यूआरआई फ़ॉर्मैट एक जैसे हों. अपने डेटा का MIME टाइप तय करने से, Android सिस्टम को आपके इंटेंट को पाने के लिए सबसे सही कॉम्पोनेंट ढूंढने में मदद मिलती है. हालांकि, कभी-कभी यूआरआई से MIME टाइप का पता लगाया जा सकता है. खास तौर पर, जब डेटा 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 कुंजी का इस्तेमाल करके, ईमेल पाने वाले व्यक्ति का to पता तय किया जा सकता है. साथ ही, EXTRA_SUBJECT कुंजी का इस्तेमाल करके, subject तय किया जा सकता है.

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

Kotlin

const val EXTRA_GIGAWATTS = "com.example.EXTRA_GIGAWATTS"

Java

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

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

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

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

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

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

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

Kotlin

// 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)

Java

// 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() को कॉल किया जाता है, तो उपयोगकर्ता उस ऐप्लिकेशन को चुन सकता है जिसके ज़रिए कॉन्टेंट शेयर करना है.

Kotlin

// 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.
}

Java

// 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() को कॉल करने पर, सिस्टम इंस्टॉल किए गए सभी ऐप्लिकेशन की जांच करता है. इससे यह पता चलता है कि इनमें से कौनसे ऐप्लिकेशन इस तरह के इंटेंट को हैंडल कर सकते हैं. यह startActivity() ऐक्शन वाला इंटेंट होता है और इसमें "text/plain" डेटा होता है.ACTION_SEND अगर सिर्फ़ एक ऐप्लिकेशन ऐसा है जो इस अनुरोध को पूरा कर सकता है, तो वह ऐप्लिकेशन तुरंत खुल जाता है और उसे इंटेंट मिल जाता है. अगर कोई दूसरा ऐप्लिकेशन इसे हैंडल नहीं कर सकता, तो आपका ऐप्लिकेशन होने वाली ActivityNotFoundException को कैप्चर कर सकता है. अगर कई ऐक्टिविटी, इंटेंट को स्वीकार करती हैं, तो सिस्टम, दूसरी इमेज में दिखाए गए डायलॉग जैसा डायलॉग दिखाता है. इससे उपयोगकर्ता यह चुन सकता है कि उसे किस ऐप्लिकेशन का इस्तेमाल करना है.

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

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

ऐप्लिकेशन चुनने की सुविधा को चालू करना

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

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

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

Kotlin

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)
}

Java

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 का उल्लंघन होता है:

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

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

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

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

Kotlin

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

Java

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 लॉन्च कर सकता है. इस कॉन्फ़िगरेशन की मदद से, दूसरा ऐप्लिकेशन आपके ऐप्लिकेशन में किसी भी कॉम्पोनेंट को सुरक्षित तरीके से लॉन्च कर सकता है. इसमें एक्सपोर्ट नहीं किया गया कॉम्पोनेंट भी शामिल है.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

किसी सूचना को खारिज करना

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

किसी लंबित इंटेंट के मुख्य इस्तेमाल के उदाहरण यहां दिए गए हैं:

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

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

अगर आपका ऐप्लिकेशन, दूसरे ऐप्लिकेशन से पेंडिंग इंटेंट नहीं पा रहा है, तो 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 ऑब्जेक्ट में बदलाव नहीं किया जा सकता, तो अन्य ऐप्लिकेशन, इंटेंट को बदलकर इंटेंट को चालू करने के नतीजे में बदलाव नहीं कर सकते.

Kotlin

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

Java

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

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

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

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

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

यह बेहतर तरीके से तय करने के लिए कि अन्य ऐप्लिकेशन, आपके ऐप्लिकेशन के लंबित इंटेंट का इस्तेमाल कैसे कर सकते हैं, हमेशा एक्सप्लिसिट इंटेंट के आस-पास पेंडिंग इंटेंट रैप करें. इस सबसे सही तरीके को अपनाने के लिए, यह तरीका अपनाएं:

  1. यह पक्का करें कि बेस इंटेंट के लिए कार्रवाई, पैकेज, और कॉम्पोनेंट वाले फ़ील्ड सेट किए गए हों.

  2. पेंडिंग इंटेंट बनाने के लिए, Android 6.0 (एपीआई लेवल 23) में जोड़े गए FLAG_IMMUTABLE का इस्तेमाल करें. इस फ़्लैग से, उन ऐप्लिकेशन को रोका जाता है जिन्हें खाली प्रॉपर्टी से भरने की वजह से 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> एलिमेंट, यूआरआई स्ट्रक्चर और डेटा टाइप (MIME मीडिया टाइप) के बारे में जानकारी दे सकता है. यूआरआई का हर हिस्सा एक अलग एट्रिब्यूट होता है: 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 टाइप से करता है. नियम ये हैं:

  1. जिस इंटेंट में न तो यूआरआई और न ही MIME टाइप शामिल होता है वह टेस्ट तब ही पास करता है, जब फ़िल्टर में कोई यूआरआई या MIME टाइप शामिल न हो.
  2. अगर किसी इंटेंट में यूआरआई मौजूद है, लेकिन एमआईएमई टाइप नहीं है (न तो साफ़ तौर पर बताया गया है और न ही यूआरआई से इसका अनुमान लगाया जा सकता है), तो वह टेस्ट तभी पास करेगा, जब उसका यूआरआई, फ़िल्टर के यूआरआई फ़ॉर्मैट से मेल खाता हो. साथ ही, फ़िल्टर में भी एमआईएमई टाइप के बारे में जानकारी न दी गई हो.
  3. अगर किसी इंटेंट में MIME टाइप मौजूद है, लेकिन यूआरआई मौजूद नहीं है, तो वह टेस्ट तब ही पास कर पाएगा, जब फ़िल्टर में वही MIME टाइप मौजूद हो और यूआरआई फ़ॉर्मैट के बारे में कोई जानकारी न दी गई हो.
  4. अगर किसी इंटेंट में यूआरआई और 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().