मैं एक्शनबार में मेनू आइटम कैसे छिपा सकता हूं?

Question

मेरे पास एक मेनू बार के साथ एक एक्शन बार है। मैं उस मेनू आइटम को कैसे छिपा / दिखा सकता हूं?

यही मैं करने की कोशिश कर रहा हूँ:

MenuItem item = (MenuItem) findViewById(R.id.addAction);
item.setVisible(false);
this.invalidateOptionsMenu();

Answer 1

एक हो जाओ MenuItemइस तरह के आइटम इंगित करता, कॉल setVisibleउस पर उसकी दृश्यता समायोजित करने के लिए और फिर फोन invalidateOptionsMenu()पर अपनी गतिविधि के इतने ActionBar मेनू के हिसाब से निकाला जाता है।

अद्यतन: एक MenuItemएक नियमित रूप से मानना है कि अपने लेआउट का हिस्सा है नहीं है। इसकी कुछ खास, बिल्कुल अलग। आपका कोड वापस आ nullजाता है itemऔर यही दुर्घटना का कारण बनता है। इसके बजाय आपको क्या करने की आवश्यकता है:

MenuItem item = menu.findItem(R.id.addAction);

यहां वह क्रम दिया गया है जिसमें आपको कॉल करना चाहिए: पहले कॉल करें invalidateOptionsMenu()और फिर onCreateOptionsMenu(Menu)MenuItem (कॉल करके menu.findItem()) का संदर्भ प्राप्त करें और उस setVisible()पर कॉल करें

Comments

यह वही है जो मैंने शुरू में सोचा था, लेकिन यह एप्लिकेशन को क्रैश कर देता है।

— स्टिर ज़ोल्टन

@Stir Zoltán: ठीक है कि आप इसे कैसे करते हैं, यदि आप एप्लिकेशन को क्रैश करते हैं तो आप इसे गलत कर सकते हैं। उदाहरण के लिए, आपका MenuItemहो सकता है nullक्योंकि आप getItemइसके बजाय उपयोग कर रहे हैं findItem। हम आपके कोड और क्रैश लॉग को देखे बिना कभी नहीं जान सकते थे।

— K-ballo

ठीक है, लेकिन मुझे onCreateOptionsMenu विधि के बाहर मेनू का संदर्भ कैसे मिल सकता है?

— स्टिर ज़ोल्टन

@Stir Zoltán: मेरा मानना ​​है कि आपको उस अंतिम टिप्पणी से कोई मतलब नहीं है ... बस अपने मेनू आइटम का संदर्भ लें onCreateOptionsMenu, और उस बिंदु पर आइटम दृश्यता सेट करें। या जब तक आप यह तय नहीं कर लेते कि यह दिखाई दे या नहीं, तब तक संदर्भ को अपने पास रखें।

— के-बल्लो

मुझे लगता है कि (सबसे अच्छे रूप में) यह जवाब खराब शब्दों में दिया गया है क्योंकि चरणों का अनुक्रम गलत है। सही अनुक्रम पहले कॉल करना है invalidateOptionsMenu()और फिर अंदर (कॉल करके ) और उस पर कॉल onCreateOptionsMenu(Menu)करने के लिए एक संदर्भ प्राप्त करना है। जवाब suhas_sm द्वारा और P1r4nh4 द्वारा सही दृष्टिकोण प्रस्तुत करते हैं। MenuItemmenu.findItem()setVisible()

— टेड होप

Answer 2

इस प्रश्न के लिए एक परिशिष्ट मिला:

यदि आप चलते-फिरते अपने मेनू आइटमों की दृश्यता को बदलना चाहते हैं, तो आपको अपनी गतिविधि में एक सदस्य चर सेट करने की आवश्यकता है, ताकि यह याद रहे कि आप मेनू को छुपाना चाहते हैं invalidateOptionsMenu()और अपने ओवरराइड onCreateOptionsMenu(...)पद्धति में आइटमों को कॉल और छिपा सकते हैं ।

//anywhere in your code
...
mState = HIDE_MENU; // setting state
invalidateOptionsMenu(); // now onCreateOptionsMenu(...) is called again
...

@Override
public boolean onCreateOptionsMenu(Menu menu)
{
    // inflate menu from xml
    MenuInflater inflater = getSupportMenuInflater();
    inflater.inflate(R.menu.settings, menu);

    if (mState == HIDE_MENU)
    {
        for (int i = 0; i < menu.size(); i++)
            menu.getItem(i).setVisible(false);
    }
}

मेरे उदाहरण में मैंने सभी आइटम छिपाए हैं।

Comments

यह वही है जिसकी मुझे तलाश है। MenuItem पर कॉल करना और setV अदृश्य () को वह नहीं करना चाहिए जो मुझे उम्मीद थी (शायद इसलिए कि मैं अमान्य कॉल कर रहा था ।Menu () के बाद, इस प्रकार मेनू को फिर से बनाना), लेकिन किसी भी तरह से - यह ठीक वैसे ही काम करता है जैसा मैं उम्मीद कर रहा था, धन्यवाद!

— मैट

यदि आप प्रत्येक आइटम को छिपाने जा रहे हैं, तो एक आसान तरीका है। यहां प्रत्येक आइटम के माध्यम से लूप करने के बजाय, आप बस कर सकते हैं: if (HIDE_MENU) { return false; } else { getSupportMenuInflater().inflate(R.menu.menu_settings, menu); return true; }डॉक्स स्थिति: "आपको प्रदर्शित होने वाले मेनू के लिए सही लौटना होगा; यदि आप झूठे वापस आते हैं तो यह नहीं दिखाया जाएगा"।

— w3bshark

इसके अलावा, मैं यह उल्लेख करना चाहूंगा कि यह दृष्टिकोण स्वीकृत उत्तर की तुलना में बहुत साफ है। साझा करने के लिए धन्यवाद!

— w3bshark

कॉल करके अमान्य। अच्छे उत्तर के लिए धन्यवाद

— user1912026

onPrepareOptionsMenu()इसके बजाय दिखाने / छिपाने के तर्क के लिए इस्तेमाल किया जाना चाहिए onCreateOptionsMenu()क्योंकि यह केवल एक बार कहा जाता है इसलिए उपयोगी नहीं है यदि आप इसके प्रारंभ होने के बाद मेनू आइटम बदलना चाहते हैं। इसलिए onCreate में बढ़ें, लेकिन onPrepare में दिखाएं / छुपाएं।

— JCutting8

Answer 3

हाँ।

1. आप एक ध्वज / स्थिति सेट कर सकते हैं।
2. invalidateOptionsMenu()जब आप विकल्प को छुपाना चाहें तब कॉल करें । यह कॉल करेगा onCreateOptionsMenu()।
3. में onCreateOptionsMenu(), झंडा / हालत और शो या के लिए चेक इसे छिपाने निम्नलिखित तरीके:

MenuItem item = menu.findItem(R.id.menu_Done);

if (flag/condition)) {
  item.setVisible(false); 
} else { }

Comments

invalidateOptionsMenuइसके बजाय नहीं होना चाहिए invalidateOptions?

— razz

यदि आप अपने झंडे को एक बूलियन बनाते हैं, तो आप ज़रूरत पड़ने पर आइटम की दृश्यता को ध्वज (या ध्वज) पर सेट कर सकते हैं। तो, item.setVisbility (झंडा!); यह एक लाइनर बनाता है अगर कोई शर्त नहीं है।

— jwehrle

चर "मेनू" कहां परिभाषित किया गया है?

— जोनाथन

इसे एक पैरामीटर के रूप में पारित किया गया हैonCreateOptionsMenu

— suhas_sm

इस पद्धति का उपयोग करने का मतलब होगा कि आइटम अभी भी जगह की खपत करता है और आप अपने यूआई में "गैप" के साथ समाप्त हो सकते हैं जहां बटन होना चाहिए। OnPrepareOptionsMenu () में removeItem का उपयोग करके ट्रिक करेंगे।

— JCutting8

Answer 4

आप इसे कॉल कर सकते हैं:

MenuItem item = menu.findItem(R.id.my_item);
item.setVisible(false);

अपडेट करें:

सुनिश्चित करें कि आपका कोड वापस नहीं आता nullहै itemया यह एप्लिकेशन क्रैश कर सकता है।

Comments

इस पद्धति का उपयोग करने का मतलब होगा कि आइटम अभी भी जगह की खपत करता है और आप अपने यूआई में "गैप" के साथ समाप्त हो सकते हैं जहां बटन होना चाहिए। OnPrepareOptionsMenu () में removeItem का उपयोग करके ट्रिक करेंगे।

— JCutting8

Answer 5

मैं थोड़ा और संदर्भ के साथ उत्तर की तलाश में था। अब जब मैंने इसका पता लगा लिया है, तो मैं इसका उत्तर दूंगा।

मेनू में डिफ़ॉल्ट बटन को छिपाएं xml

डिफ़ॉल्ट रूप से शेयर बटन छिपा दिया जाएगा, जैसा कि द्वारा निर्धारित किया गया है android:visible="false"।

main_menu.xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:app="http://schemas.android.com/apk/res-auto">

    <!-- hide share button by default -->
    <item
        android:id="@+id/menu_action_share"
        android:icon="@drawable/ic_share_white_24dp"
        android:visible="false"     
        android:title="Share"
        app:showAsAction="always"/>

    <item
        android:id="@+id/menu_action_settings"
        android:icon="@drawable/ic_settings_white_24dp"
        android:title="Setting"
        app:showAsAction="ifRoom"/>

</menu>

कोड में बटन दिखाएं

लेकिन शेयर बटन को वैकल्पिक रूप से कुछ शर्त के आधार पर दिखाया जा सकता है।

MainActivity.java

public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.main_menu, menu);
    MenuItem shareItem = menu.findItem(R.id.menu_action_share);

    // show the button when some condition is true
    if (someCondition) {        
        shareItem.setVisible(true);
    }

    return true;
}

यह सभी देखें

• ऐप बार सेट करना (ऐप / एक्शन बार सेट करने में मदद के लिए एंड्रॉइड डॉक्स)

Comments

onPrepareOptionsMenu () का उपयोग onCreateOptionsMenu () के बजाय दिखाने / छिपाने के तर्क के लिए किया जाना चाहिए क्योंकि इसे केवल एक बार उपयोगी नहीं कहा जाता है यदि आप इसके प्रारंभ होने के बाद मेनू आइटम बदलना चाहते हैं। इसलिए onCreate में बढ़ें, लेकिन onPrepare में दिखाएं / छुपाएं, फिर invalidateOptionsMenu()मेनू को रिफ्रेश करने के लिए उपयोग करें।

— JCutting8

Answer 6

मेरे लिए काम नहीं किया। मुझे onPrepareOptionsMenuअदृश्य रूप से आइटम सेट करने के लिए स्पष्ट रूप से उपयोग करना था ।

इसलिए onCreateOptionsMenuमेनू बनाने और onPrepareOptionsMenuदृश्यता आदि को बदलने के लिए उपयोग करें ।

Comments

मेरे लिए इसने दोनों तरह से काम किया, लेकिन एंड्रॉइड के डॉक्स पर आधारित onPrepareOptionsMenuइस प्रकार के ऑपरेशन को करने के लिए सही जगह की तरह लगता है: "स्क्रीन के मानक विकल्प मेनू को प्रदर्शित करने के लिए तैयार करें। मेनू दिखाए जाने से पहले इसे सही कहा जाता है, हर बार यह दिखाई देता है। । आप इस विधि का उपयोग कुशलता से / अक्षम वस्तुओं को निष्क्रिय करने के लिए या अन्यथा गतिशील रूप से सामग्री को संशोधित करने के लिए कर सकते हैं। "

— युवल

हां, यह आदर्श है। onPrepareOptionsMenu () का उपयोग onCreateOptionsMenu () के बजाय दिखाने / छिपाने के तर्क के लिए किया जाना चाहिए क्योंकि इसे केवल एक बार उपयोगी नहीं कहा जाता है यदि आप इसके प्रारंभ होने के बाद मेनू आइटम बदलना चाहते हैं। तो onCreate में फुलाएँ, लेकिन शो ऑन / प्रिंट onPrepare, फिर invalidateOptionsMenu()मेनू को ताज़ा करने के लिए उपयोग करें।

— JCutting8

Answer 7

प्रारंभ में मेनू आइटम दृश्यता को मेनू लेआउट फ़ाइल में झूठे रूप में सेट करें:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item
        android:visible="false"
        android:id="@+id/action_do_something"
        android:title="@string/txt_do_something"
        app:showAsAction="always|withText"
        android:icon="@drawable/ic_done"/>
</menu>

तब आप मेनू आइटम की दृश्यता सेट कर सकते हैं अपने मेनू में झूठी करने के लिए मेनू को फुलाए जाने के बाद।

@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    super.onCreateOptionsMenu(menu, inflater);
    inflater.inflate(menu,R.menu.menu);
    MenuItem item = menu.findItem(R.id.menuItemId);
    if (item != null){
        item.setVisible(false);
    }
}

Comments

onCreateOptionsMenu एक बूलियन मान वापस नहीं करता है। हालांकि समाधान पूरी तरह से काम किया।

— जोसेफ

Answer 8

इसे इस्तेमाल करे:

MenuItem myitem = menu.findItem(R.id.my_item);
myitem.setVisible(false);

Answer 9

इसने मेरे लिए एक्टिविटी और फ्रैगमेंट दोनों से काम किया

@Override
public void onPrepareOptionsMenu(Menu menu) {
    super.onPrepareOptionsMenu(menu);
    if (menu.findItem(R.id.action_messages) != null)
        menu.findItem(R.id.action_messages).setVisible(false);
}

Comments

मेरे मामले में onPrepareOptionsMenu बूलियन देता है, शून्य नहीं।

— कूलमाइंड

Answer 10

P1r4nh4 उत्तर ठीक काम करता है, मैंने बूलियन ध्वज का उपयोग करके इसे सरल बनाया:

public int mState = 0; //at the top of the code
//where you want to trigger the hide action
mState = 1; // to hide or mState = 0; to show
invalidateOptionsMenu(); // now onCreateOptionsMenu(...) is called again
...

@Override
public boolean onCreateOptionsMenu(Menu menu)
{
    // inflate menu from xml
    MenuInflater inflater = getSupportMenuInflater();
    inflater.inflate(R.menu.settings, menu);

    if (mState == 1) //1 is true, 0 is false
    {
        //hide only option 2
            menu.getItem(2).setVisible(false);
    }
}

Comments

उपयोग करना 0और 1"बूलियन ध्वज" नहीं है, यह छद्म बूलियन है। इसके अलावा, यहां एक वास्तविक बूलियन का उपयोग करने का कोई कारण नहीं है।

— इंगो बुर्क

इसके अलावा, आपके पास कई राज्य हो सकते हैं, न कि केवल एक छिपाने के लिए और एक दिखाने के लिए। आपके ऐप की जटिलता और नए ऐप के लिए नई गतिविधियों को लिखने से इनकार करने पर निर्भर करता है कि आपके पास SHOW_ALL राज्य, HIDE_ALL राज्य, लेकिन HIDE_EDIT या HIDE_SHARE स्थिति भी हो सकती है, जब आप अपने मेनू के कुछ भागों को छिपाना चाहते हैं।

— P1r4nh4

Answer 11

एंड्रॉइड डेवलपर आधिकारिक साइट के अनुसार, ऑनक्रीट ऑक्शनमेनू (मेनू मेनू) को मेनू आइटम या आइकन बदलने के लिए पुन: प्राप्त नहीं किया गया है, दृश्यता .. रनटाइम पर।

सिस्टम कॉल onCreateOptionsMenu () के बाद, यह आपके द्वारा पॉप्युलेट किए गए मेनू की आवृत्ति को बरकरार रखता है और onCreateOptionsMenu () को फिर से कॉल नहीं करेगा, जब तक कि मेनू किसी कारण से अमान्य न हो। हालाँकि, आपको केवल प्रारंभिक मेनू स्थिति बनाने और गतिविधि जीवनचक्र के दौरान परिवर्तन नहीं करने के लिए onCreateOptionsMenu () का उपयोग करना चाहिए।

यदि आप गतिविधि जीवन चक्र के दौरान होने वाली घटनाओं के आधार पर विकल्प मेनू को संशोधित करना चाहते हैं, तो आप onPrepareOptionsMenu () विधि में ऐसा कर सकते हैं। यह विधि आपको मेनू ऑब्जेक्ट पास करती है क्योंकि यह वर्तमान में मौजूद है इसलिए आप इसे संशोधित कर सकते हैं, जैसे कि आइटम जोड़ना, हटाना या अक्षम करना। (टुकड़े भी एक onPrepareOptionsMenu () कॉलबैक प्रदान करते हैं।) --AndroidDeveloper आधिकारिक साइट -

जैसा कि आप पुन: उपयोग कर सकते हैं, आप इस onOptionsItemSelected (MenuItem आइटम) विधि ट्रैक उपयोगकर्ता इनपुट का उपयोग कर सकते हैं ।

@Override
public boolean onOptionsItemSelected(MenuItem item) {

    int id = item.getItemId();

    if (id == R.id.edit) {
        Intent intent = new Intent(this, ExampleActivity.class);
        intent.putExtra(BUNDLE_KEY, mConnection);
        startActivityForResult(intent, PICK_CHANGE_REQUEST);
        return true;
    } else if (id == R.id.delete) {
        showDialog(this);
        return true;
    }

    return super.onOptionsItemSelected(item);
}

यदि आपको रन टाइम पर मेनू आइटम बदलने की आवश्यकता है, तो आप उन्हें बदलने के लिए onPrepareOptionsMenu (मेनू मेनू) का उपयोग कर सकते हैं

@Override
public boolean onPrepareOptionsMenu(Menu menu){

    if (Utils.checkNetworkStatus(ExampleActivity.this)) {
        menu.findItem(R.id.edit).setVisible(true);
        menu.findItem(R.id.delete).setVisible(true);
    }else {
        menu.findItem(R.id.edit).setVisible(false);
        menu.findItem(R.id.delete).setVisible(false);
    }
    return true;
} 

Comments

कुछ आइटम हमेशा दिखाई देते हैं, इसलिए जब मैं setVisible(false)हमेशा दिखाई देने वाली वस्तु के लिए होता हूं , तब तक यह गायब नहीं होता है जब तक कि मैं तीन डॉट्स (मेनू ही) पर क्लिक नहीं करता। अगर मैं का उपयोग invalidateOptionsMenu()में onPrepareOptionsMenuआइटम तुरंत ही पुनर्निर्माण, लेकिन वे अपने कार्यों ढीला (अगर मैं किसी भी आइटम पर क्लिक करें, यह कुछ भी नहीं है)।

— एलिटन ओलिवेरा

Answer 12

किसी वैरिएबल पर मान सेट करें और अमान्य कॉल करेंMenu ();

उदाहरण के लिए

    selectedid=arg2;
            invalidateOptionsMenu();


 public boolean onPrepareOptionsMenu(Menu menu) {

    if(selectedid==1){
        menu.findItem(R.id.action_setting).setVisible(false);
        menu.findItem(R.id.action_s2).setVisible(false);
        menu.findItem(R.id.action_s3).setVisible(false);
    }
    else{
        if(selectedid==2){
            menu.findItem(R.id.action_search).setVisible(false);
            menu.findItem(R.id.action_s4).setVisible(false);
            menu.findItem(R.id.action_s5).setVisible(false);
        }
    }
    return super.onPrepareOptionsMenu(menu);
}

Comments

कुछ आइटम हमेशा दिखाई देते हैं, इसलिए जब मैं setVisible(false)हमेशा दिखाई देने वाली वस्तु के लिए होता हूं , तब तक यह गायब नहीं होता है जब तक कि मैं तीन डॉट्स (मेनू ही) पर क्लिक नहीं करता। अगर मैं का उपयोग invalidateOptionsMenu()में onPrepareOptionsMenuआइटम तुरंत ही पुनर्निर्माण, लेकिन वे अपने कार्यों ढीला (अगर मैं किसी भी आइटम पर क्लिक करें, यह कुछ भी नहीं है)।

— एलिटन ओलिवेरा

Answer 13

आप toolbar.getMenu().clear();एक ही बार में सभी मेनू आइटम छिपाने के लिए उपयोग कर सकते हैं

Comments

@Ajeet_Yadav मेनू को स्पष्ट करने के बाद दिखाई देने का एक तरीका है?

— शॉन

Answer 14

मेनू में सभी मदों की दृश्यता सेट करके, ऐपबार मेनू या ओवरफ्लो मेनू स्वचालित रूप से छिपाया जाएगा

उदाहरण

private Menu menu_change_language;

...

...

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    ...
    ...
    menu_change_language = menu;
    menu_change_language.findItem(R.id.menu_change_language)
           .setVisible(true);

    return super.onCreateOptionsMenu(menu);
}

अन्य टुकड़ा उपयोग करने के लिए bellow कोड जाने से पहले:

if(menu_change_language != null){                 
    menu_change_language.findItem(R.id.menu_change_language)
       .setVisible(false);
}

Answer 15

https://stackoverflow.com/a/21215280/466363 - लुक अल्टरनेओ और सूफियान द्वारा उत्तर दिया गया

• ActivityCompat.invalidateOptionsMenu () पर कॉलबैक नहीं करता हैPrepareOptionsMenu (); यह सीधे मेनू को अपडेट करता है।
• मेरे someMethod () को कई जगहों से पुकारा जाता है, onCreateOptionsMenu () से पहले भी, इसलिए मुझे mMenu! = Null की जाँच करनी चाहिए।
• एपीआई 8 का उपयोग करके काम करना चाहिए

।

private Menu mMenu;
   @Override
   public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
       inflater.inflate(R.menu.track_fragment, menu);
       mMenu = menu;
       }
   ...
   private void someMethod() {
   ...
       if (mMenu != null) {
          MenuItem item = mMenu.findItem(R.id.new_track);
          if (item != null) {
               item.setVisible(false);
               ActivityCompat.invalidateOptionsMenu(this.getActivity());
           }
       }
   ...
   }

• ActivityCompat.invalidateOptionsMenu () पर कॉलबैक नहीं करता हैPrepareOptionsMenu (); यह सीधे मेनू को अपडेट करता है।

• मेरे someMethod () को कई जगहों से पुकारा जाता है, onCreateOptionsMenu () से पहले भी, इसलिए मुझे mMenu! = Null की जाँच करनी चाहिए।

• एपीआई 8 का उपयोग करके काम करना चाहिए

Answer 16

यदि आपने उपरोक्त उत्तर में सब कुछ किया है, लेकिन एक मेनू आइटम अभी भी दिखाई दे रहा है, तो जांचें कि आप अद्वितीय संसाधन का संदर्भ देते हैं । उदाहरण के लिए, onCreateOptionsMenu या onPrepareOptionsMenu पर

@Override
public void onPrepareOptionsMenu(Menu menu) {
    super.onPrepareOptionsMenu(menu);
    MenuItem menuOpen = menu.findItem(R.id.menu_open);
    menuOpen.setVisible(false);
}

Ctrl + R.id.menu_open पर क्लिक करें और जांचें कि यह केवल एक मेनू फ़ाइल में मौजूद है। मामले में जब यह संसाधन पहले से कहीं भी उपयोग किया जाता है और किसी गतिविधि में लोड किया जाता है, तो यह वहां छिपाने की कोशिश करेगा।

Answer 17

एक मेनू में सभी वस्तुओं को सिर्फ एक कमांड के साथ छिपाने का सबसे अच्छा तरीका अपने मेनू xml पर "समूह" का उपयोग करना है। बस सभी मेनू आइटम जोड़ें जो एक ही समूह के अंदर आपके अतिप्रवाह मेनू में होंगे।

इस उदाहरण में हमारे पास दो मेनू आइटम हैं जो हमेशा दिखाए जाएंगे (नियमित आइटम और खोज) और तीन अतिप्रवाह आइटम:

<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <item
        android:id="@+id/someItemNotToHide1"
        android:title="ITEM"
        app:showAsAction="always" />

    <item
        android:id="@+id/someItemNotToHide2"
        android:icon="@android:drawable/ic_menu_search"
        app:showAsAction="collapseActionView|ifRoom"
        app:actionViewClass="android.support.v7.widget.SearchView"
        android:title="Search"/>

    <group android:id="@+id/overFlowItemsToHide">
    <item android:id="@+id/someID" 
    android:orderInCategory="1" app:showAsAction="never" />
    <item android:id="@+id/someID2" 
    android:orderInCategory="1" app:showAsAction="never" />
    <item android:id="@+id/someID3" 
    android:orderInCategory="1" app:showAsAction="never" />
    </group>
</menu>

फिर, आपकी गतिविधि (onCreateOptionsMenu पर बेहतर) पर, सभी मेनू आइटम दृश्यता को गलत या सत्य पर सेट करने के लिए कमांड सेटग्रुपविविज़ का उपयोग करें।

public boolean onCreateOptionsMenu(Menu menu) {
   menu.setGroupVisible(R.id.overFlowItems, false); // Or true to be visible
}

यदि आप अपनी गतिविधि पर कहीं और इस आदेश का उपयोग करना चाहते हैं, तो मेनू क्लास को स्थानीय रूप से सहेजना सुनिश्चित करें, और हमेशा जांचें कि क्या मेनू शून्य है, क्योंकि आप createOuesMenu से पहले निष्पादित कर सकते हैं:

Menu menu;

public boolean onCreateOptionsMenu(Menu menu) {
       this.menu = menu;

}

public void hideMenus() {
       if (menu != null) menu.setGroupVisible(R.id.overFlowItems, false); // Or true to be visible       
}

Answer 18

Appcompat लाइब्रेरी का उपयोग करने वालों के लिए: यदि आपकी गतिविधि ActionBarActivity को उपवर्गित करती है, तो आप supportInvalidateOptionsMenu () को कॉल कर सकते हैं।

यहाँ देखें: https://stackoverflow.com/a/19649877/1562524

Answer 19

मुझे लगता है कि मेनू के लिए एक सदस्य चर का उपयोग करने के लिए एक बेहतर तरीका होगा, इसे onCreateOptionsMenu () में प्रारंभ करें और बस विकल्प मेनू को अमान्य किए बिना सेटविज़ुअल () का उपयोग करें।

Answer 20

इस कोड ने मेरे लिए काम किया

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.main_menu,menu);
    if (Application.sharedPreferences.getInt("type",1) == 2)
    {
        menuItem = menu.findItem(R.id.menu_travel_orders);
        menuItem.setVisible(false);
    }
    return super.onCreateOptionsMenu(menu);
}

Answer 21

इस दृष्टिकोण ने मेरे लिए काम किया:

private  Menu thismenu;

if (condition)
{
   if(thismenu != null)
   {
       thismenu.findItem(R.id.menu_save).setVisible(true);
       Toast.makeText(ProfileActivity.this, 
    ""+thismenu.findItem(R.id.menu_save).getTitle(),
                Toast.LENGTH_SHORT).show();
   }else
   {
       thismenu.findItem(R.id.menu_save).setVisible(false);
   }
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
   getMenuInflater().inflate(R.menu.profile_menu, menu);
   thismenu = menu;

   return true;
}

Answer 22

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

मेनू आइटम " नेविगेशन बार " जैसी वस्तुओं से जुड़े होते हैं, जो बदले में इसी गतिविधि के साथ बंधे होते हैं।

इसलिए गतिविधि में उन विचारों को आरंभ करें (), और फिर उस दृश्य के साथ मेनू आइटम तक पहुंचें।

Navigation navView;
navView = findViewById(R.id.navigationView);

MenuItem item = navView.getMenu().findItem(R.id.item_hosting);
item.setVisible(false);

Answer 23

उपयोग invalidateOptionsMenu()

कॉल करने के लिए onPrepareOptionsMenu(menu: Menu?)

आपको केवल प्रारंभिक मेनू स्थिति बनाने के लिए onCreateOptionsMenu () का उपयोग करना चाहिए और गतिविधि के दौरान परिवर्तन नहीं करना चाहिए ...

जब कोई घटना होती है और आप एक मेनू अपडेट करना चाहते हैं, तो आपको अमान्य कॉल करना होगा Menu () अनुरोध करने के लिए कि सिस्टम कॉल onPrepareOptionsMenu ()।

https://developer.android.com/guide/topics/ui/menus

Answer 24

एंड्रॉइड कोटलिन, प्रोग्राम बार में मेनू आइटम के छिपने या दृश्यता को निर्धारित करता है।

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    val inflater = menuInflater
    inflater.inflate(R.menu.main_menu, menu)
    val method = menu.findItem(R.id.menu_method)
    method.isVisible = false //if want to show set true
    return super.onCreateOptionsMenu(menu)
}