मेन्यू जोड़ें

Compose को आज़माएं
Android के लिए, Jetpack Compose को यूज़र इंटरफ़ेस (यूआई) टूलकिट के तौर पर इस्तेमाल करने का सुझाव दिया जाता है. Compose में कॉम्पोनेंट जोड़ने का तरीका जानें.
मेन्यू →

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

इस इमेज में, ओवरफ़्लो मेन्यू का उदाहरण दिखाया गया है
पहली इमेज. आइकॉन पर टैप करने से ट्रिगर होने वाला मेन्यू, जो ओवरफ़्लो मेन्यू आइकॉन के नीचे दिखता है.

इस दस्तावेज़ में, Android के सभी वर्शन पर तीन तरह के मेन्यू या ऐक्शन प्रज़ेंटेशन बनाने का तरीका बताया गया है:

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

विकल्पों वाला मेन्यू बनाना सेक्शन देखें.

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

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

कॉन्टेक्स्ट मेन्यू बनाना सेक्शन देखें.

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

पॉप-अप मेन्यू बनाना सेक्शन देखें.

एक्सएमएल में मेन्यू तय करना

Android, सभी तरह के मेन्यू के लिए स्टैंडर्ड XML फ़ॉर्मैट उपलब्ध कराता है. इससे मेन्यू आइटम तय किए जा सकते हैं. अपनी गतिविधि के कोड में मेन्यू बनाने के बजाय, एक्सएमएल मेन्यू रिसॉर्स में मेन्यू और उसके सभी आइटम तय करें. इसके बाद, मेन्यू रिसॉर्स को अपनी ऐक्टिविटी या फ़्रैगमेंट में Menu ऑब्जेक्ट के तौर पर लोड करके, उसे बड़ा किया जा सकता है.

मेन्यू रिसॉर्स का इस्तेमाल करना इन वजहों से सबसे सही तरीका है:

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

मेन्यू तय करने के लिए, अपने प्रोजेक्ट की res/menu/ डायरेक्ट्री में एक एक्सएमएल फ़ाइल बनाएं. इसके बाद, यहां दिए गए एलिमेंट का इस्तेमाल करके मेन्यू बनाएं:

<menu>
यह Menu को तय करता है. यह मेन्यू आइटम के लिए एक कंटेनर होता है. <menu> एलिमेंट, फ़ाइल के लिए रूट नोड होना चाहिए. साथ ही, इसमें एक या उससे ज़्यादा <item> और <group> एलिमेंट हो सकते हैं.
<item>
यह MenuItem बनाता है, जो मेन्यू में मौजूद किसी एक आइटम को दिखाता है. इस एलिमेंट में, सब-मेन्यू बनाने के लिए नेस्ट किया गया <menu> एलिमेंट शामिल किया जा सकता है.
<group>
यह <item> एलिमेंट के लिए एक वैकल्पिक और अदृश्य कंटेनर होता है. इससे मेन्यू आइटम को कैटगरी में बांटा जा सकता है, ताकि वे प्रॉपर्टी शेयर कर सकें. जैसे, चालू स्थिति और दिखने की स्थिति. ज़्यादा जानकारी के लिए, मेन्यू ग्रुप बनाना सेक्शन देखें.

यहां game_menu.xml नाम वाले मेन्यू का एक उदाहरण दिया गया है:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/new_game"
          android:icon="@drawable/ic_new_game"
          android:title="@string/new_game"
          app:showAsAction="ifRoom"/>
    <item android:id="@+id/help"
          android:icon="@drawable/ic_help"
          android:title="@string/help" />
</menu>

<item> एलिमेंट के साथ कई एट्रिब्यूट काम करते हैं. इनका इस्तेमाल करके, किसी आइटम के दिखने के तरीके और उसके व्यवहार के बारे में बताया जा सकता है. ऊपर दिए गए मेन्यू में मौजूद आइटम में ये एट्रिब्यूट शामिल हैं:

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

ये ऐसे एट्रिब्यूट हैं जिनका इस्तेमाल सबसे ज़्यादा किया जाता है. हालांकि, इनके अलावा और भी कई एट्रिब्यूट उपलब्ध हैं. इस्तेमाल किए जा सकने वाले सभी एट्रिब्यूट के बारे में जानने के लिए, मेन्यू रिसॉर्स का दस्तावेज़ देखें.

किसी भी मेन्यू में मौजूद किसी आइटम में सबमेन्यू जोड़ा जा सकता है. इसके लिए, <item> के चाइल्ड के तौर पर <menu> एलिमेंट जोड़ें. सबमेन्यू तब काम आते हैं, जब आपके ऐप्लिकेशन में कई फ़ंक्शन होते हैं. इन्हें विषयों के हिसाब से व्यवस्थित किया जा सकता है. जैसे, पीसी ऐप्लिकेशन के मेन्यू बार में मौजूद आइटम—जैसे कि फ़ाइल, बदलाव करें, और देखें. यह उदाहरण देखें:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/file"
          android:title="@string/file" >
        <!-- "file" submenu -->
        <menu>
            <item android:id="@+id/create_new"
                  android:title="@string/create_new" />
            <item android:id="@+id/open"
                  android:title="@string/open" />
        </menu>
    </item>
</menu>

अपनी ऐक्टिविटी में मेन्यू का इस्तेमाल करने के लिए, मेन्यू रिसॉर्स को _inflate_ करें. इसके लिए, MenuInflater.inflate() का इस्तेमाल करके, एक्सएमएल रिसॉर्स को प्रोग्राम किए जा सकने वाले ऑब्जेक्ट में बदलें. यहां दिए गए सेक्शन में, हर तरह के मेन्यू के लिए मेन्यू को बड़ा करने का तरीका बताया गया है.

विकल्प मेन्यू बनाना

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

Google Sheets ऐप्लिकेशन का ऐप्लिकेशन बार दिखाने वाली इमेज
दूसरी इमेज. Google Sheets ऐप्लिकेशन में कई बटन दिखाए गए हैं. इनमें ऐक्शन ओवरफ़्लो बटन भी शामिल है.

अपने Activity सबक्लास या Fragment सबक्लास से, विकल्प मेन्यू के लिए आइटम जोड़े जा सकते हैं. अगर आपकी गतिविधि और फ़्रैगमेंट, दोनों में विकल्प मेन्यू के लिए आइटम तय किए गए हैं, तो आइटम को यूज़र इंटरफ़ेस (यूआई) में एक साथ दिखाया जाता है. गतिविधि के आइटम सबसे पहले दिखते हैं. इसके बाद, हर फ़्रैगमेंट के आइटम दिखते हैं. ये आइटम, गतिविधि में फ़्रैगमेंट जोड़ने के क्रम में दिखते हैं. अगर ज़रूरी हो, तो आपको जिन android:orderInCategory को मूव करना है उनमें android:orderInCategory एट्रिब्यूट का इस्तेमाल करके, मेन्यू आइटम का क्रम बदला जा सकता है.<item>

किसी ऐक्टिविटी के लिए विकल्प मेन्यू तय करने के लिए, onCreateOptionsMenu() को ओवरराइड करें. फ़्रैगमेंट, अपना onCreateOptionsMenu() कॉलबैक उपलब्ध कराते हैं. इस तरीके में, मेन्यू रिसॉर्स को Menu में बदला जा सकता है. यह Menu, कॉलबैक में दिया जाता है. मेन्यू रिसॉर्स को एक्सएमएल में तय किया जाता है. इसे यहां दिए गए उदाहरण में दिखाया गया है:

Kotlin

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    val inflater: MenuInflater = menuInflater
    inflater.inflate(R.menu.game_menu, menu)
    return true
}

Java

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.game_menu, menu);
    return true;
}

add() का इस्तेमाल करके मेन्यू आइटम जोड़े जा सकते हैं. साथ ही, findItem() का इस्तेमाल करके आइटम वापस पाए जा सकते हैं. इसके बाद, MenuItem एपीआई की मदद से उनकी प्रॉपर्टी में बदलाव किया जा सकता है.

क्लिक इवेंट मैनेज करना

जब उपयोगकर्ता, विकल्पों वाले मेन्यू से कोई आइटम चुनता है, तो सिस्टम आपकी गतिविधि के onOptionsItemSelected() तरीके को कॉल करता है. विकल्पों वाले मेन्यू में, ऐक्शन आइटम और ऐप्लिकेशन बार में मौजूद आइटम शामिल होते हैं. यह तरीका, चुने गए MenuItem को पास करता है. getItemId() को कॉल करके, आइटम की पहचान की जा सकती है. यह मेन्यू आइटम के लिए यूनीक आईडी दिखाता है. इसे मेन्यू रिसॉर्स में android:id एट्रिब्यूट या add() तरीके को दिए गए पूर्णांक से तय किया जाता है. इस आईडी को मेन्यू के जाने-पहचाने आइटम से मैच करके, सही कार्रवाई की जा सकती है.

Kotlin

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    // Handle item selection.
    return when (item.itemId) {
        R.id.new_game -> {
            newGame()
            true
        }
        R.id.help -> {
            showHelp()
            true
        }
        else -> super.onOptionsItemSelected(item)
    }
}

Java

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // Handle item selection.
    switch (item.getItemId()) {
        case R.id.new_game:
            newGame();
            return true;
        case R.id.help:
            showHelp();
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

मेन्यू आइटम को मैनेज करने के बाद, true वैल्यू दिखाएं. अगर आपको मेन्यू आइटम को हैंडल नहीं करना है, तो onOptionsItemSelected() के सुपरक्लास को लागू करें. डिफ़ॉल्ट तौर पर लागू करने पर, यह फ़ंक्शन false दिखाता है.

अगर आपकी ऐक्टिविटी में फ़्रैगमेंट शामिल हैं, तो सिस्टम सबसे पहले ऐक्टिविटी के लिए onOptionsItemSelected() को कॉल करता है. इसके बाद, हर फ़्रैगमेंट के लिए onOptionsItemSelected() को कॉल करता है. ऐसा तब तक किया जाता है, जब तक कोई फ़्रैगमेंट true नहीं दिखाता या सभी फ़्रैगमेंट कॉल नहीं कर लिए जाते.

रनटाइम के दौरान मेन्यू आइटम में बदलाव करना

सिस्टम के onCreateOptionsMenu() को कॉल करने के बाद, यह Menu का एक इंस्टेंस सेव रखता है. साथ ही, मेन्यू के अमान्य होने तक onCreateOptionsMenu() को फिर से कॉल नहीं करता. हालांकि, onCreateOptionsMenu() का इस्तेमाल सिर्फ़ मेन्यू की शुरुआती स्थिति बनाने के लिए करें. इसका इस्तेमाल, गतिविधि की लाइफ़साइकल के दौरान बदलाव करने के लिए न करें.

अगर आपको गतिविधि के लाइफ़साइकल के दौरान होने वाले इवेंट के आधार पर, विकल्प मेन्यू में बदलाव करना है, तो onPrepareOptionsMenu() तरीके में ऐसा किया जा सकता है. यह तरीका, आपको Menu ऑब्जेक्ट को मौजूदा स्थिति में पास करता है, ताकि आप इसमें बदलाव कर सकें. जैसे, आइटम जोड़ना, हटाना या बंद करना. फ़्रैगमेंट भी onPrepareOptionsMenu() कॉल बैक</0x0A>की सुविधा देते हैं.

जब मेन्यू आइटम, ऐप्लिकेशन बार में दिखाए जाते हैं, तब विकल्प मेन्यू को हमेशा खुला हुआ माना जाता है. जब कोई इवेंट होता है और आपको मेन्यू अपडेट करना होता है, तो invalidateOptionsMenu() को कॉल करें. इससे सिस्टम, onPrepareOptionsMenu() को कॉल करने का अनुरोध करेगा.

कॉन्टेक्स्ट के हिसाब से मेन्यू बनाना

फ़्लोटिंग कॉन्टेक्स्ट मेन्यू दिखाने वाली इमेज
तीसरी इमेज. फ़्लोटिंग कॉन्टेक्स्ट मेन्यू.

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

कॉन्टेक्स्ट के हिसाब से कार्रवाइयां उपलब्ध कराने के दो तरीके हैं:

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

ध्यान दें: संदर्भ मेन्यू में आइटम के शॉर्टकट और आइटम के आइकॉन काम नहीं करते.

फ़्लोटिंग कॉन्टेक्स्ट मेन्यू बनाना

फ़्लोटिंग कॉन्टेक्स्ट मेन्यू उपलब्ध कराने के लिए, यह तरीका अपनाएं:

  1. View को रजिस्टर करें, जिससे संदर्भ मेन्यू जुड़ा हुआ है. इसके लिए, registerForContextMenu() को कॉल करें और उसे View पास करें.

    अगर आपकी गतिविधि में RecyclerView का इस्तेमाल किया जाता है और आपको हर आइटम के लिए एक ही संदर्भ मेन्यू चाहिए, तो सभी आइटम को संदर्भ मेन्यू के लिए रजिस्टर करें. इसके लिए, RecyclerView को registerForContextMenu() पर पास करें.

  2. अपने Activity या Fragment में onCreateContextMenu() तरीका लागू करें.

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

    Kotlin

        override fun onCreateContextMenu(menu: ContextMenu, v: View,
                            menuInfo: ContextMenu.ContextMenuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo)
        val inflater: MenuInflater = menuInflater
        inflater.inflate(R.menu.context_menu, menu)
    }

    Java

        @Override
    public void onCreateContextMenu(ContextMenu menu, View v,
                                    ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.context_menu, menu);
    }

    MenuInflater की मदद से, मेन्यू रिसॉर्स से कॉन्टेक्स्ट मेन्यू को बड़ा किया जा सकता है. कॉलबैक तरीके के पैरामीटर में, उपयोगकर्ता की ओर से चुना गया View और ContextMenu.ContextMenuInfo ऑब्जेक्ट शामिल होता है. यह ऑब्जेक्ट, चुने गए आइटम के बारे में ज़्यादा जानकारी देता है. अगर आपकी गतिविधि में कई ऐसे व्यू हैं जिनमें हर एक के लिए अलग-अलग कॉन्टेक्स्ट मेन्यू उपलब्ध है, तो इन पैरामीटर का इस्तेमाल करके यह तय किया जा सकता है कि किस कॉन्टेक्स्ट मेन्यू को बड़ा करना है.

  3. onContextItemSelected() को लागू करें. इसके लिए, यहां दिया गया उदाहरण देखें. जब उपयोगकर्ता कोई मेन्यू आइटम चुनता है, तो सिस्टम इस तरीके को कॉल करता है, ताकि आप सही कार्रवाई कर सकें.

    Kotlin

        override fun onContextItemSelected(item: MenuItem): Boolean {
        val info = item.menuInfo as AdapterView.AdapterContextMenuInfo
        return when (item.itemId) {
            R.id.edit -> {
                editNote(info.id)
                true
            }
            R.id.delete -> {
                deleteNote(info.id)
                true
            }
            else -> super.onContextItemSelected(item)
        }
    }

    Java

        @Override
    public boolean onContextItemSelected(MenuItem item) {
        AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
        switch (item.getItemId()) {
            case R.id.edit:
                editNote(info.id);
                return true;
            case R.id.delete:
                deleteNote(info.id);
                return true;
            default:
                return super.onContextItemSelected(item);
        }
    }

    getItemId() मेथड, चुने गए मेन्यू आइटम के आईडी के लिए क्वेरी करता है. यह आईडी, android:id एट्रिब्यूट का इस्तेमाल करके, एक्सएमएल में हर मेन्यू आइटम को असाइन किया जाता है. इसे एक्सएमएल में मेन्यू तय करना में दिखाया गया है.

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

काम की कार्रवाई वाले मोड का इस्तेमाल करना

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

कॉन्टेक्स्ट के हिसाब से कार्रवाइयां करने की सुविधा देने वाले व्यू के लिए, आम तौर पर इन दोनों इवेंट में से किसी एक या दोनों के होने पर, कॉन्टेक्स्ट के हिसाब से कार्रवाई करने का मोड चालू किया जाता है:

  • जब उपयोगकर्ता व्यू को दबाकर रखता है.
  • उपयोगकर्ता, व्यू में मौजूद किसी चेकबॉक्स या मिलते-जुलते यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को चुनता है.

आपका ऐप्लिकेशन, कॉन्टेक्स्ट के हिसाब से कार्रवाई करने वाले मोड को कैसे चालू करता है और हर कार्रवाई के लिए व्यवहार कैसे तय करता है, यह आपके डिज़ाइन पर निर्भर करता है. ये दो डिज़ाइन में उपलब्ध हैं:

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

यहां दिए गए सेक्शन में, पहले परिदृश्य के लिए ज़रूरी सेटअप के बारे में बताया गया है.

अलग-अलग व्यू के लिए, काम की कार्रवाई वाला मोड चालू करना

अगर आपको काम की कार्रवाई वाले मोड को सिर्फ़ तब चालू करना है, जब उपयोगकर्ता कुछ खास व्यू चुनता है, तो यह तरीका अपनाएं:

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

    Kotlin

        private val actionModeCallback = object : ActionMode.Callback {
        // Called when the action mode is created. startActionMode() is called.
        override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
            // Inflate a menu resource providing context menu items.
            val inflater: MenuInflater = mode.menuInflater
            inflater.inflate(R.menu.context_menu, menu)
            return true
        }

        // Called each time the action mode is shown. Always called after
        // onCreateActionMode, and might be called multiple times if the mode
        // is invalidated.
        override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
            return false // Return false if nothing is done
        }

        // Called when the user selects a contextual menu item.
        override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
            return when (item.itemId) {
                R.id.menu_share -> {
                    shareCurrentItem()
                    mode.finish() // Action picked, so close the CAB.
                    true
                }
                else -> false
            }
        }

        // Called when the user exits the action mode.
        override fun onDestroyActionMode(mode: ActionMode) {
            actionMode = null
        }
    }

    Java

        private ActionMode.Callback actionModeCallback = new ActionMode.Callback() {

        // Called when the action mode is created. startActionMode() is called.
        @Override
        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
            // Inflate a menu resource providing context menu items.
            MenuInflater inflater = mode.getMenuInflater();
            inflater.inflate(R.menu.context_menu, menu);
            return true;
        }

        // Called each time the action mode is shown. Always called after
        // onCreateActionMode, and might be called multiple times if the mode
        // is invalidated.
        @Override
        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
            return false; // Return false if nothing is done.
        }

        // Called when the user selects a contextual menu item.
        @Override
        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
           switch (item.getItemId()) {
                case R.id.menu_share:
                    shareCurrentItem();
                    mode.finish(); // Action picked, so close the CAB.
                    return true;
                default:
                    return false;
            }
        }

        // Called when the user exits the action mode.
        @Override
        public void onDestroyActionMode(ActionMode mode) {
            actionMode = null;
        }
    };

    ये इवेंट कॉलबैक, विकल्प मेन्यू के कॉलबैक की तरह ही होते हैं. हालांकि, इनमें से हर कॉलबैक, इवेंट से जुड़ा ActionMode ऑब्जेक्ट भी पास करता है. ActionMode एपीआई का इस्तेमाल करके, सीएबी में कई तरह के बदलाव किए जा सकते हैं. जैसे, setTitle() और setSubtitle() की मदद से टाइटल और सबटाइटल में बदलाव करना. इससे यह पता चलता है कि कितने आइटम चुने गए हैं.

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

  2. कॉल करें startActionMode() जब आपको बार दिखाना हो. जैसे, जब उपयोगकर्ता व्यू पर टच करके रखता है.

    Kotlin

        someView.setOnLongClickListener { view ->
        // Called when the user performs a touch & hold on someView.
        when (actionMode) {
            null -> {
                // Start the CAB using the ActionMode.Callback defined earlier.
                actionMode = activity?.startActionMode(actionModeCallback)
                view.isSelected = true
                true
            }
            else -> false
        }
    }

    Java

        someView.setOnLongClickListener(new View.OnLongClickListener() {
        // Called when the user performs a touch & hold on someView.
        public boolean onLongClick(View view) {
            if (actionMode != null) {
                return false;
            }

            // Start the CAB using the ActionMode.Callback defined earlier.
            actionMode = getActivity().startActionMode(actionModeCallback);
            view.setSelected(true);
            return true;
        }
    });

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

पॉप-अप मेन्यू बनाना

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

PopupMenu, View से जुड़ा एक मोडल मेन्यू होता है. अगर जगह होती है, तो यह ऐंकर किए गए व्यू के नीचे दिखता है. अगर जगह नहीं होती है, तो यह व्यू के ऊपर दिखता है. यह इन कामों के लिए उपयोगी है:

  • कार्रवाइयों के लिए ओवरफ़्लो स्टाइल वाला मेन्यू उपलब्ध कराना. ये कार्रवाइयाँ, किसी खास कॉन्टेंट से जुड़ी होती हैं. जैसे, Gmail के ईमेल हेडर. इन्हें इमेज 4 में दिखाया गया है.
  • कमांड वाले वाक्य का दूसरा हिस्सा देना. जैसे, जोड़ें के तौर पर मार्क किया गया बटन, जो जोड़ें के अलग-अलग विकल्पों वाला पॉप-अप मेन्यू दिखाता है.
  • Spinner के जैसा मेन्यू उपलब्ध कराना, जिसमें लगातार चुने गए विकल्प को सेव नहीं किया जाता.

अगर आपने एक्सएमएल में मेन्यू तय किया है, तो पॉप-अप मेन्यू दिखाने का तरीका यहां बताया गया है:

  1. इसके कंस्ट्रक्टर के साथ PopupMenu को इंस्टैंटिएट करें. यह मौजूदा ऐप्लिकेशन Context और View लेता है, जिससे मेन्यू को ऐंकर किया जाता है.
  2. MenuInflater का इस्तेमाल करके, मेन्यू रिसॉर्स को Menu ऑब्जेक्ट में बदलें. यह ऑब्जेक्ट, PopupMenu.getMenu() फ़ंक्शन से मिलता है.
  3. PopupMenu.show() पर कॉल करें.

उदाहरण के लिए, यहां एक ऐसा बटन दिया गया है जो पॉप-अप मेन्यू दिखाता है:

<ImageButton
    android:id="@+id/dropdown_menu"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:contentDescription="@string/descr_overflow_button"
    android:src="@drawable/arrow_drop_down" />

इसके बाद, गतिविधि में इस तरह पॉप-अप मेन्यू दिख सकता है:

Kotlin

findViewById<ImageButton>(R.id.dropdown_menu).setOnClickListener {
    val popup = PopupMenu(this, it)
    val inflater: MenuInflater = popup.menuInflater
    inflater.inflate(R.menu.actions, popup.menu)
    popup.show()
}

Java

findViewById(R.id.dropdown_menu).setOnClickListener(v -> {
    PopupMenu popup = new PopupMenu(this, v);
    popup.getMenuInflater().inflate(R.menu.actions, popup.getMenu());
    popup.show();
});

जब उपयोगकर्ता कोई आइटम चुनता है या मेन्यू के बाहर टैप करता है, तब मेन्यू बंद हो जाता है. PopupMenu.OnDismissListener का इस्तेमाल करके, खारिज करने के इवेंट को सुना जा सकता है.

क्लिक इवेंट मैनेज करना

जब उपयोगकर्ता कोई मेन्यू आइटम चुनता है, तब कोई कार्रवाई करने के लिए, PopupMenu.OnMenuItemClickListener इंटरफ़ेस लागू करें. साथ ही, इसे PopupMenu के साथ रजिस्टर करें. इसके लिए, setOnMenuItemclickListener() को कॉल करें. जब उपयोगकर्ता किसी आइटम को चुनता है, तो सिस्टम आपके इंटरफ़ेस में onMenuItemClick() कॉलबैक को कॉल करता है.

इसे यहां दिए गए उदाहरण में दिखाया गया है:

Kotlin

fun showMenu(v: View) {
    PopupMenu(this, v).apply {
        // MainActivity implements OnMenuItemClickListener.
        setOnMenuItemClickListener(this@MainActivity)
        inflate(R.menu.actions)
        show()
    }
}

override fun onMenuItemClick(item: MenuItem): Boolean {
    return when (item.itemId) {
        R.id.archive -> {
            archive(item)
            true
        }
        R.id.delete -> {
            delete(item)
            true
        }
        else -> false
    }
}

Java

public void showMenu(View v) {
    PopupMenu popup = new PopupMenu(this, v);

    // This activity implements OnMenuItemClickListener.
    popup.setOnMenuItemClickListener(this);
    popup.inflate(R.menu.actions);
    popup.show();
}

@Override
public boolean onMenuItemClick(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.archive:
            archive(item);
            return true;
        case R.id.delete:
            delete(item);
            return true;
        default:
            return false;
    }
}

मेन्यू ग्रुप बनाना

मेन्यू ग्रुप, मेन्यू आइटम का एक कलेक्शन होता है. इसमें शामिल मेन्यू आइटम की कुछ विशेषताएं एक जैसी होती हैं. किसी ग्रुप की मदद से, ये काम किए जा सकते हैं:

  • setGroupVisible() का इस्तेमाल करके, सभी आइटम दिखाएं या छिपाएं.
  • setGroupEnabled() का इस्तेमाल करके, सभी आइटम के लिए इस सुविधा को चालू या बंद करें.
  • यह तय करें कि setGroupCheckable() का इस्तेमाल करके, सभी आइटम की जांच की जा सकती है या नहीं.

ग्रुप बनाने के लिए, मेन्यू रिसॉर्स में मौजूद <group> एलिमेंट के अंदर <item> एलिमेंट नेस्ट किए जा सकते हैं. इसके अलावा, add() तरीके का इस्तेमाल करके, ग्रुप आईडी भी तय किया जा सकता है.

यहां मेन्यू रिसॉर्स का एक उदाहरण दिया गया है, जिसमें एक ग्रुप शामिल है:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/menu_save"
          android:icon="@drawable/menu_save"
          android:title="@string/menu_save" />
    <!-- menu group -->
    <group android:id="@+id/group_delete">
        <item android:id="@+id/menu_archive"
              android:title="@string/menu_archive" />
        <item android:id="@+id/menu_delete"
              android:title="@string/menu_delete" />
    </group>
</menu>

ग्रुप में मौजूद आइटम, पहले आइटम के साथ एक ही लेवल पर दिखते हैं. मेन्यू में मौजूद तीनों आइटम, एक ही लेवल पर दिखते हैं. हालांकि, ग्रुप आईडी का रेफ़रंस देकर और ऊपर बताए गए तरीकों का इस्तेमाल करके, ग्रुप में मौजूद दोनों आइटम की विशेषताओं में बदलाव किया जा सकता है. सिस्टम, ग्रुप किए गए आइटम को कभी अलग नहीं करता. उदाहरण के लिए, अगर आपने हर आइटम के लिए android:showAsAction="ifRoom" का एलान किया है, तो ये दोनों कार्रवाई बार में दिखेंगे या दोनों कार्रवाई ओवरफ़्लो में दिखेंगे.

चेक किए जा सकने वाले मेन्यू आइटम इस्तेमाल करना

पांचवीं इमेज. चेक किए जा सकने वाले आइटम के साथ एक सबमेन्यू.

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

<item> एलिमेंट में मौजूद android:checkable एट्रिब्यूट का इस्तेमाल करके, मेन्यू के अलग-अलग आइटम के लिए, चुने जा सकने वाले व्यवहार को तय किया जा सकता है. इसके अलावा, <group> एलिमेंट में मौजूद android:checkableBehavior एट्रिब्यूट का इस्तेमाल करके, पूरे ग्रुप के लिए भी ऐसा किया जा सकता है. उदाहरण के लिए, इस मेन्यू ग्रुप में मौजूद सभी आइटम को रेडियो बटन की मदद से चुना जा सकता है:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <group android:checkableBehavior="single">
        <item android:id="@+id/red"
              android:title="@string/red" />
        <item android:id="@+id/blue"
              android:title="@string/blue" />
    </group>
</menu>

android:checkableBehavior एट्रिब्यूट इनमें से कोई एक वैल्यू स्वीकार करता है:

single
ग्रुप में से सिर्फ़ एक आइटम चुना जा सकता है. इससे रेडियो बटन बनते हैं.
all
सभी आइटम चुने जा सकते हैं. इससे चेकबॉक्स दिखते हैं.
none
किसी भी आइटम को चुना नहीं जा सकता.

<item> एलिमेंट में मौजूद android:checked एट्रिब्यूट का इस्तेमाल करके, किसी आइटम के लिए डिफ़ॉल्ट रूप से चुने गए विकल्प को लागू किया जा सकता है. साथ ही, setChecked() तरीके का इस्तेमाल करके, कोड में इसे बदला जा सकता है.

जब चुने जा सकने वाले किसी आइटम को चुना जाता है, तो सिस्टम आपके आइटम-चुने गए कॉलबैक तरीके को कॉल करता है. जैसे, onOptionsItemSelected(). यहां चेकबॉक्स की स्थिति सेट की जाती है, क्योंकि चेकबॉक्स या रेडियो बटन की स्थिति अपने-आप नहीं बदलती. isChecked() की मदद से, आइटम की मौजूदा स्थिति के बारे में क्वेरी की जा सकती है. यह स्थिति, उपयोगकर्ता के आइटम चुनने से पहले की स्थिति होती है. इसके बाद, setChecked() की मदद से, चुने गए आइटम की स्थिति सेट की जा सकती है. इसे यहां दिए गए उदाहरण में दिखाया गया है:

Kotlin

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    return when (item.itemId) {
        R.id.vibrate, R.id.dont_vibrate -> {
            item.isChecked = !item.isChecked
            true
        }
        else -> super.onOptionsItemSelected(item)
    }
}

Java

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.vibrate:
        case R.id.dont_vibrate:
            if (item.isChecked()) item.setChecked(false);
            else item.setChecked(true);
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

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

किसी इंटेंट के आधार पर मेन्यू आइटम जोड़ना

कभी-कभी, आपको किसी मेन्यू आइटम से Intent का इस्तेमाल करके कोई गतिविधि लॉन्च करनी होती है. यह गतिविधि आपके ऐप्लिकेशन में या किसी दूसरे ऐप्लिकेशन में हो सकती है. अगर आपको उस इंटेंट के बारे में पता है जिसका इस्तेमाल करना है और आपके पास कोई ऐसा मेन्यू आइटम है जो इंटेंट शुरू करता है, तो onOptionsItemSelected() जैसे सही on-item-selected कॉलबैक तरीके के दौरान, startActivity() का इस्तेमाल करके इंटेंट को लागू किया जा सकता है.

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

उपलब्ध उन गतिविधियों के आधार पर मेन्यू आइटम जोड़ने के लिए जो इंटेंट स्वीकार करती हैं, यह तरीका अपनाएं:

  1. CATEGORY_ALTERNATIVE या CATEGORY_SELECTED_ALTERNATIVE या दोनों के साथ-साथ अन्य ज़रूरी शर्तों के साथ, इंटेंट तय करें.
  2. Menu.addIntentOptions() पर कॉल करें. इसके बाद, Android ऐसे ऐप्लिकेशन खोजता है जो इस इंटेंट को पूरा कर सकते हैं. साथ ही, उन्हें आपके मेन्यू में जोड़ देता है.

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

इसे यहां दिए गए उदाहरण में दिखाया गया है:

Kotlin

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    super.onCreateOptionsMenu(menu)

    // Create an Intent that describes the requirements to fulfill, to be
    // included in the menu. The offering app must include a category value
    // of Intent.CATEGORY_ALTERNATIVE.
    val intent = Intent(null, dataUri).apply {
        addCategory(Intent.CATEGORY_ALTERNATIVE)
    }

    // Search and populate the menu with acceptable offering apps.
    menu.addIntentOptions(
            R.id.intent_group,  // Menu group to which new items are added.
            0,                  // Unique item ID (none).
            0,                  // Order for the items (none).
            this.componentName, // The current activity name.
            null,               // Specific items to place first (none).
            intent,             // Intent created above that describes the requirements.
            0,                  // Additional flags to control items (none).
            null)               // Array of MenuItems that correlate to specific items (none).

    return true
}

Java

@Override
public boolean onCreateOptionsMenu(Menu menu){
    super.onCreateOptionsMenu(menu);

    // Create an Intent that describes the requirements to fulfill, to be
    // included in the menu. The offering app must include a category value
    // of Intent.CATEGORY_ALTERNATIVE.
    Intent intent = new Intent(null, dataUri);
    intent.addCategory(Intent.CATEGORY_ALTERNATIVE);

    // Search and populate the menu with acceptable offering apps.
    menu.addIntentOptions(
         R.id.intent_group,         // Menu group to which new items are added.
         0,                         // Unique item ID (none).
         0,                         // Order for the items (none).
         this.getComponentName(),   // The current activity name.
         null,                      // Specific items to place first (none).
         intent,                    // Intent created above that describes the requirements.
         0,                         // Additional flags to control items (none).
         null);                     // Array of MenuItems that correlate to specific items (none).

    return true;
}

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

अपनी गतिविधि को अन्य मेन्यू में जोड़ने की अनुमति दें

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

किसी अन्य ऐप्लिकेशन के मेन्यू में शामिल होने के लिए, सामान्य तरीके से इंटेंट फ़िल्टर तय करें. हालांकि, इंटेंट फ़िल्टर कैटगरी के लिए CATEGORY_ALTERNATIVE या CATEGORY_SELECTED_ALTERNATIVE वैल्यू या दोनों शामिल करें. इसे यहां दिए गए उदाहरण में दिखाया गया है:

<intent-filter label="@string/resize_image">
    ...
    <category android:name="android.intent.category.ALTERNATIVE" />
    <category android:name="android.intent.category.SELECTED_ALTERNATIVE" />
    ...
</intent-filter>

इंटेंट और इंटेंट फ़िल्टर में, इंटेंट फ़िल्टर लिखने के बारे में ज़्यादा पढ़ें.