Wie verstecke ich einen Menüpunkt in der Aktionsleiste?

346

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();
Zoltán umrühren
quelle

Antworten:

484

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

K-Ballo
quelle
Dies ist, was ich anfangs gedacht habe, aber dies stürzt die Anwendung ab.
Rühren Sie Zoltán
3
@Stir Zoltán: Nun, so machen Sie es, Sie können es falsch machen, wenn die Anwendung abstürzt. Zum Beispiel MenuItemkann dies nulldaran liegen , dass Sie getItemanstelle von verwenden findItem. Wir könnten es nie erfahren, ohne sowohl Ihren Code als auch Ihr Absturzprotokoll zu sehen.
K-Ballo
OK, aber wie kann ich einen Verweis auf das Menü außerhalb der onCreateOptionsMenu-Methode erhalten?
Rühren Sie Zoltán
7
@Stir Zoltán: Ich glaube, Sie machen mit diesem letzten Kommentar keinen Sinn ... Holen Sie sich einfach einen Verweis auf Ihren Menüpunkt onCreateOptionsMenuunter und stellen Sie die Sichtbarkeit des Elements an diesem Punkt ein. Oder bewahren Sie die Referenz so lange auf, bis Sie entscheiden, ob sie sichtbar sein soll oder nicht.
K-Ballo
33
Ich denke, dass diese Antwort (bestenfalls) schlecht formuliert ist, weil die Reihenfolge der Schritte falsch ist. Die richtige Reihenfolge ist, zuerst anzurufen invalidateOptionsMenu()und dann im Inneren onCreateOptionsMenu(Menu)einen Verweis auf das MenuItem(durch Aufrufen menu.findItem()) zu erhalten und es aufzurufen setVisible(). Die Antworten von suhas_sm und von P1r4nh4 zeigen den richtigen Ansatz.
Ted Hopp
163

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.

P1r4nh4
quelle
2
Genau das habe ich gesucht. Das Festhalten am MenuItem und das Aufrufen von setVisible () schienen nicht das zu tun, was ich erwartet hatte (vielleicht weil ich danach invalidateOptionsMenu () aufgerufen und damit das Menü neu erstellt habe), aber so oder so - das funktioniert genau so, wie ich es mir erhofft hatte, danke!
Matt
4
Wenn Sie jeden Gegenstand verstecken möchten, gibt es einen einfacheren Weg. Anstatt jedes Element hier zu durchlaufen, können Sie einfach if (HIDE_MENU) { return false; } else { getSupportMenuInflater().inflate(R.menu.menu_settings, menu); return true; }Folgendes tun: In den Dokumenten heißt es: "Sie müssen true zurückgeben, damit das Menü angezeigt wird. Wenn Sie false zurückgeben, wird es nicht angezeigt."
w3bshark
Ich möchte auch erwähnen, dass dieser Ansatz viel sauberer ist als die akzeptierte Antwort. Danke für das Teilen!
w3bshark
durch Aufrufen von invalidateOptionMenu () wird onCreateOptionMenu () aufgerufen und ich behandle meine Bedingungen in onCreateOptionMenu (). Vielen Dank für die gute Antwort
user1912026
onPrepareOptionsMenu()sollte für die Ein- / Ausblendlogik verwendet werden, anstatt onCreateOptionsMenu()nur einmal aufgerufen zu werden. Dies ist daher nicht sinnvoll, wenn Sie die Menüelemente nach der Initialisierung ändern möchten. Also in onCreate aufblasen, aber in onPrepare ein- / ausblenden.
JCutting8
89

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 { }
suhas_sm
quelle
2
Sollte es nicht invalidateOptionsMenustatt sein invalidateOptions?
Razz
3
Wenn Sie Ihre Flagge zu einem Booleschen Wert machen, können Sie die Sichtbarkeit des Elements bei Bedarf einfach auf die Flagge (oder! -Flagge) setzen. Also item.setVisbility (! Flag); macht dies zu einem Einzeiler ohne Wenn-Bedingung.
jwehrle
Wo ist die Variable "Menü" definiert?
Jonathan
Es wird als Parameter anonCreateOptionsMenu
suhas_sm
Wenn Sie diese Methode verwenden, verbraucht das Element immer noch Platz und es kann zu einer "Lücke" in Ihrer Benutzeroberfläche kommen, in der sich die Schaltfläche befinden sollte. Die Verwendung von removeItem in onPrepareOptionsMenu () reicht aus.
JCutting8
39

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.

elias
quelle
Wenn Sie diese Methode verwenden, verbraucht das Element immer noch Platz und es kann zu einer "Lücke" in Ihrer Benutzeroberfläche kommen, in der sich die Schaltfläche befinden sollte. Die Verwendung von removeItem in onPrepareOptionsMenu () reicht aus.
JCutting8
33

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

Geben Sie hier die Bildbeschreibung ein

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.

Geben Sie hier die Bildbeschreibung ein

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

Suragch
quelle
onPrepareOptionsMenu () sollte anstelle von onCreateOptionsMenu () für die Ein- / Ausblendlogik verwendet werden, da es nur einmal aufgerufen wird. Dies ist daher nicht hilfreich, wenn Sie die Menüelemente nach der Initialisierung ändern möchten. Also in onCreate aufblasen, aber in onPrepare ein- / ausblenden und dann invalidateOptionsMenu()zum Aktualisieren des Menüs verwenden.
JCutting8
24

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.

hotzen
quelle
1
Für mich hat es in beide Richtungen funktioniert, aber basierend auf den Dokumenten von AndroidonPrepareOptionsMenu scheint dies der richtige Ort für diese Art von Operation zu sein: "Bereiten Sie das Standardoptionsmenü des Bildschirms für die Anzeige vor. Dies wird jedes Mal aufgerufen, bevor das Menü angezeigt wird Mit dieser Methode können Sie Elemente effizient aktivieren / deaktivieren oder den Inhalt auf andere Weise dynamisch ändern. "
Yuval
Ja, das ist ideal. onPrepareOptionsMenu () sollte anstelle von onCreateOptionsMenu () für die Ein- / Ausblendlogik verwendet werden, da es nur einmal aufgerufen wird. Dies ist daher nicht hilfreich, wenn Sie die Menüelemente nach der Initialisierung ändern möchten. Also in onCreate aufblasen, aber in onPrepare ein- / ausblenden und dann invalidateOptionsMenu()das Menü aktualisieren .
JCutting8
9

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);
    }
}
Akhila
quelle
onCreateOptionsMenu gibt keinen booleschen Wert zurück. Die Lösung funktionierte jedoch perfekt.
Joseph
8

Versuche dies:

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

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);
}
Bala Vishnu
quelle
1
In meinem Fall gibt onPrepareOptionsMenu boolean zurück, nicht void.
CoolMind
6

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);
    }
}
Hiram
quelle
2
Verwenden 0und 1ist kein "Boolesches Flag", sondern ein Pseudo-Boolesches. Außerdem gibt es hier keinen Grund, einen tatsächlichen Booleschen Wert zu verwenden.
Ingo Bürk
2
Sie können auch mehrere Zustände haben, nicht nur einen zum Ausblenden und einen zum Anzeigen. Abhängig von der Komplexität Ihrer App und Ihrer Weigerung, neue Aktivitäten für neue App-Status zu schreiben, haben Sie möglicherweise den Status SHOW_ALL, den Status HIDE_ALL, aber auch den Status HIDE_EDIT oder HIDE_SHARE, falls Sie bestimmte Teile Ihres Menüs ausblenden möchten.
P1r4nh4
4

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;
} 
Chanaka Fernando
quelle
Einige Elemente sind immer sichtbar. Wenn ich also setVisible(false)für das immer sichtbare Element bin, verschwindet es nicht, bis ich auf die drei Punkte klicke (Menü selbst). Wenn ich invalidateOptionsMenu()in onPrepareOptionsMenuden Elementen verwende, reorganisiere ich mich sofort, aber sie verlieren ihre Aktionen (wenn ich auf ein Element klicke, tut es nichts).
Aliton Oliveira
3

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);
}
Zacharia
quelle
Einige Elemente sind immer sichtbar. Wenn ich also setVisible(false)für das immer sichtbare Element bin, verschwindet es nicht, bis ich auf die drei Punkte klicke (Menü selbst). Wenn ich invalidateOptionsMenu()in onPrepareOptionsMenuden Elementen verwende, reorganisiere ich mich sofort, aber sie verlieren ihre Aktionen (wenn ich auf ein Element klicke, tut es nichts).
Aliton Oliveira
3

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

Ajeet Yadav
quelle
@Ajeet_Yadav Gibt es eine Möglichkeit, das Menü sichtbar zu machen, nachdem Sie es gelöscht haben?
Shawn
3

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

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

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.

CoolMind
quelle
2

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       
}
Adriano Moutinho
quelle
1

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

RuideraJ
quelle
1

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.

Catalin Clabescu
quelle
1

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);
}
Sai Gopi N.
quelle
1

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;
}
Wald Baba
quelle
1

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);
VeeyaaR
quelle
1

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

Dan Alboteanu
quelle
0

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)
}
Aftab Alam
quelle