Ich habe eine Aktionsleiste mit einem Menü. Wie kann ich diesen Menüpunkt ausblenden / einblenden?

Das versuche ich zu tun:

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

Holen Sie sich ein MenuItemZeige auf solche Artikel, rufen Sie setVisibleauf, ihre Sichtbarkeit zu justieren und rufen Sie dann invalidateOptionsMenu()auf Ihre Tätigkeit so das ActionBar Menü entsprechend angepasst wird.

Update: A MenuItemist keine reguläre Ansicht, die Teil Ihres Layouts ist. Es ist etwas Besonderes, ganz anders. Ihr Code kehrt nullfür zurück itemund das verursacht den Absturz. Was Sie stattdessen brauchen, ist zu tun:

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

Hier ist die Reihenfolge, in der Sie aufrufen sollten: Rufen Sie zuerst auf invalidateOptionsMenu()und erhalten Sie dann im Inneren onCreateOptionsMenu(Menu)einen Verweis auf das MenuItem (durch Aufrufen menu.findItem()) und rufen Sie setVisible()es auf

Einen Nachtrag zu dieser Frage 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ü invalidateOptionsMenu()ausblenden und die Elemente in Ihrer überschriebenen onCreateOptionsMenu(...)Methode aufrufen und 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 ein Flag / eine Bedingung setzen.
2. Rufen invalidateOptionsMenu()Sie an, wenn Sie die Option ausblenden möchten. Dies wird anrufen onCreateOptionsMenu().
3. In onCreateOptionsMenu(), Check für die Flagge / Zustand und zeigen oder verstecken sie die folgende Art und Weise:

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

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

Sie können dies nennen:

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

Aktualisieren:

Stellen Sie sicher, dass Ihr Code nicht nullfür zurückgegeben wird, itemda sonst die Anwendung abstürzen kann.

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

Schaltfläche im Menü XML standardmäßig ausblenden

Standardmäßig wird die Freigabeschaltfläche ausgeblendet, wie von festgelegt 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>

Schaltfläche im Code anzeigen

Die Schaltfläche "Teilen" kann jedoch optional unter bestimmten 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 für Hilfe beim Einrichten der App / Aktionsleiste)

hat bei mir nicht funktioniert. Ich musste explizit verwenden onPrepareOptionsMenu, um einen Gegenstand unsichtbar zu machen.

Verwenden Sie onCreateOptionsMenudiese Option, um das Menü zu erstellen und onPrepareOptionsMenudie Sichtbarkeit usw. zu ändern.

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

Versuche dies:

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

Dies funktionierte sowohl für Activity als auch für 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);
}

P1r4nh4 Antwort funktioniert gut, ich habe es nur mit einem booleschen Flag 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);
    }
}

Laut der offiziellen Website von Android Developer wird OnCreateOptionMenu (Menü Menü) nicht zum Ändern von Menüelementen oder Symbolen, Sichtbarkeit usw. zur Laufzeit empfohlen.

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 onCreateOptionsMenu () jedoch nur verwenden, um den anfänglichen Menüstatus 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 Methode onPrepareOptionsMenu () tun. Diese Methode übergibt Ihnen das Menüobjekt, wie es derzeit vorhanden ist, damit Sie es ändern können, z. B. Elemente hinzufügen, entfernen oder deaktivieren. (Fragmente bieten auch einen onPrepareOptionsMenu () - Rückruf.) --AndroidDeveloper Official Site -

Wie empfohlen Sie können dies verwenden onOptionsItemSelected- Methode (MenuItem-Element) 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;
} 

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

Sie können toolbar.getMenu().clear();damit alle Menüelemente gleichzeitig ausblenden

Durch Einstellen der Sichtbarkeit aller Elemente im Menü 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 wechseln, verwenden Sie den folgenden Code:

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

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

• ActivityCompat.invalidateOptionsMenu () ruft onPrepareOptionsMenu () nicht zurück; es aktualisiert einfach das Menü direkt.
• Meine someMethod () wird von mehreren Stellen aufgerufen, sogar vor onCreateOptionsMenu (), daher 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 onPrepareOptionsMenu () nicht zurück; es aktualisiert einfach das Menü direkt.

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

• sollte mit API 8 funktionieren

Wenn Sie alles wie in den obigen Antworten ausgeführt haben, aber ein Menüelement weiterhin sichtbar ist, überprüfen Sie, ob Sie auf die eindeutige Ressource verweisen . Zum Beispiel in onCreateOptionsMenu oder onPrepareOptionsMenu

@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 überprüfen Sie, ob es nur in einer Menüdatei vorhanden ist. Falls diese Ressource bereits irgendwo verwendet und in eine Aktivität geladen wird, wird versucht, sie dort auszublenden.

Der beste Weg, um alle Elemente in einem Menü mit nur einem Befehl auszublenden, ist die Verwendung von "group" in Ihrer Menü-XML. Fügen Sie einfach alle Menüelemente, die sich in Ihrem Überlaufmenü befinden, innerhalb derselben Gruppe hinzu.

In diesem Beispiel haben wir zwei Menüelemente, die immer angezeigt werden (reguläres Element 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 zu setzen.

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

Für Benutzer der Appcompat-Bibliothek: Wenn Ihre Aktivität ActionBarActivity untergeordnet ist, können Sie supportInvalidateOptionsMenu () aufrufen.

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

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

Dieser Code hat bei mir 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);
}

Dieser Ansatz hat bei mir 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, die keinen Zugriff auf den Bereich hat, auf einen Menüpunkt zuzugreifen. Der Aufruf zum Suchen des Menüelements gibt null zurück , da die Ansicht weder an die Aktivität noch an das Layout gebunden ist ist, von Sie anrufen.

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

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

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

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

verwenden invalidateOptionsMenu()

um anzurufen onPrepareOptionsMenu(menu: Menu?)

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

Android kotlin, blendet oder setzt die Sichtbarkeit eines Menüelements in der Aktionsleiste programmgesteuert.

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