Wie blende ich einen Menüpunkt in der Aktionsleiste aus?

Zu dieser Frage einen Nachtrag gefunden:

Wenn Sie die Sichtbarkeit Ihrer Menüelemente unterwegs ändern möchten, müssen Sie lediglich eine Mitgliedsvariable in Ihrer Aktivität festlegen, um sich daran zu erinnern, dass Sie das Menü ausblenden und invalidateOptionsMenu() aufrufen und die Elemente in Ihrer überschriebenen onCreateOptionsMenu(...)-Methode ausblenden möchten.

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

In meinem Beispiel habe ich alle Elemente ausgeblendet.

Ja. 

1. Sie können eine Flagge/Bedingung setzen.
2. Rufen Sie invalidateOptionsMenu() auf, wenn Sie die Option ausblenden möchten. Dies wird onCreateOptionsMenu() aufrufen.
3. Suchen Sie in onCreateOptionsMenu() nach dem Flag/der Bedingung und zeigen Sie oder Verstecken Sie es folgendermaßen:

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

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

Sie können das anrufen:

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

Update:

Stellen Sie sicher, dass Ihr Code nicht null für item zurückgibt, da sonst die Anwendung abstürzt.

Ich suchte nach einer Antwort mit etwas mehr Kontext. Nun, da ich es herausgefunden habe, werde ich diese Antwort hinzufügen.

Schaltfläche standardmäßig in Menü xml ausblenden

Standardmäßig ist die Share-Schaltfläche ausgeblendet, wie von Android:visible="false" festgelegt.

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>

Schaltfläche im Code anzeigen

Die Share-Schaltfläche kann jedoch optional aufgrund bestimmter Bedingungen angezeigt werden.

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

Siehe auch

• Einrichten der App-Leiste (Android-Dokumente zur Unterstützung beim Einrichten der App/Aktionsleiste)

funktionierte nicht für mich Ich musste explizit onPrepareOptionsMenu verwenden, um ein Element unsichtbar zu machen.

Verwenden Sie also onCreateOptionsMenu zum Erstellen des Menüs und onPrepareOptionsMenu zum Ändern der Sichtbarkeit usw.

Dies funktionierte für mich sowohl von Activity als auch von Fragment

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

Setzen Sie die Sichtbarkeit des Menüelements in der Menü-Layoutdatei zunächst wie folgt auf "false":

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

Sie können dann einfach die Sichtbarkeit des Menüelements in onCreateOptionsMenu () auf false setzen, nachdem Sie das Menü aufgeblasen haben.

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

P1r4nh4 Antwort funktioniert gut, ich habe es einfach mit einer booleschen Flagge vereinfacht:

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

Mit toolbar.getMenu().clear(); können Sie alle Menüelemente auf einmal ausblenden 

setzen Sie einen Wert auf eine Variable und rufen Sie invalidateOptionsMenu () auf.

zum Beispiel

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

Laut offiziellen offiziellen Android-Entwickler-Websites wird OnCreateOptionMenu (Menümenü) nicht zum Ändern von Menüelementen oder Symbolen empfohlen, Sichtbarkeit usw. zur Laufzeit.

Nachdem das System onCreateOptionsMenu () aufgerufen hat, behält es eine Instanz des von Ihnen aufgefüllten Menüs bei und ruft onCreateOptionsMenu () nicht erneut auf, es sei denn, das Menü ist aus irgendeinem Grund ungültig. Sie sollten jedoch onCreateOptionsMenu () nur verwenden, um den ursprünglichen Menüzustand zu erstellen und keine Änderungen während des Aktivitätslebenszyklus vorzunehmen.

Wenn Sie das Optionsmenü basierend auf Ereignissen ändern möchten, die während des Aktivitätslebenszyklus auftreten, können Sie dies in der onPrepareOptionsMenu () - Methode tun. Diese Methode übergibt Ihnen das Menüobjekt, da es derzeit vorhanden ist, sodass Sie es ändern können, z. B. Elemente hinzufügen, entfernen oder deaktivieren. (Fragmente stellen auch einen onPrepareOptionsMenu () - Rückruf bereit.) --AndroidDeveloper Offizielle Seite -

Wie empfohlen Sie können diese onOptionsItemSelected (MenuItem-Element) -Methode verwenden, um Benutzereingaben zu verfolgen.

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

Wenn Sie Menüelemente zur Laufzeit ändern müssen, können Sie sie mit onPrepareOptionsMenu (Menü Menü) ändern

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

https://stackoverflow.com/a/21215280/466363 - beantwortet von Look Alterno und Sufian

• ActivityCompat.invalidateOptionsMenu () ruft nicht zurück OnPrepareOptionsMenu (); Aktualisieren Sie einfach das Menü direkt.
• Meine someMethod () wird von mehreren Stellen aufgerufen, sogar vor OnCreateOptionsMenu (), also muss ich mMenu! = Null überprüfen.
• sollte mit API 8 funktionieren

.

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 () ruft nicht zurück OnPrepareOptionsMenu (); Aktualisieren Sie einfach das Menü direkt.

• Meine someMethod () wird von mehreren Stellen aufgerufen, sogar vor OnCreateOptionsMenu (), also muss ich mMenu! = Null überprüfen.

• sollte mit API 8 funktionieren

Wenn Sie alles wie in den obigen Antworten gemacht haben, ein Menüelement jedoch immer noch sichtbar ist, überprüfen Sie, ob Sie auf die Ressource unique resource verweisen

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

Strg + Klicken Sie auf R.id.menu_open und prüfen Sie, ob es nur in einer Menüdatei vorhanden ist. Wenn diese Ressource bereits irgendwo verwendet und in eine Aktivität geladen wird, versucht sie, sich dort zu verstecken.

Wenn Sie die Sichtbarkeit aller Elemente im Menü einstellen, wird das Appbar-Menü oder das Überlaufmenü automatisch ausgeblendet

Beispiel

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

Bevor Sie zu einem anderen Fragment gehen, verwenden Sie den folgenden Code:

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

dieser Code hat für mich funktioniert

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

Ich denke, ein besserer Ansatz wäre, eine Membervariable für das Menü zu verwenden, sie in onCreateOptionsMenu () zu initialisieren und anschließend setVisible () zu verwenden, ohne das Optionsmenü zu entwerten.

Für diejenigen, die die Appcompat-Bibliothek verwenden: Wenn Ihre Activity-Unterklassen ActionBarActivity umfassen, können Sie supportInvalidateOptionsMenu () aufrufen.

Hier zu sehen: https://stackoverflow.com/a/19649877/1562524

Die beste Möglichkeit, alle Elemente in einem Menü mit einem einzigen Befehl auszublenden, ist die Verwendung von "Gruppe" in der Menü-XML. Fügen Sie einfach alle Menüelemente hinzu, die sich in Ihrem Überlaufmenü in derselben Gruppe befinden.

In diesem Beispiel haben wir zwei Menüelemente, die immer angezeigt werden (reguläre Elemente und Suche) und drei Überlaufelemente:

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

Verwenden Sie dann für Ihre Aktivität (vorzugsweise bei onCreateOptionsMenu) den Befehl setGroupVisible, um die Sichtbarkeit aller Menüelemente auf "false" oder "true" festzulegen.

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

Wenn Sie diesen Befehl an einer anderen Stelle in Ihrer Aktivität verwenden möchten, müssen Sie die Menüklasse in local speichern und immer überprüfen, ob das Menü null ist, da Sie es vor createOptionsMenu ausführen können:

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       
}

Dieser Ansatz hat für mich funktioniert:

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

Sie versuchen, über eine Aktivität auf einen Menüeintrag zuzugreifen, der keinen Zugriff auf den Bereich hat. Der Aufruf zum Suchen des Menüelements gibt null zurück, da die Ansicht nicht an weder die Aktivität noch das Layout gebunden ist, von dem aus Sie anrufen.

Die Menüelemente sind mit Elementen wie " Navigationsleiste " verknüpft, die wiederum mit der entsprechenden Aktivität verknüpft sind.

Initialisieren Sie also diese Ansichten in activity () und greifen Sie dann auf die Menüelemente mit diesen Ansichten zu.

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

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

Versuche dies:

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

benutze invalidateOptionsMenu()

um onPrepareOptionsMenu(menu: Menu?) aufzurufen

sie sollten onCreateOptionsMenu () nur verwenden, um den anfänglichen Menüstatus zu erstellen und keine Änderungen während des Aktivitätslebenszyklus vorzunehmen.

Wenn ein Ereignis eintritt und Sie eine Menüaktualisierung durchführen möchten, müssen Sie invalidateOptionsMenu () aufrufen, um den Systemaufruf onPrepareOptionsMenu () anzufordern.

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