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

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() की मदद से दोनों को साफ़ तौर पर सेट किया जा सकता है.

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