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

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: यूआरआई से पता चलता है कि डेटा डिवाइस पर मौजूद है और इसे content: कंट्रोल करता है. इससे सिस्टम को डेटा का MIME टाइप दिखता है.ContentProvider

सिर्फ़ डेटा यूआरआई सेट करने के लिए, 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 नाम की कोई सेवा बनाई है, जिसे वेब से कोई फ़ाइल डाउनलोड करने के लिए डिज़ाइन किया गया है, तो इसे इस कोड से शुरू किया जा सकता है:

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

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

अपने ऐप्लिकेशन में असुरक्षित इंटेंट लॉन्च की जांच करने के लिए, 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

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

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

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

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

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

• Activity शुरू करने वाले Intent के लिए PendingIntent.getActivity().
• 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 को फ़्लैग के तौर पर पास किया जाता है.
• सूचनाओं को Android Auto फ़्रेमवर्क से जोड़ना. इसके लिए, CarAppExtender के इंस्टेंस का इस्तेमाल किया जाता है.
• 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. अगर किसी इंटेंट में एमआईएमई टाइप शामिल है, लेकिन यूआरआई नहीं है, तो वह टेस्ट तब ही पास करेगा, जब फ़िल्टर में वही एमआईएमई टाइप शामिल हो और यूआरआई फ़ॉर्मैट के बारे में जानकारी न दी गई हो.
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().