android - poner - ¿Cómo oculto un elemento de menú en la barra de acción?

menu toolbar android

Question

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

Esto es lo que estoy tratando de hacer:

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

Answer 1

Al configurar la Visibilidad de todos los elementos en el Menú, el menú de la barra de aplicaciones o el menú de desbordamiento se ocultará 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);
}

Answer 2

Creo que un mejor enfoque sería utilizar una variable miembro para el menú, inicializarlo en onCreateOptionsMenu () y luego usar setVisible () después, sin invalidar el menú de opciones.

Answer 3

Encontré un apéndice 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 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.

Answer 4

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

Ocultar botón por defecto en el menú xml

Por defecto, el botón de compartir estará oculto, según lo establecido 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ón en el código

Pero el botón de compartir se puede mostrar opcionalmente en función de alguna condición.

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 barra de acción / aplicación)

Answer 5

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

Answer 6

Esto me funcionó tanto de la actividad como del 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);
}

Answer 7

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

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

Luego, simplemente puede configurar la visibilidad del elemento de menú en falso en suCrearOpcionesMenú () 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);
    }
}

Answer 8

La mejor manera de ocultar todos los elementos en un menú con un solo comando es usar "grupo" en su menú xml. Solo 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:

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

Luego, en su actividad (preferible en onCreateOptionsMenu), use el comando setGroupVisible para configurar la visibilidad de todos los elementos del menú como falsa o verdadera.

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

Si desea usar este comando en cualquier otra parte 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       
}

Answer 9

La respuesta de P1r4nh4 funciona bien, simplemente la simplifiqué utilizando 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);
    }
}

Answer 10

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 acción se ajuste en consecuencia.

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

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

Aquí está la secuencia en la que debe llamar: primero llame a invalidateOptionsMenu() y luego dentro de onCreateOptionsMenu(Menu) obtenga una referencia al MenuItem (llamando a menu.findItem() ) y llame a setVisible()

Answer 11

Para aquellos que usan la biblioteca Appcompat: Si sus subclases de actividad ActionBarActivity, puede llamar a supportInvalidateOptionsMenu ()

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

Answer 12

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

Answer 13

Puedes llamar a esto:

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

Actualizar:

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

Answer 14

Sí.

1. Puede establecer una bandera / condición.
2. Llame a invalidateOptionsMenu() cuando desee ocultar la opción. Esto llamará a onCreateOptionsMenu() .
3. En onCreateOptionsMenu() , compruebe el indicador / condición y muéstrelo u ocúltelo de la siguiente manera:

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

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

Answer 15

Si hizo todo como en las respuestas anteriores, pero un elemento del menú aún está visible, verifique que haga 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 R.id.menu_open y verifica que exista 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í.

Answer 16

establezca un valor en una variable y llame 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);
}

Answer 17

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

Answer 18

no funciono para mi Tuve que usar explícitamente onPrepareOptionsMenu para configurar un elemento invisible.

Entonces use onCreateOptionsMenu para crear el menú y onPrepareOptionsMenu para cambiar la visibilidad, etc.

Answer 19

De acuerdo con el sitio oficial de Android Developer, OnCreateOptionMenu (menú del menú) no se recomienda para cambiar elementos de menú o íconos, visibilidad ... etc. en Runtime.

Después de que el sistema llame a onCreateOptionsMenu (), retiene una instancia del menú que llena y no volverá a llamar a onCreateOptionsMenu () a menos que el menú se invalide por alguna razón. Sin embargo, debe usar onCreateOptionsMenu () solo para crear el estado del menú inicial 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 pasa el objeto Menú tal como existe actualmente para que pueda modificarlo, como agregar, eliminar o deshabilitar elementos. (Los fragmentos también proporcionan una devolución de llamada onPrepareOptionsMenu ().) - Sitio oficial de Android Developer -

Según lo recomendado Puede usar este método onOptionsItemSelected (elemento MenuItem) para realizar un seguimiento de 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 los elementos del menú en tiempo de ejecución, puede usar onPrepareOptionsMenu (menú del 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;
} 

Answer 20

https://.com/a/21215280/466363 - contestado por Look Alterno y Sufian

• ActivityCompat.invalidateOptionsMenu () no devuelve la llamada enPrepareOptionsMenu (); simplemente actualiza el menú directamente.
• Mi someMethod () recibe llamadas desde varios lugares, incluso antes de onCreateOptionsMenu (), así que debo verificar mMenu! = Null.
• debería funcionar utilizando 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 devuelve la llamada enPrepareOptionsMenu (); simplemente actualiza el menú directamente.

• Mi someMethod () recibe llamadas desde varios lugares, incluso antes de onCreateOptionsMenu (), así que debo verificar mMenu! = Null.

• debería funcionar utilizando API 8