Android: como ativar / desativar o item de menu de opções ao clicar no botão?

Eu posso fazer isso facilmente quando estou usando onCreateOptionsMenuou onOptionsItemSelectedmétodos.

Mas eu tenho um botão em algum lugar na tela e, ao clicar nesse botão, ele deve ativar / desativar os itens do menu de contexto.

De qualquer forma, a documentação cobre todas as coisas.

Alterando itens de menu em tempo de execução

Depois que a atividade é criada, o onCreateOptionsMenu()método é chamado apenas uma vez, conforme descrito acima. O sistema mantém e reutiliza o que Menuvocê define neste método até que sua atividade seja destruída. Se você deseja alterar o menu Opções a qualquer momento após a sua criação, você deve substituir o onPrepareOptionsMenu()método. Isso passa o objeto Menu como ele existe atualmente. Isso é útil se você deseja remover, adicionar, desativar ou ativar itens de menu, dependendo do estado atual do seu aplicativo.

Por exemplo

@Override
public boolean onPrepareOptionsMenu (Menu menu) {
    if (isFinalized) {
        menu.getItem(1).setEnabled(false);
        // You can also use something like:
        // menu.findItem(R.id.example_foobar).setEnabled(false);
    }
    return true;
}

No Android 3.0 e superior, o menu de opções é considerado sempre aberto quando os itens de menu são apresentados na barra de ação. Quando um evento ocorre e você deseja executar uma atualização de menu, você deve ligar invalidateOptionsMenu()para solicitar a chamada do sistema onPrepareOptionsMenu().

Em todas as versões do Android, a maneira mais fácil: use isso para MOSTRAR um ícone de ação do menu como desativado E torná-lo FUNCIONADO também como desativado:

@Override
public boolean onPrepareOptionsMenu(Menu menu) {

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

    if (myItemShouldBeEnabled) {
        item.setEnabled(true);
        item.getIcon().setAlpha(255);
    } else {
        // disabled
        item.setEnabled(false);
        item.getIcon().setAlpha(130);
    }
}

Você pode salvar o item como uma variável ao criar o menu de opções e, em seguida, alterar suas propriedades à vontade.

private MenuItem securedConnection;
private MenuItem insecuredConnection;

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.connect_menu, menu);
    securedConnection = menu.getItem(0);
    insecuredConnection =  menu.getItem(1);
    return true;
}

public void foo(){
       securedConnection.setEnabled(true);
}    

simplifique a versão @Vikas

@Override
public boolean onPrepareOptionsMenu (Menu menu) {

    menu.findItem(R.id.example_foobar).setEnabled(isFinalized);
    return true;
}

Como atualizar o menu atual para ativar ou desativar os itens quando um AsyncTask é concluído.

No meu caso de uso, eu precisava desativar meu menu enquanto o AsyncTask carregava dados; depois de carregar todos os dados, era necessário ativar todo o menu novamente para permitir que o usuário o usasse.

Isso impediu o aplicativo de permitir que os usuários clicassem nos itens de menu enquanto os dados estavam sendo carregados.

Primeiro, declaro uma variável de estado; se a variável for 0, o menu será exibido; se essa variável for 1, o menu estará oculto.

private mMenuState = 1; //I initialize it on 1 since I need all elements to be hidden when my activity starts loading.

Então, na minha onCreateOptionsMenu()verificação dessa variável, se for 1, desativo todos os meus itens; caso contrário, apenas mostro a todos

 @Override
    public boolean onCreateOptionsMenu(Menu menu) {

        getMenuInflater().inflate(R.menu.menu_galeria_pictos, menu);

        if(mMenuState==1){
            for (int i = 0; i < menu.size(); i++) {
                menu.getItem(i).setVisible(false);
            }
        }else{
             for (int i = 0; i < menu.size(); i++) {
                menu.getItem(i).setVisible(true);
            }
        }

        return super.onCreateOptionsMenu(menu);
    }

Agora, quando minha Atividade iniciar, onCreateOptionsMenu()será chamada apenas uma vez e todos os meus itens desaparecerão porque eu configurei o estado para eles no início.

Em seguida, crio um AsyncTask, onde defino essa variável de estado como 0 no meu onPostExecute()

Este passo é muito importante!

Quando você ligar invalidateOptionsMenu();, será reiniciadoonCreateOptionsMenu();

Então, depois de configurar meu estado como 0, apenas redesenhei todo o menu, mas desta vez com a variável 0, ou seja, todo o menu será exibido depois que todo o processo assíncrono estiver concluído, e então meu usuário poderá usar o menu .

 public class LoadMyGroups extends AsyncTask<Void, Void, Void> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            mMenuState = 1; //you can set here the state of the menu too if you dont want to initialize it at global declaration. 

        }

        @Override
        protected Void doInBackground(Void... voids) {
           //Background work

            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);

            mMenuState=0; //We change the state and relaunch onCreateOptionsMenu
            invalidateOptionsMenu(); //Relaunch onCreateOptionsMenu

        }
    }

Resultados

a melhor solução quando você executa na gaveta de navegação

@Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        menu.setGroupVisible(0,false);
        return true;
    }

Uma resposta mais moderna para uma pergunta antiga:

MainActivity.kt

private var myMenuIconEnabled by Delegates.observable(true) { _, old, new ->
    if (new != old) invalidateOptionsMenu()
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    findViewById<Button>(R.id.my_button).setOnClickListener { myMenuIconEnabled = false }
}

override fun onCreateOptionsMenu(menu: Menu?): Boolean {
    menuInflater.inflate(R.menu.menu_main_activity, menu)
    return super.onCreateOptionsMenu(menu)
}

override fun onPrepareOptionsMenu(menu: Menu): Boolean {
    menu.findItem(R.id.action_my_action).isEnabled = myMenuIconEnabled
    return super.onPrepareOptionsMenu(menu)
}

menu_main_activity.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">
<item
    android:id="@+id/action_my_action"
    android:icon="@drawable/ic_my_icon_24dp"
    app:iconTint="@drawable/menu_item_icon_selector"
    android:title="My title"
    app:showAsAction="always" />
</menu>

menu_item_icon_selector.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:color="?enabledMenuIconColor" android:state_enabled="true" />
<item android:color="?disabledMenuIconColor" />

attrs.xml

<resources>   
    <attr name="enabledMenuIconColor" format="reference|color"/>
    <attr name="disabledMenuIconColor" format="reference|color"/>
</resources>

styles.xml or themes.xml

<style name="AppTheme" parent="Theme.MaterialComponents.Light.NoActionBar">
    <!-- Customize your theme here. -->
    <item name="disabledMenuIconColor">@color/white_30_alpha</item>
    <item name="enabledMenuIconColor">@android:color/white</item>

  @Override
        public boolean onOptionsItemSelected(MenuItem item) {

            switch (item.getItemId()) {

                case R.id.item_id:

                       //Your Code....

                        item.setEnabled(false);
                        break;
              }
            return super.onOptionsItemSelected(item);
     }

O que fiz foi salvar uma referência ao Menu em onCreateOptionsMenu. Isso é semelhante à resposta de nir, exceto que, em vez de salvar cada item individual, salvei o menu inteiro.

Declare um menu Menu toolbarMenu;.

Em seguida, onCreateOptionsMenusalve o menu na sua variável

@Override
public boolean onCreateOptionsMenu(Menu menu)
{
    getMenuInflater().inflate(R.menu.main_menu, menu);
    toolbarMenu = menu;
    return true;
}

Agora você pode acessar seu menu e todos os itens a qualquer momento. toolbarMenu.getItem(0).setEnabled(false);

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    // getMenuInflater().inflate(R.menu.home, menu);
    return false;
}

Se menu visível

menu.findItem(R.id.id_name).setVisible(true);

Se ocultar menu

menu.findItem(R.id.id_name).setVisible(false);

Geralmente pode alterar as propriedades de suas visualizações em tempo de execução:

(Button) item = (Button) findViewById(R.id.idBut);

e depois...

item.setVisibility(false)

mas

se você deseja modificar a visibilidade das opções no menu de contexto, pressione o botão, você pode ativar um sinalizador e, em seguida, no menu Criar menu, você pode fazer algo assim:

 @Override
        public void onCreateContextMenu(ContextMenu menu, 
                View v,ContextMenu.ContextMenuInfo menuInfo) {

            super.onCreateContextMenu(menu, v, menuInfo);

                menu.setHeaderTitle(R.string.context_title);

                if (flagIsOn()) {
                    addMenuItem(menu, "Option available", true);
                } else {
                    Toast.makeText(this, "Option not available", 500).show();
                }

        }

Eu espero que isso ajude