wake-up-neo.com

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

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

Das versuche ich zu tun:

MenuItem item = (MenuItem) findViewById(R.id.addAction);
item.setVisible(false);
this.invalidateOptionsMenu();
291
Stir Zoltán

Rufen Sie eine MenuItem ab, die auf ein solches Element zeigt, rufen Sie setVisible auf, um die Sichtbarkeit anzupassen, und rufen Sie dann invalidateOptionsMenu() für Ihre Aktivität auf, damit das ActionBar-Menü entsprechend angepasst wird.

Update: Eine MenuItem ist keine reguläre Ansicht, die Teil Ihres Layouts ist. Es ist etwas Besonderes, ganz anders. Ihr Code gibt null für item zurück und führt zum Absturz. Was Sie stattdessen tun müssen, ist:

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

Hier ist die Reihenfolge, in der Sie aufrufen sollten: Rufen Sie zuerst invalidateOptionsMenu() auf und rufen Sie dann in onCreateOptionsMenu(Menu) eine Referenz auf das Menüelement (durch Aufruf von menu.findItem()) auf und rufen Sie setVisible() auf

428
K-ballo

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.

142
P1r4nh4

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 { }
77
suhas_sm

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.

36
elias

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.

 enter image description here

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.

 enter image description here

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

28
Suragch

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.

23
hotzen

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

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

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

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

3
Ajeet Yadav

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

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
2
Shimon Doodkin

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.

2
CoolMind

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);
}
2
Hantash Nadeem

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

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.

0

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

0
RuideraJ

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

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;
}
0
Forest baba

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);
0
VeeyaaR

Versuche dies:

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

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

0
Dan Alboteanu