Eu tenho uma barra de ação com um menu. Como posso ocultar / mostrar esse item de menu?

Isto é o que estou tentando fazer:

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

Obter um MenuItemapontador para tal item, chamada setVisiblenele para ajustar a sua visibilidade e, em seguida, chamar invalidateOptionsMenu()em sua atividade para que o menu ActionBar é ajustado em conformidade.

Atualização: A MenuItemnão é uma visualização regular que faz parte do seu layout. É algo especial, completamente diferente. Seus retornos de código nullpara iteme que está causando o acidente. O que você precisa é fazer:

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

Aqui está a sequência na qual você deve chamar: primeira chamada invalidateOptionsMenu()e depois onCreateOptionsMenu(Menu)obter uma referência ao MenuItem (chamando menu.findItem()) e chamar setVisible()por ele

Encontrou um adendo para esta pergunta:

Se você quiser alterar a visibilidade de seus itens de menu em qualquer lugar, basta definir uma variável de membro em sua atividade para lembrar que deseja ocultar o menu e chamar invalidateOptionsMenu()e ocultar os itens no seu onCreateOptionsMenu(...)método substituído .

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

No meu exemplo, eu escondi todos os itens.

Sim.

1. Você pode definir uma bandeira / condição.
2. Ligue invalidateOptionsMenu()quando quiser ocultar a opção. Isso vai ligar onCreateOptionsMenu().
3. Em onCreateOptionsMenu(), verifique a bandeira / condição e mostre ou oculte-a da seguinte maneira:

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

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

Você pode chamar isso:

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

Atualizar:

Verifique se o seu código não retorna nullpara itemou pode travar o aplicativo.

Eu estava procurando uma resposta com um pouco mais de contexto. Agora que eu descobri, vou adicionar essa resposta.

Botão Ocultar por padrão no menu xml

Por padrão, o botão de compartilhamento ficará oculto, conforme definido por 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>

Mostrar botão no código

Mas o botão de compartilhamento pode opcionalmente ser mostrado com base em alguma condição.

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

Veja também

• Configuração da barra de aplicativos (documentos do Android para obter ajuda na configuração da barra de aplicativos / ações)

não funcionou para mim. Eu tive que usar explicitamente onPrepareOptionsMenupara definir um item invisível.

Portanto, use onCreateOptionsMenupara criar o menu e onPrepareOptionsMenualterar a visibilidade, etc.

Inicialmente, defina a visibilidade do item de menu como false no arquivo de layout do menu, da seguinte maneira:

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

Você pode simplesmente definir a visibilidade do item de menu como false no seu onCreateOptionsMenu () depois de aumentar o 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);
    }
}

Tente o seguinte:

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

Isso funcionou para mim tanto na Atividade quanto no Fragmento

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

A resposta P1r4nh4 funciona bem, apenas a simplifiquei usando um sinalizador booleano:

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

De acordo com o site oficial do desenvolvedor Android, o OnCreateOptionMenu (menu Menu) não é recomendado para alterar itens ou ícones de menu, visibilidade .. etc no Runtime.

Depois que o sistema chama onCreateOptionsMenu (), ele retém uma instância do Menu que você preenche e não chama o OnCreateOptionsMenu () novamente, a menos que o menu seja invalidado por algum motivo. No entanto, você deve usar onCreateOptionsMenu () apenas para criar o estado inicial do menu e não fazer alterações durante o ciclo de vida da atividade.

Se você deseja modificar o menu de opções com base nos eventos que ocorrem durante o ciclo de vida da atividade, é possível fazê-lo no método onPrepareOptionsMenu (). Esse método passa o objeto Menu como ele existe atualmente para que você possa modificá-lo, como adicionar, remover ou desativar itens. (Os fragmentos também fornecem um retorno de chamada onPrepareOptionsMenu ().) --Site oficial do AndroidDeveloper -

Como recomendado Você pode usar este método onOptionsItemSelected (Item do MenuItem) para rastrear as entradas do usuário.

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

Se você precisar alterar os itens de menu no tempo de execução, use o menuPrepareOptions (menu Menu) para alterá-los

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

defina um valor para uma variável e chame invalidateOptionsMenu ();

por exemplo

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

Você pode usar toolbar.getMenu().clear();para ocultar todos os itens de menu de uma só vez

Ao definir a visibilidade de todos os itens no Menu, o menu da barra de aplicativos ou o menu excedente será Ocultar automaticamente

Exemplo

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

Antes de ir para outro fragmento, use o código abaixo:

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

https://stackoverflow.com/a/21215280/466363 - respondido por Look Alterno e Sufian

• ActivityCompat.invalidateOptionsMenu () não retorna callPrepareOptionsMenu (); basta atualizar o menu diretamente.
• Meu someMethod () é chamado de vários lugares, mesmo antes de onCreateOptionsMenu (), então devo verificar mMenu! = Null.
• deve funcionar usando a 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 () não retorna callPrepareOptionsMenu (); basta atualizar o menu diretamente.

• Meu someMethod () é chamado de vários lugares, mesmo antes de onCreateOptionsMenu (), então devo verificar mMenu! = Null.

• deve funcionar usando a API 8

Se você fez tudo como nas respostas acima, mas um item de menu ainda está visível, verifique se você faz referência ao recurso exclusivo . Por exemplo, em onCreateOptionsMenu ou onPrepareOptionsMenu

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

Ctrl + Clique em R.id.menu_open e verifique se ele existe apenas em um arquivo de menu. Caso esse recurso já esteja sendo usado em qualquer lugar e carregado em uma atividade, ele tentará se esconder lá.

A melhor maneira de ocultar todos os itens em um menu com apenas um comando é usar "group" em seu menu xml. Basta adicionar todos os itens de menu que estarão no seu menu excedente dentro do mesmo grupo.

Neste exemplo, temos dois itens de menu que sempre serão exibidos (item regular e pesquisa) e três itens de estouro:

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

Em sua atividade (de preferência em onCreateOptionsMenu), use o comando setGroupVisible para definir a visibilidade de todos os itens de menu como false ou true.

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

Se você deseja usar este comando em qualquer outro lugar da sua atividade, salve a classe de menu em local e sempre verifique se o menu é nulo, pois você pode executar antes de 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       
}

Para aqueles que usam a biblioteca Appcompat: Se sua Atividade incluir subclasses ActionBarActivity, você poderá chamar supportInvalidateOptionsMenu ()

Visto aqui: https://stackoverflow.com/a/19649877/1562524

Eu acho que uma abordagem melhor seria usar uma variável de membro para o menu, inicializá-la em onCreateOptionsMenu () e usar setVisible () depois, sem invalidar o menu de opções.

esse código funcionou para mim

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

Essa abordagem funcionou para mim:

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

Você está tentando acessar um item de menu de uma atividade que não tem acesso ao escopo. A chamada para localizar o item de menu retornará nulo , porque a visualização não está vinculada nem à atividade nem ao layout você está chamando.

Os itens de menu são vinculados a itens como " Barra de Navegação ", que por sua vez são vinculados à atividade correspondente.

Portanto, inicialize essas visualizações em activity () e acesse os itens de menu dentro dessas visualizações.

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

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

usar invalidateOptionsMenu()

para ligar onPrepareOptionsMenu(menu: Menu?)

você deve usar onCreateOptionsMenu () apenas para criar o estado inicial do menu e não fazer alterações durante o ciclo de vida da atividade ...

Quando um evento ocorre e você deseja executar uma atualização de menu, você deve chamar invalidateOptionsMenu () para solicitar que o sistema chamePrepareOptionsMenu ().

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

Android kotlin, oculte ou defina a visibilidade de um item de menu na barra de ação programaticamente.

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