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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

जब किसी इंप्लिसिट इंटेंट का इस्तेमाल किया जाता है, तो 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 सिस्टम को आपका इंटेंट पाने के लिए सबसे अच्छा कॉम्पोनेंट ढूंढने में मदद मिलती है. हालांकि, कभी-कभी यूआरआई से एमआईएम टाइप का पता लगाया जा सकता है. खास तौर पर, जब डेटा content: यूआरआई हो. content: यूआरआई से पता चलता है कि डेटा डिवाइस पर मौजूद है और ContentProvider से कंट्रोल किया जाता है. इससे सिस्टम को डेटा का MIME टाइप दिखता है.

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

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

कैटगरी

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

CATEGORY_BROWSABLE

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

CATEGORY_LAUNCHER

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

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

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

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

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

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

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

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

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

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

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

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

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 panorama एपीआई की मदद से मैनेज किया जा सकता है.

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

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

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

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

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

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

अगर आपके ऐप्लिकेशन को दूसरे ऐप्लिकेशन से, मंज़ूरी बाकी है वाले इंटेंट मिल रहे हैं, तो 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. 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> एलिमेंट में यूआरआई स्ट्रक्चर और डेटा टाइप (एमआईएम मीडिया टाइप) की जानकारी दी जा सकती है. यूआरआई का हर हिस्सा एक अलग एट्रिब्यूट होता है: scheme, host, port, और path:

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

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

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

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

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

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

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

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

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

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

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