android - studio - poner un menu en toolbar




¿Cómo oculto un elemento de menú en la barra de acción? (14)

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

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

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.


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


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

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

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       
}

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


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

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


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.


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

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

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

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

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




android-menu