¿Puedo cambiar el color de fondo de un elemento de menú en Android?
Avíseme si alguien tiene alguna solución para esto. Obviamente, la última opción será personalizarlo, pero hay alguna forma de cambiar el color del texto sin personalizarlo.
¿Puedo cambiar el color de fondo de un elemento de menú en Android?
Avíseme si alguien tiene alguna solución para esto. Obviamente, la última opción será personalizarlo, pero hay alguna forma de cambiar el color del texto sin personalizarlo.
Respuestas:
Una línea simple en tu tema :)
<item name="android:actionMenuTextColor">@color/your_color</item>
actionBarStyle
por ejemplo. No funcionará dentro actionBarStyle
, ¡aunque parezca lógico!
<item name="actionMenuTextColor">@color/your_color</item>
, no use el espacio de nombres de Android
theme
atributo en su barra de herramientas, esto funciona.
Parece que un
<item name="android:itemTextAppearance">@style/myCustomMenuTextAppearance</item>
en mi tema y
<style name="myCustomMenuTextAppearance" parent="@android:style/TextAppearance.Widget.IconMenu.Item">
<item name="android:textColor">@android:color/primary_text_dark</item>
</style>
en styles.xml cambia el estilo de los elementos de la lista pero no de los elementos del menú.
android:itemTextAppearance
atributo no se puede colocar dentro de un estilo cuyo padre es, parent="@android:style/Widget.Holo.ListPopupWindow"
ya que no se representará correctamente. Debe estar en un estilo de nivel superior como uno cuyo padre es android:Theme.Holo.Light.DarkActionBar
.
Theme.Holo
o Theme.Holo.Light.DarkActionBar
o similar.
Puede cambiar el color del MenuItem
texto fácilmente usando en SpannableString
lugar de String
.
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
inflater.inflate(R.menu.your_menu, menu);
int positionOfMenuItem = 0; // or whatever...
MenuItem item = menu.getItem(positionOfMenuItem);
SpannableString s = new SpannableString("My red MenuItem");
s.setSpan(new ForegroundColorSpan(Color.RED), 0, s.length(), 0);
item.setTitle(s);
}
menu.findItem(R.id.menu_item_id);
lugar demenu.getItem()
Si está utilizando la nueva barra de herramientas, con el tema Theme.AppCompat.Light.NoActionBar
, puede diseñarla de la siguiente manera.
<style name="ToolbarTheme" parent="Theme.AppCompat.Light.NoActionBar">
<item name="android:textColorPrimary">@color/my_color1</item>
<item name="android:textColorSecondary">@color/my_color2</item>
<item name="android:textColor">@color/my_color3</item>
</style>`
Según los resultados que obtuve,
android:textColorPrimary
es el color del texto que muestra el nombre de su actividad, que es el texto principal de la barra de herramientas.
android:textColorSecondary
es el color del texto para el botón de subtítulos y más opciones (3 puntos). (Sí, ¡cambió su color de acuerdo con esta propiedad!)
android:textColor
Es el color de todos los demás textos, incluido el menú.
Finalmente establece el tema en la barra de herramientas
<android.support.v7.widget.Toolbar xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
app:theme="@style/ToolbarTheme"
android:layout_height="wrap_content"
android:layout_width="match_parent"
android:minHeight="?attr/actionBarSize"/>
android:actionMenuTextColor
(consulte stackoverflow.com/a/5538709/423105 ).
Si está utilizando el menú como <android.support.design.widget.NavigationView />
entonces, simplemente agregue la siguiente línea en NavigationView
:
app:itemTextColor="your color"
También disponible en colorTint para ícono, también anulará el color de su ícono. Para eso tienes que agregar la siguiente línea:
app:itemIconTint="your color"
Ejemplo:
<android.support.design.widget.NavigationView
android:id="@+id/nav_view"
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:layout_gravity="start"
app:itemTextColor="@color/color_white"
app:itemIconTint="@color/color_white"
android:background="@color/colorPrimary"
android:fitsSystemWindows="true"
app:headerLayout="@layout/nav_header_main"
app:menu="@menu/activity_main_drawer"/>
Espero que te ayude.
Lo hice programáticamente así:
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.changeip_card_menu, menu);
for(int i = 0; i < menu.size(); i++) {
MenuItem item = menu.getItem(i);
SpannableString spanString = new SpannableString(menu.getItem(i).getTitle().toString());
spanString.setSpan(new ForegroundColorSpan(Color.BLACK), 0, spanString.length(), 0); //fix the color to white
item.setTitle(spanString);
}
return true;
}
como puede ver en esta pregunta , debe:
<item name="android:textColorPrimary">yourColor</item>
El código anterior cambia el color del texto de los elementos de acción del menú para API> = v21.
<item name="actionMenuTextColor">@android:color/holo_green_light</item>
Arriba está el código para API <v21
Usé la etiqueta html para cambiar el color del texto de un solo elemento cuando el elemento del menú está inflado. Espero que sea útil.
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
menu.findItem(R.id.main_settings).setTitle(Html.fromHtml("<font color='#ff3824'>Settings</font>"));
return true;
}
La forma MÁS SENCILLA de hacer un color de menú personalizado para una barra de herramientas única, no para AppTheme
<android.support.design.widget.AppBarLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:theme="@style/AppTheme.AppBarOverlay.MenuBlue">
<android.support.v7.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"/>
</android.support.design.widget.AppBarLayout>
barra de herramientas habitual en styles.xml
<style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar"/>
nuestro estilo de barra de herramientas personalizada
<style name="AppTheme.AppBarOverlay.MenuBlue">
<item name="actionMenuTextColor">@color/blue</item>
</style>
en Kotlin escribí estas extensiones:
fun MenuItem.setTitleColor(color: Int) {
val hexColor = Integer.toHexString(color).toUpperCase().substring(2)
val html = "<font color='#$hexColor'>$title</font>"
this.title = html.parseAsHtml()
}
@Suppress("DEPRECATION")
fun String.parseAsHtml(): Spanned {
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
Html.fromHtml(this, Html.FROM_HTML_MODE_LEGACY)
} else {
Html.fromHtml(this)
}
}
y usado así:
menu.findItem(R.id.main_settings).setTitleColor(Color.RED)
La respuesta corta es sí. ¡eres afortunado!
Para hacerlo, debe anular algunos estilos de los estilos predeterminados de Android:
Primero, mira la definición de los temas en Android:
<style name="Theme.IconMenu">
<!-- Menu/item attributes -->
<item name="android:itemTextAppearance">@android:style/TextAppearance.Widget.IconMenu.Item</item>
<item name="android:itemBackground">@android:drawable/menu_selector</item>
<item name="android:itemIconDisabledAlpha">?android:attr/disabledAlpha</item>
<item name="android:horizontalDivider">@android:drawable/divider_horizontal_bright</item>
<item name="android:verticalDivider">@android:drawable/divider_vertical_bright</item>
<item name="android:windowAnimationStyle">@android:style/Animation.OptionsPanel</item>
<item name="android:moreIcon">@android:drawable/ic_menu_more</item>
<item name="android:background">@null</item>
</style>
Entonces, la aparición del texto en el menú está en @android:style/TextAppearance.Widget.IconMenu.Item
Ahora, en la definición de los estilos :
<style name="TextAppearance.Widget.IconMenu.Item" parent="TextAppearance.Small">
<item name="android:textColor">?textColorPrimaryInverse</item>
</style>
Así que ahora tenemos el nombre del color en cuestión, si busca en la carpeta de colores de los recursos del sistema:
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:state_enabled="false" android:color="@android:color/bright_foreground_light_disabled" />
<item android:state_window_focused="false" android:color="@android:color/bright_foreground_light" />
<item android:state_pressed="true" android:color="@android:color/bright_foreground_light" />
<item android:state_selected="true" android:color="@android:color/bright_foreground_light" />
<item android:color="@android:color/bright_foreground_light" />
<!-- not selected -->
</selector>
Finalmente, esto es lo que debe hacer:
Anule "TextAppearance.Widget.IconMenu.Item" y cree su propio estilo. Luego, vincúlelo a su propio selector para hacerlo de la manera que desee. Espero que esto te ayude. ¡Buena suerte!
El menú de opciones en Android se puede personalizar para establecer el fondo o cambiar la apariencia del texto. El fondo y el color del texto en el menú no se pueden cambiar usando temas y estilos. El código fuente de Android (data \ res \ layout \ icon_menu_item_layout.xml) utiliza un elemento personalizado de la clase "com.android.internal.view.menu.IconMenuItem" View para el diseño del menú. Podemos hacer cambios en la clase anterior para personalizar el menú. Para lograr lo mismo, use la clase de fábrica LayoutInflater y establezca el fondo y el color del texto para la vista.
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.my_menu, menu);
getLayoutInflater().setFactory(new Factory() {
@Override
public View onCreateView(String name, Context context, AttributeSet attrs) {
if (name .equalsIgnoreCase(“com.android.internal.view.menu.IconMenuItemView”)) {
try{
LayoutInflater f = getLayoutInflater();
final View view = f.createView(name, null, attrs);
new Handler().post(new Runnable() {
public void run() {
// set the background drawable
view .setBackgroundResource(R.drawable.my_ac_menu_background);
// set the text color
((TextView) view).setTextColor(Color.WHITE);
}
});
return view;
} catch (InflateException e) {
} catch (ClassNotFoundException e) {}
}
return null;
}
});
return super.onCreateOptionsMenu(menu);
}
03-23 19:45:25.134: E/AndroidRuntime(26761): java.lang.IllegalStateException: A factory has already been set on this LayoutInflater
Gracias por el código de ejemplo. Tuve que modificarlo para que funcione con un menú contextual. Esta es mi solución
static final Class<?>[] constructorSignature = new Class[] {Context.class, AttributeSet.class};
class MenuColorFix implements LayoutInflater.Factory {
public View onCreateView(String name, Context context, AttributeSet attrs) {
if (name.equalsIgnoreCase("com.android.internal.view.menu.ListMenuItemView")) {
try {
Class<? extends ViewGroup> clazz = context.getClassLoader().loadClass(name).asSubclass(ViewGroup.class);
Constructor<? extends ViewGroup> constructor = clazz.getConstructor(constructorSignature);
final ViewGroup view = constructor.newInstance(new Object[]{context,attrs});
new Handler().post(new Runnable() {
public void run() {
try {
view.setBackgroundColor(Color.BLACK);
List<View> children = getAllChildren(view);
for(int i = 0; i< children.size(); i++) {
View child = children.get(i);
if ( child instanceof TextView ) {
((TextView)child).setTextColor(Color.WHITE);
}
}
}
catch (Exception e) {
Log.i(TAG, "Caught Exception!",e);
}
}
});
return view;
}
catch (Exception e) {
Log.i(TAG, "Caught Exception!",e);
}
}
return null;
}
}
public List<View> getAllChildren(ViewGroup vg) {
ArrayList<View> result = new ArrayList<View>();
for ( int i = 0; i < vg.getChildCount(); i++ ) {
View child = vg.getChildAt(i);
if ( child instanceof ViewGroup) {
result.addAll(getAllChildren((ViewGroup)child));
}
else {
result.add(child);
}
}
return result;
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
LayoutInflater lInflater = getLayoutInflater();
if ( lInflater.getFactory() == null ) {
lInflater.setFactory(new MenuColorFix());
}
super.onCreateContextMenu(menu, v, menuInfo);
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.myMenu, menu);
}
Para mí esto funciona con Android 1.6, 2.03 y 4.03.
Lo encontré Eureka !!
en el tema de tu aplicación:
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
<item name="android:actionBarStyle">@style/ActionBarTheme</item>
<!-- backward compatibility -->
<item name="actionBarStyle">@style/ActionBarTheme</item>
</style>
Aquí está el tema de su barra de acción:
<style name="ActionBarTheme" parent="@style/Widget.AppCompat.Light.ActionBar.Solid.Inverse">
<item name="android:background">@color/actionbar_bg_color</item>
<item name="popupTheme">@style/ActionBarPopupTheme</item
<!-- backward compatibility -->
<item name="background">@color/actionbar_bg_color</item>
</style>
y aquí está tu tema emergente:
<style name="ActionBarPopupTheme">
<item name="android:textColor">@color/menu_text_color</item>
<item name="android:background">@color/menu_bg_color</item>
</style>
Salud ;)
para cambiar el color del texto del elemento del menú, use el siguiente código
<style name="AppToolbar" parent="Theme.AppCompat.Light.NoActionBar">
<item name="android:itemTextAppearance">@style/menu_item_color</item>
</style>
dónde
<style name="menu_item_color">
<item name="android:textColor">@color/app_font_color</item>
</style>
Gracias a max.musterman, esta es la solución que llegué a trabajar en el nivel 22:
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_main, menu);
SearchManager searchManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
MenuItem searchMenuItem = menu.findItem(R.id.search);
SearchView searchView = (SearchView) searchMenuItem.getActionView();
searchView.setSearchableInfo(searchManager.getSearchableInfo(getComponentName()));
searchView.setSubmitButtonEnabled(true);
searchView.setOnQueryTextListener(this);
setMenuTextColor(menu, R.id.displaySummary, R.string.show_summary);
setMenuTextColor(menu, R.id.about, R.string.text_about);
setMenuTextColor(menu, R.id.importExport, R.string.import_export);
setMenuTextColor(menu, R.id.preferences, R.string.settings);
return true;
}
private void setMenuTextColor(Menu menu, int menuResource, int menuTextResource) {
MenuItem item = menu.findItem(menuResource);
SpannableString s = new SpannableString(getString(menuTextResource));
s.setSpan(new ForegroundColorSpan(Color.BLACK), 0, s.length(), 0);
item.setTitle(s);
}
El hardcoded Color.BLACK
podría convertirse en un parámetro adicional para el setMenuTextColor
método. Además, solo usé esto para elementos de menú que eran android:showAsAction="never"
.
Puede configurar el color mediante programación.
private static void setMenuTextColor(final Context context, final Toolbar toolbar, final int menuResId, final int colorRes) {
toolbar.post(new Runnable() {
@Override
public void run() {
View settingsMenuItem = toolbar.findViewById(menuResId);
if (settingsMenuItem instanceof TextView) {
if (DEBUG) {
Log.i(TAG, "setMenuTextColor textview");
}
TextView tv = (TextView) settingsMenuItem;
tv.setTextColor(ContextCompat.getColor(context, colorRes));
} else { // you can ignore this branch, because usually there is not the situation
Menu menu = toolbar.getMenu();
MenuItem item = menu.findItem(menuResId);
SpannableString s = new SpannableString(item.getTitle());
s.setSpan(new ForegroundColorSpan(ContextCompat.getColor(context, colorRes)), 0, s.length(), 0);
item.setTitle(s);
}
}
});
}
Simplemente agregue esto a su tema
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
<item name="android:itemTextAppearance">@style/AppTheme.ItemTextStyle</item>
</style>
<style name="AppTheme.ItemTextStyle" parent="@android:style/TextAppearance.Widget.IconMenu.Item">
<item name="android:textColor">@color/orange_500</item>
</style>
Probado en API 21
<style name="AppTheme.ItemTextStyle" parent="@android:style/TextAppearance.Widget">
, de lo contrario el texto parece demasiado pequeño en el menú de desbordamiento. También tenga en cuenta que esta técnica solo funciona en Android 5 y superior.
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
inflater.inflate(R.menu.search, menu);
MenuItem myActionMenuItem = menu.findItem( R.id.action_search);
SearchView searchView = (SearchView) myActionMenuItem.getActionView();
EditText searchEditText = (EditText) searchView.findViewById(android.support.v7.appcompat.R.id.search_src_text);
searchEditText.setTextColor(Color.WHITE); //You color here
Mi situación fue la configuración del color del texto en el menú de opciones (el menú principal de la aplicación se mostró al presionar el botón de menú).
Probado de API 16 con appcompat-v7-27.0.2 biblioteca, AppCompatActivity
para MainActivity
y AppCompat
tema para la aplicación en AndroidManifest.xml .
styles.xml :
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
<item name="actionBarPopupTheme">@style/PopupTheme</item>
</style>
<style name="PopupTheme" parent="@style/ThemeOverlay.AppCompat.Light">
<item name="android:textColorSecondary">#f00</item>
</style>
No sé si eso textColorSecondary
afecta a otros elementos pero controla el color del texto del menú.
Busqué algunos ejemplos sobre el tema, pero todos los fragmentos listos para usar no funcionaron.
Así que quería investigarlo con el código fuente de la biblioteca appcompat-v7 (específicamente con la carpeta res del paquete .aar ).
Aunque en mi caso usé Eclipse con dependencias .aar explotadas . Entonces podría cambiar los estilos predeterminados y verificar los resultados. No sé cómo explotar las bibliotecas para usar con Gradle o Android Studio directamente. Se merece otro hilo de investigación.
Entonces, mi propósito era encontrar qué color en el archivo res / values / values.xml se usa para el texto del menú (estaba casi seguro de que el color estaba allí).
#f00
valor.secondary_text_default_material_light
elemento de color.@color/abc_secondary_text_material_light
.Base.ThemeOverlay.AppCompat.Light
yPlatform.AppCompat.Light
.android:textColorSecondary
y android:textColorTertiary
en el Base.ThemeOverlay.AppCompat.Light
.android:textColorSecondary
.Theme.AppCompat.Light
y no el ThemeOverlay.AppCompat.Light
).Base.ThemeOverlay.AppCompat.Light
. Tuvo un hijo ThemeOverlay.AppCompat.Light
.ThemeOverlay.AppCompat.Light
, encontré su uso en el Base.Theme.AppCompat.Light.DarkActionBar
tema como actionBarPopupTheme
valor de atributo.Theme.AppCompat.Light.DarkActionBar
era hijo de lo encontrado, Base.Theme.AppCompat.Light.DarkActionBar
por lo que podría usar ese atributo en mi styles.xml sin problemas.ThemeOverlay.AppCompat.Light
y cambié el android:textColorSecondary
atributo.La solución de Sephy no funciona. Es posible anular la apariencia del texto del elemento del menú de opciones utilizando el método descrito anteriormente, pero no el elemento o el menú. Para hacer eso hay esencialmente 3 formas:
Consulte el número 4441: Tema del menú de opciones personalizadas para obtener más pistas.
prueba este código ...
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.my_menu, menu);
getLayoutInflater().setFactory(new Factory() {
@Override
public View onCreateView(String name, Context context,
AttributeSet attrs) {
if (name.equalsIgnoreCase("com.android.internal.view.menu.IconMenuItemView")) {
try {
LayoutInflater f = getLayoutInflater();
final View view = f.createView(name, null, attrs);
new Handler().post(new Runnable() {
public void run() {
// set the background drawable
view.setBackgroundResource(R.drawable.my_ac_menu_background);
// set the text color
((TextView) view).setTextColor(Color.WHITE);
}
});
return view;
} catch (InflateException e) {
} catch (ClassNotFoundException e) {
}
}
return null;
}
});
return super.onCreateOptionsMenu(menu);
}
java.lang.IllegalStateException: A factory has already been set on this LayoutInflater
Si desea establecer el color para un elemento de menú individual, personalizar un tema de barra de herramientas no es la solución correcta. Para lograr esto, puede hacer uso de android: actionLayout y una vista de acción para el elemento del menú.
Primero cree un archivo de diseño XML para la vista de acción. En este ejemplo, usamos un botón como vista de acción:
menu_button.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">
<Button
android:id="@+id/menuButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Done"
android:textColor="?android:attr/colorAccent"
style="?android:attr/buttonBarButtonStyle"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
En el fragmento de código anterior, usamos android:textColor="?android:attr/colorAccent"
para personalizar el color del texto del botón.
Luego, en su archivo de diseño XML para el menú, incluya lo app:actionLayout="@layout/menu_button"
que se muestra a continuación:
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">
<item
android:id="@+id/menuItem"
android:title=""
app:actionLayout="@layout/menu_button"
app:showAsAction="always"/>
</menu>
Última anulación del onCreateOptionsMenu()
método en su actividad:
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.main_menu, menu);
MenuItem item = menu.findItem(R.id.menuItem);
Button saveButton = item.getActionView().findViewById(R.id.menuButton);
saveButton.setOnClickListener(view -> {
// Do something
});
return true;
}
... o fragmento:
@Override
public void onCreateOptionsMenu(@NonNull Menu menu, @NonNull MenuInflater inflater){
inflater.inflate(R.menu.main_menu, menu);
MenuItem item = menu.findItem(R.id.menuItem);
Button saveButton = item.getActionView().findViewById(R.id.menuButton);
button.setOnClickListener(view -> {
// Do something
});
}
Para obtener más detalles sobre las vistas de acción, consulte la guía para desarrolladores de Android .
Así es como puede colorear un elemento de menú específico con color, funciona para todos los niveles de API:
public static void setToolbarMenuItemTextColor(final Toolbar toolbar,
final @ColorRes int color,
@IdRes final int resId) {
if (toolbar != null) {
for (int i = 0; i < toolbar.getChildCount(); i++) {
final View view = toolbar.getChildAt(i);
if (view instanceof ActionMenuView) {
final ActionMenuView actionMenuView = (ActionMenuView) view;
// view children are accessible only after layout-ing
actionMenuView.post(new Runnable() {
@Override
public void run() {
for (int j = 0; j < actionMenuView.getChildCount(); j++) {
final View innerView = actionMenuView.getChildAt(j);
if (innerView instanceof ActionMenuItemView) {
final ActionMenuItemView itemView = (ActionMenuItemView) innerView;
if (resId == itemView.getId()) {
itemView.setTextColor(ContextCompat.getColor(toolbar.getContext(), color));
}
}
}
}
});
}
}
}
}
Al hacerlo, pierde el efecto del selector de fondo, así que aquí está el código para aplicar un selector de fondo personalizado a todos los elementos secundarios del menú.
public static void setToolbarMenuItemsBackgroundSelector(final Context context,
final Toolbar toolbar) {
if (toolbar != null) {
for (int i = 0; i < toolbar.getChildCount(); i++) {
final View view = toolbar.getChildAt(i);
if (view instanceof ImageButton) {
// left toolbar icon (navigation, hamburger, ...)
UiHelper.setViewBackgroundSelector(context, view);
} else if (view instanceof ActionMenuView) {
final ActionMenuView actionMenuView = (ActionMenuView) view;
// view children are accessible only after layout-ing
actionMenuView.post(new Runnable() {
@Override
public void run() {
for (int j = 0; j < actionMenuView.getChildCount(); j++) {
final View innerView = actionMenuView.getChildAt(j);
if (innerView instanceof ActionMenuItemView) {
// text item views
final ActionMenuItemView itemView = (ActionMenuItemView) innerView;
UiHelper.setViewBackgroundSelector(context, itemView);
// icon item views
for (int k = 0; k < itemView.getCompoundDrawables().length; k++) {
if (itemView.getCompoundDrawables()[k] != null) {
UiHelper.setViewBackgroundSelector(context, itemView);
}
}
}
}
}
});
}
}
}
}
Aquí está la función auxiliar también:
public static void setViewBackgroundSelector(@NonNull Context context, @NonNull View itemView) {
int[] attrs = new int[]{R.attr.selectableItemBackgroundBorderless};
TypedArray ta = context.obtainStyledAttributes(attrs);
Drawable drawable = ta.getDrawable(0);
ta.recycle();
ViewCompat.setBackground(itemView, drawable);
}
Para cambiar el color del texto, puede establecer una vista personalizada para el elemento de menú y luego puede definir el color del texto.
Código de muestra: MenuItem.setActionView ()