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

लिखने का तरीका आज़माएं

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

TopAppBar →

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

इस दस्तावेज़ में तीन बुनियादी तरह के मेन्यू बनाने या Android के सभी वर्शन पर कार्रवाई प्रज़ेंटेशन:

विकल्प मेन्यू और ऐप्लिकेशन बार

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

विकल्प मेन्यू बनाएं लेख पढ़ें सेक्शन में जाएं.

संदर्भ मेन्यू और संदर्भ के हिसाब से कार्रवाई मोड

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

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

संदर्भ मेन्यू बनाना पढ़ें सेक्शन में जाएं.

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

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

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

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

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

यह आइटम, ऐक्शन आइटम के तौर पर कब और कैसे दिखता है, इसके बारे में जानकारी शामिल कर सकते हैं.

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

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

<?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(). यहां दिए गए सेक्शन में, हर तरह के मेन्यू के लिए, मेन्यू को इनफ़्लेट करने का तरीका बताया गया है.

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

विकल्प मेन्यू, जैसा कि पहली इमेज में दिखाया गया है, वह जगह है जहां आप मौजूदा गतिविधि के हिसाब से काम की कार्रवाइयां और अन्य विकल्प चुनें, जैसे कि "Search", "ईमेल लिखो" और "सेटिंग" पर क्लिक करें.

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

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

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

@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() तरीके में. इस आईडी का मिलान, जाने-पहचाने मेन्यू से किया जा सकता है आइटम का उपयोग करके उचित कार्रवाई की जा सकती है.

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)
    }
}

@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(). डिफ़ॉल्ट रूप से लागू होने पर, यह दिखता है गलत.

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

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

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

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

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

संदर्भ के हिसाब से मेन्यू बनाना

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

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

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

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

फ़्लोटिंग संदर्भ मेन्यू बनाना

फ़्लोटिंग संदर्भ मेन्यू उपलब्ध कराने के लिए, ये काम करें:

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

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

2. लागू करें onCreateContextMenu() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है तरीका है.ActivityFragment

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

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

PopupMenu View से जुड़ा मॉडल मेन्यू है. यह ऐंकर के नीचे दिखता है दृश्य के ऊपर या उसके स्थान पर. यह पब्लिशर, फ़ॉलो किया जा रहा है:

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

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

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()
}

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() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है कॉलबैक की प्रक्रिया शुरू की है.

यह नीचे दिए गए उदाहरण में दिखाया गया है:

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
    }
}

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().

<item> एलिमेंट को नेस्ट करके ग्रुप बनाया जा सकता है अपने मेन्यू रिसॉर्स में <group> एलिमेंट जोड़कर या ग्रुप आईडी 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 एट्रिब्यूट या android:checkableBehavior वाले पूरे ग्रुप के लिए विशेषता <group> एलिमेंट में शामिल करें. उदाहरण के लिए, इसमें मौजूद सभी आइटम इस मेनू समूह को एक रेडियो बटन से जाँचा जा सकता है:

<?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() से चेक की गई स्थिति सेट करें. यह इसमें दिखाया गया है नीचे दिया गया उदाहरण:

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)
    }
}

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

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

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

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

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

यह नीचे दिए गए उदाहरण में दिखाया गया है:

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
}

@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>

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