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

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

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

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

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

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

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

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

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

• ब्रॉडकास्ट डिलीवर करना

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

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

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

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

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

इमेज 1 में दिखाया गया है कि किसी गतिविधि को शुरू करते समय, इंटेंट का इस्तेमाल कैसे किया जाता है. जब 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 ऑब्जेक्ट), जो उस डेटा के बारे में बताता है जिस पर कार्रवाई की जानी है और/या उस डेटा का एमआईएमई टाइप. आम तौर पर, इंटेंट की कार्रवाई से यह तय होता है कि किस तरह का डेटा दिया जाएगा. उदाहरण के लिए, अगर कार्रवाई ACTION_EDIT है, तो डेटा में उस दस्तावेज़ का यूआरआई होना चाहिए जिसमें बदलाव करना है.

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

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

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

कैटगरी

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

CATEGORY_BROWSABLE

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

CATEGORY_LAUNCHER

यह गतिविधि, किसी टास्क की शुरुआती गतिविधि है और इसे सिस्टम के ऐप्लिकेशन लॉन्चर में लिस्ट किया गया है.

कैटगरी की पूरी सूची के लिए, Intent क्लास की जानकारी देखें.

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

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

अतिरिक्त सुविधाएं

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

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

उदाहरण के लिए, ACTION_SEND से ईमेल भेजने के लिए इंटेंट बनाते समय, EXTRA_EMAIL कुंजी की मदद से पाने वाले की जानकारी दी जा सकती है. साथ ही, EXTRA_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 नाम की कोई सेवा बनाई है, जिसे वेब से कोई फ़ाइल डाउनलोड करने के लिए डिज़ाइन किया गया है, तो उसे इस कोड से शुरू किया जा सकता है:

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

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

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

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

ऐप्लिकेशन चुनने के लिए मजबूर करना

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ऐप्लिकेशन के कॉम्पोनेंट को हर उस यूनीक काम के लिए अलग-अलग फ़िल्टर तय करने चाहिए जो वह कर सकता है. उदाहरण के लिए, इमेज गैलरी ऐप्लिकेशन में किसी गतिविधि के लिए दो फ़िल्टर हो सकते हैं: एक फ़िल्टर इमेज देखने के लिए और दूसरा फ़िल्टर इमेज में बदलाव करने के लिए. जब गतिविधि शुरू होती है, तो यह 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) और एमआईएमई टाइप के अलग-अलग पहलुओं के बारे में बताते हैं.

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

ध्यान दें: सभी गतिविधियों के लिए, आपको मेनिफ़ेस्ट फ़ाइल में अपने इंटेंट फ़िल्टर तय करने होंगे. हालांकि, ब्रॉडकास्ट रिसीवर के लिए फ़िल्टर, डाइनैमिक तौर पर रजिस्टर किए जा सकते हैं. इसके लिए, 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 पैनोरामा एपीआई की मदद से मैनेज किया जा सकता है.

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

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

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

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

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

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

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

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

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

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

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

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

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

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 को फ़्लैग के तौर पर पास किया जाता है.
• 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. पेंडिंग इंटेंट बनाने के लिए, 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> एलिमेंट में इनमें से कोई भी एट्रिब्यूट ज़रूरी नहीं है. हालांकि, इनमें लीनियर डिपेंडेंसी होती हैं:

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

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

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

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

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

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

ध्यान दें: अगर कोई इंटेंट, यूआरआई या एमआईएमई टाइप के बारे में बताता है, तो <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() नाम का एक मिलता-जुलता तरीका है.