¿Cómo escondo un elemento del menú en la barra de acciones?

Tengo una barra de acción con un elemento de menú. ¿Cómo puedo ocultar / mostrar ese elemento del menú?

Esto es lo que trato de hacer:

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

Obtenga un elemento de setVisible que apunte a dicho elemento, llame a setVisible para ajustar su visibilidad y luego llame a invalidateOptionsMenu() en su actividad para que el menú de la barra de acciones se ajuste en consecuencia.

Actualización: Un MenuItem no es una vista normal que es parte de su diseño. Es algo especial, completamente diferente. Su código devuelve null para el item y eso está causando el locking. Lo que necesitas en cambio es hacer:

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

Aquí está la secuencia: first call invalidateOptionsMenu() y luego dentro onCreateOptionsMenu(Menu) obtener una referencia al MenuItem (llamando a menu.findItem() ) y llamar a setVisible() en él

Encontré una adición a esta pregunta:

Si desea cambiar la visibilidad de sus elementos de menú sobre la marcha, solo necesita establecer una variable miembro en su actividad para recordar que desea ocultar el menú y llamar a invalidateOptionsMenu() y ocultar los elementos en su reemplazado onCreateOptionsMenu(...) método.

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

En mi ejemplo, he ocultado todos los artículos.

Sí.

  1. Puede establecer un indicador / condición.
  2. Llame a invalidateOptionsMenu() cuando desee ocultar la opción. Esto llamará onCreateOptionsMenu() .
  3. En onCreateOptionsMenu() , verifica la bandera / condición y muéstrala u ocúltala de la siguiente manera:
 MenuItem item = menu.findItem(R.id.menu_Done); if (flag/condition)) { item.setVisible(false); } else { } 

Puedes llamar esto:

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

Actualizar:

Asegúrese de que su código no devuelve null para el item o puede bloquear la aplicación.

Estaba buscando una respuesta con un poco más de contexto. Ahora que lo he descubierto, agregaré esa respuesta.

Ocultar el botón por defecto en el menú xml

Por defecto, el botón compartir estará oculto, tal como lo establece android:visible="false" .

enter image description here

main_menu.xml

 < ?xml version="1.0" encoding="utf-8"?>      

Mostrar el botón en el código

Pero el botón Compartir puede opcionalmente mostrarse en función de alguna condición.

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

Ver también

  • Configuración de la barra de aplicaciones (documentos de Android para obtener ayuda para configurar la aplicación / barra de acciones)

no funcionó para mí Tuve que usar explícitamente onPrepareOptionsMenu para establecer un elemento invisible.

Así que use onCreateOptionsMenu para crear el menú y onPrepareOptionsMenu para cambiar la visibilidad, etc.

Esto funcionó para mí tanto de Actividad como de 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); } 

Inicialmente establezca la visibilidad del elemento de menú en falso en el archivo de diseño del menú de la siguiente manera:

 < ?xml version="1.0" encoding="utf-8"?>    

A continuación, puede configurar la visibilidad del elemento de menú en falso en su onCreateOptionsMenu () después de inflar el menú.

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

La respuesta P1r4nh4 funciona bien, simplemente la simplifiqué usando una bandera booleana:

 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 acuerdo con el sitio oficial de Android Developer, OnCreateOptionMenu (Menú menú) no es recomendado para cambiar elementos de menú o icons, visibility..etc en Runtime.

Después de que el sistema invoque a CreateOptionsMenu (), conservará una instancia del Menú que llena y no volverá a llamar a CrearOpcionesMenú () a menos que el menú se invalide por algún motivo. Sin embargo, debe usar onCreateOptionsMenu () solo para crear el estado inicial del menú y no para realizar cambios durante el ciclo de vida de la actividad.

Si desea modificar el menú de opciones en función de los eventos que ocurren durante el ciclo de vida de la actividad, puede hacerlo en el método onPrepareOptionsMenu (). Este método le transfiere el objeto de menú tal como existe actualmente para que pueda modificarlo, como agregar, quitar o deshabilitar elementos. (Los fragmentos también proporcionan una callback onPrepareOptionsMenu ().) – Sitio oficial de DearoidDeveloper –

Como recomendado, puede utilizar este método onOptionsItemSelected (elemento MenuItem) para rastrear las entradas del usuario.

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

Si necesita cambiar elementos de menú en tiempo de ejecución, puede usar onPrepareOptionsMenu (menú de menú) para cambiarlos

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

establecer un valor a una variable y llamar a invalidateOptionsMenu ();

por ejemplo

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

https://stackoverflow.com/a/21215280/466363 – respondida por Look Alterno y Sufian

  • ActivityCompat.invalidateOptionsMenu () no realiza una callback enPrepareOptionsMenu (); simplemente actualiza el menú directamente.
  • Mi someMethod () se llama desde varios lugares, incluso antes de onCreateOptionsMenu (), así que debo marcar mMenu! = Null.
  • debería funcionar usando 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 () no realiza una callback enPrepareOptionsMenu (); simplemente actualiza el menú directamente.

  • Mi someMethod () se llama desde varios lugares, incluso antes de onCreateOptionsMenu (), así que debo marcar mMenu! = Null.

  • debería funcionar usando API 8

Puede usar toolbar.getMenu().clear(); para ocultar todos los elementos del menú a la vez

Si hizo todo lo que se indica en las respuestas anteriores, pero un elemento del menú aún está visible, verifique que hace referencia al recurso único . Por ejemplo, en onCreateOptionsMenu o onPrepareOptionsMenu

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

Ctrl + clic en R.menú_abierto y compruebe que existe solo en un archivo de menú. En caso de que este recurso ya se use en cualquier lugar y se cargue en una actividad, intentará esconderse allí.

este código funcionó para mí

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

Para aquellos que usan la biblioteca de Appcompat: si su actividad subclasifica ActionBarActivity, puede llamar a supportInvalidateOptionsMenu ()

Visto aquí: https://stackoverflow.com/a/19649877/1562524

Creo que un mejor enfoque sería usar una variable miembro para el menú, inicializarla enCreateOptionsMenu () y simplemente usar setVisible () después, sin invalidar el menú de opciones.

La mejor manera de ocultar todos los elementos en un menú con solo un comando es usar “grupo” en el menú xml. Simplemente agregue todos los elementos del menú que estarán en su menú de desbordamiento dentro del mismo grupo.

En este ejemplo, tenemos dos elementos de menú que siempre se mostrarán (elemento normal y búsqueda) y tres elementos de desbordamiento:

          

Luego, en su actividad (preferiblemente en onCreateOptionsMenu), use el comando setGroupVisible para establecer la visibilidad de todos los elementos del menú en falso o verdadero.

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

Si desea utilizar este comando en cualquier otro lugar de su actividad, asegúrese de guardar la clase de menú en local, y siempre verifique si el menú es nulo, porque puede ejecutar 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 } 

Al configurar la Visibilidad de todos los elementos en el Menú, el menú de la barra de la aplicación o el menú de desbordamiento se Ocultarán automáticamente

Ejemplo

 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 a otro fragmento use el siguiente código:

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

Este enfoque funcionó para mí:

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