Mam pasek akcji z menuitem. Jak mogę ukryć / pokazać ten element menu?

Oto co próbuję zrobić:

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

Uzyskaj MenuItemwskazanie na taki element, przywołaj setVisiblego, aby dostosować jego widoczność, a następnie przywołaj invalidateOptionsMenu()swoją aktywność, aby odpowiednio dostosować menu ActionBar.

Aktualizacja: A MenuItemnie jest zwykłym widokiem, który jest częścią twojego układu. To coś wyjątkowego, zupełnie innego. Twój kod wraca nulldo item, co powoduje awarię. Zamiast tego musisz zrobić:

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

Oto sekwencja, w której powinieneś zadzwonić: najpierw zadzwoń, invalidateOptionsMenu()a następnie w środku onCreateOptionsMenu(Menu)uzyskaj odwołanie do MenuItem (dzwoniąc menu.findItem()) i zadzwoń setVisible()do niego

Znaleziono uzupełnienie do tego pytania:

Jeśli chcesz zmienić widoczność elementów menu w podróży, wystarczy ustawić zmienną członka w swojej aktywności, aby pamiętać, że chcesz ukryć menu i wywołać invalidateOptionsMenu()i ukryć elementy w przesłoniętej onCreateOptionsMenu(...)metodzie.

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

W moim przykładzie ukryłem wszystkie przedmioty.

Tak.

1. Możesz ustawić flagę / warunek.
2. Zadzwoń, invalidateOptionsMenu()gdy chcesz ukryć opcję. To zadzwonionCreateOptionsMenu() .
3. W onCreateOptionsMenu()sprawdź flagę / warunek i pokaż lub ukryj ją w następujący sposób:

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

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

Możesz to nazwać:

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

Aktualizacja:

Upewnij się, że kod nie zwraca nullna itemlub może ulec awarii aplikacji.

Szukałem odpowiedzi w nieco szerszym kontekście. Teraz, gdy to rozgryzłem, dodam tę odpowiedź.

Ukryj przycisk domyślnie w menu xml

Domyślnie przycisk udostępniania będzie ukryty, zgodnie z ustawieniem 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>

Pokaż przycisk w kodzie

Ale przycisk udostępniania można opcjonalnie wyświetlić w zależności od pewnych warunków.

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

Zobacz też

• Konfigurowanie paska aplikacji (dokumenty systemu Android dotyczące pomocy przy konfigurowaniu paska aplikacji / działania)

nie działało dla mnie. Musiałem wyraźnie użyć, onPrepareOptionsMenuaby ustawić element niewidoczny.

Więc użyj, onCreateOptionsMenuaby utworzyć menu i onPrepareOptionsMenuzmienić widoczność itp.

Początkowo ustaw wartość widoczności elementu menu na wartość false w pliku układu menu w następujący sposób:

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

Następnie możesz po prostu ustawić widoczność elementu menu na wartość false w funkcji onCreateOptionsMenu () po napompowaniu 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);
    }
}

Spróbuj tego:

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

To działało dla mnie zarówno z Aktywności, jak i Fragmentu

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

Odpowiedź P1r4nh4 działa dobrze, właśnie ją uprościłem, używając flagi boolean:

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

Według oficjalnej strony Android Developer, OnCreateOptionMenu (menu Menu) nie jest zalecane do zmiany pozycji menu lub ikon, widoczności .. itp. W Runtime.

Po wywołaniu funkcji onCreateOptionsMenu () system zachowuje wystąpienie menu, które wypełniasz, i nie będzie ponownie wywoływał funkcji onCreateOptionsMenu (), chyba że menu zostanie z jakiegoś powodu unieważnione. Jednak należy użyć funkcji onCreateOptionsMenu () tylko do utworzenia początkowego stanu menu i nie wprowadzania zmian podczas cyklu życia działania.

Jeśli chcesz zmodyfikować menu opcji w oparciu o zdarzenia występujące podczas cyklu życia aktywności, możesz to zrobić w metodzie onPrepareOptionsMenu (). Ta metoda przekazuje ci obiekt Menu w takiej postaci, w jakiej aktualnie istnieje, abyś mógł go zmodyfikować, na przykład dodać, usunąć lub wyłączyć elementy. (Fragmenty zapewniają również wywołanie zwrotne onPrepareOptionsMenu ().) - Oficjalna strona AndroidDeveloper -

Zgodnie z zaleceniami Możesz użyć tej metody onOptionsItemSelected (pozycja MenuItem) do śledzenia danych wejściowych użytkownika.

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

Jeśli chcesz zmienić pozycje menu w czasie wykonywania, możesz użyć onPrepareOptionsMenu (menu Menu), aby je zmienić

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

ustaw wartość zmiennej i wywołaj invalidateOptionsMenu ();

na przykład

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

Możesz użyć, toolbar.getMenu().clear();aby ukryć wszystkie elementy menu jednocześnie

Po ustawieniu Widoczności wszystkich elementów w Menu, menu paska aplikacji lub menu przepełnienia będzie Ukrywać się automatycznie

Przykład

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

Przed przejściem do innego fragmentu użyj poniższego kodu:

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

https://stackoverflow.com/a/21215280/466363 - odpowiedzi: Look Alterno i Sufian

• ActivityCompat.invalidateOptionsMenu () nie wywołuje wywołania zwrotnego onPrepareOptionsMenu (); po prostu aktualizuje menu bezpośrednio.
• Moja someMethod () jest wywoływana z kilku miejsc, nawet przed onCreateOptionsMenu (), więc muszę sprawdzić mMenu! = Null.
• powinien działać przy użyciu API 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 () nie wywołuje wywołania zwrotnego onPrepareOptionsMenu (); po prostu aktualizuje menu bezpośrednio.

• Moja someMethod () jest wywoływana z kilku miejsc, nawet przed onCreateOptionsMenu (), więc muszę sprawdzić mMenu! = Null.

• powinien działać przy użyciu API 8

Jeśli zrobiłeś wszystko jak w powyższych odpowiedziach, ale element menu jest nadal widoczny, sprawdź, czy odwołujesz się do unikalnego zasobu. Na przykład w onCreateOptionsMenu lub onPrepareOptionsMenu

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

Ctrl + kliknij R.id.menu_open i sprawdź, czy istnieje tylko w jednym pliku menu. W przypadku, gdy ten zasób jest już gdziekolwiek używany i załadowany w działaniu, spróbuje się tam ukryć.

Najlepszym sposobem na ukrycie wszystkich pozycji w menu za pomocą jednego polecenia jest użycie „grupy” w menu xml. Po prostu dodaj wszystkie elementy menu, które będą w twoim menu przepełnienia w tej samej grupie.

W tym przykładzie mamy dwa elementy menu, które zawsze będą wyświetlane (zwykły element i wyszukiwanie) oraz trzy elementy przepełnienia:

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

Następnie, w swojej aktywności (najlepiej w onCreateOptionsMenu), użyj polecenia setGroupVisible, aby ustawić widoczność wszystkich pozycji menu na false lub true.

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

Jeśli chcesz użyć tego polecenia w innym miejscu swojej aktywności, pamiętaj, aby zapisać klasę menu w lokalnym i zawsze sprawdź, czy menu jest puste, ponieważ możesz wykonać przed createOptionsMenu:

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       
}

Dla osób korzystających z biblioteki Appcompat: Jeśli Twoje działanie podklasuje ActionBarActivity, możesz wywołać supportInvalidateOptionsMenu ()

Tutaj: https://stackoverflow.com/a/19649877/1562524

Myślę, że lepszym rozwiązaniem byłoby użycie zmiennej członka dla menu, zainicjowanie jej w onCreateOptionsMenu (), a następnie użycie setVisible () później, bez unieważniania menu opcji.

ten kod działał dla mnie

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

To podejście zadziałało dla mnie:

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

Próbujesz uzyskać dostęp do elementu menu z działania, które nie ma dostępu do zakresu. Wywołanie znalezienia elementu menu zwróci null , ponieważ widok nie jest powiązany ani z działaniem, ani z układem którego dzwonisz.

Elementy menu są powiązane z elementami takimi jak „ Pasek nawigacji ”, które z kolei są powiązane z odpowiednią aktywnością.

Więc zainicjuj te widoki w activity (), a następnie uzyskaj dostęp do elementów menu za pomocą tych widoków.

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

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

posługiwać się invalidateOptionsMenu()

aby zadzwonić onPrepareOptionsMenu(menu: Menu?)

powinieneś używać onCreateOptionsMenu () tylko do utworzenia początkowego stanu menu i nie wprowadzać zmian podczas cyklu życia aktywności ...

Gdy wystąpi zdarzenie i chcesz przeprowadzić aktualizację menu, musisz wywołać invalidateOptionsMenu (), aby zażądać wywołania systemowego onPrepareOptionsMenu ().

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

Android kotlin, ukryj lub ustaw programowo widoczność pozycji menu na pasku akcji.

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