Posso alterar a cor de fundo de um item de menu no Android?
Informe-me se alguém tiver alguma solução para isso. A última opção será obviamente personalizá-la, mas existe alguma maneira de alterar a cor do texto sem personalizá-la.
Posso alterar a cor de fundo de um item de menu no Android?
Informe-me se alguém tiver alguma solução para isso. A última opção será obviamente personalizá-la, mas existe alguma maneira de alterar a cor do texto sem personalizá-la.
Respostas:
Uma linha simples no seu tema :)
<item name="android:actionMenuTextColor">@color/your_color</item>
actionBarStyle
por exemplo. Não funcionará por dentro actionBarStyle
, mesmo que isso pareça lógico!
<item name="actionMenuTextColor">@color/your_color</item>
não use o namespace Android
theme
atributo na sua barra de ferramentas, isso funcionará.
Parece que um
<item name="android:itemTextAppearance">@style/myCustomMenuTextAppearance</item>
no meu tema e
<style name="myCustomMenuTextAppearance" parent="@android:style/TextAppearance.Widget.IconMenu.Item">
<item name="android:textColor">@android:color/primary_text_dark</item>
</style>
em styles.xml altere o estilo dos itens da lista, mas não dos itens de menu.
android:itemTextAppearance
atributo não pode ser colocado em um estilo cujo pai é, parent="@android:style/Widget.Holo.ListPopupWindow"
pois isso não será renderizado corretamente. Ele deve estar em um estilo de nível superior, como aquele cujo pai é android:Theme.Holo.Light.DarkActionBar
.
Theme.Holo
ou Theme.Holo.Light.DarkActionBar
ou similar.
Você pode alterar a cor do MenuItem
texto facilmente usando em SpannableString
vez 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);
em vez demenu.getItem()
Se você estiver usando a nova barra de ferramentas, com o tema Theme.AppCompat.Light.NoActionBar
, poderá estilizá-la da seguinte maneira.
<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>`
De acordo com os resultados que obtive,
android:textColorPrimary
é a cor do texto que exibe o nome da sua atividade, que é o texto principal da barra de ferramentas.
android:textColorSecondary
é a cor do texto das legendas e o botão de mais opções (3 pontos). (Sim, ele mudou de cor de acordo com esta propriedade!)
android:textColor
É a cor de todos os outros textos, incluindo o menu.
Finalmente, defina o tema para a barra de ferramentas
<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 ).
Se você estiver usando o menu <android.support.design.widget.NavigationView />
, basta adicionar a linha abaixo NavigationView
:
app:itemTextColor="your color"
Também disponível colorTint para ícone, ele substituirá a cor do seu ícone também. Para isso você deve adicionar a linha abaixo:
app:itemIconTint="your color"
Exemplo:
<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 ajude você.
Eu fui sobre isso programaticamente assim:
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 você pode ver nesta pergunta, você deve:
<item name="android:textColorPrimary">yourColor</item>
O código acima altera a cor do texto dos itens de ação do menu para API> = v21.
<item name="actionMenuTextColor">@android:color/holo_green_light</item>
Acima está o código da API <v21
Usei a tag html para alterar a cor do texto de um único item quando o item de menu é inflado. Espero que seja ú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;
}
A maneira MAIS SIMPLES de criar cores de menu personalizadas para uma barra de ferramentas única, não para o 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 ferramentas usual em styles.xml
<style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar"/>
nosso estilo de barra de ferramentas personalizado
<style name="AppTheme.AppBarOverlay.MenuBlue">
<item name="actionMenuTextColor">@color/blue</item>
</style>
no Kotlin, escrevi estas extensões:
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)
}
}
e usado assim:
menu.findItem(R.id.main_settings).setTitleColor(Color.RED)
A resposta curta é sim. sortudo!
Para fazer isso, você precisa substituir alguns estilos dos estilos padrão do Android:
Primeiro, observe a definição dos temas no 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>
Portanto, a aparência do texto no menu está em @android:style/TextAppearance.Widget.IconMenu.Item
Agora, na definição dos estilos :
<style name="TextAppearance.Widget.IconMenu.Item" parent="TextAppearance.Small">
<item name="android:textColor">?textColorPrimaryInverse</item>
</style>
Portanto, agora temos o nome da cor em questão, se você procurar na pasta de cores dos recursos do 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, aqui está o que você precisa fazer:
Substitua "TextAppearance.Widget.IconMenu.Item" e crie seu próprio estilo. Em seguida, vincule-o ao seu próprio seletor para torná-lo da maneira que desejar. Espero que isso ajude você. Boa sorte!
O menu Opções no Android pode ser personalizado para definir o plano de fundo ou alterar a aparência do texto. A cor do plano de fundo e do texto no menu não pôde ser alterada usando temas e estilos. O código-fonte do Android (data \ res \ layout \ icon_menu_item_layout.xml) usa um item personalizado da classe “com.android.internal.view.menu.IconMenuItem” View para o layout do menu. Podemos fazer alterações na classe acima para personalizar o menu. Para conseguir o mesmo, use a classe de fábrica LayoutInflater e defina a cor do plano de fundo e do texto para a exibição.
@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
Obrigado pelo exemplo de código. Eu tive que modificá-lo e fazê-lo funcionar com um menu de contexto. Esta é a minha solução.
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 mim, isso funciona com o Android 1.6, 2.03 e 4.03.
eu achei Eureka !!
no seu tema do aplicativo:
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
<item name="android:actionBarStyle">@style/ActionBarTheme</item>
<!-- backward compatibility -->
<item name="actionBarStyle">@style/ActionBarTheme</item>
</style>
Aqui está o seu tema da barra de ação:
<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>
e aqui está o seu tema pop-up:
<style name="ActionBarPopupTheme">
<item name="android:textColor">@color/menu_text_color</item>
<item name="android:background">@color/menu_bg_color</item>
</style>
Felicidades ;)
para alterar a cor do texto do item de menu, use o código abaixo
<style name="AppToolbar" parent="Theme.AppCompat.Light.NoActionBar">
<item name="android:itemTextAppearance">@style/menu_item_color</item>
</style>
Onde
<style name="menu_item_color">
<item name="android:textColor">@color/app_font_color</item>
</style>
Graças a max.musterman, esta é a solução que consegui trabalhar no nível 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);
}
O código codificado Color.BLACK
pode se tornar um parâmetro adicional para o setMenuTextColor
método. Além disso, eu só usei isso para itens de menu que eram android:showAsAction="never"
.
Você pode definir cores programaticamente.
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);
}
}
});
}
Basta adicionar isso ao seu 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>
Testado na API 21
<style name="AppTheme.ItemTextStyle" parent="@android:style/TextAppearance.Widget">
, caso contrário, o texto parece muito pequeno no menu de estouro. Observe também que essa técnica funciona apenas no Android 5 e 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
Minha situação era configurações de cor do texto no menu de opções (o menu principal do aplicativo era exibido no pressionamento do botão de menu).
Testado na API 16 com a biblioteca appcompat-v7-27.0.2 , AppCompatActivity
para MainActivity
e AppCompat
tema para o aplicativo no 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>
Não sei se isso textColorSecondary
afeta outros elementos, mas controla a cor do texto do menu.
Procurei alguns exemplos sobre o tópico, mas todos os trechos prontos para uso não funcionaram.
Então, eu queria investigar isso com o código-fonte da biblioteca appcompat-v7 (especificamente com a pasta res do pacote .aar ).
Embora, no meu caso, eu usei o Eclipse com dependências .aar explodidas . Para que eu pudesse alterar os estilos padrão e verificar os resultados. Não sei como explodir as bibliotecas para usar diretamente com o Gradle ou o Android Studio . Merece outro segmento de investigação.
Portanto, meu objetivo era descobrir qual cor no arquivo res / values / values.xml é usada para o texto do menu (eu tinha quase certeza de que a cor estava lá).
#f00
valor a todas elas.secondary_text_default_material_light
item de cor.@color/abc_secondary_text_material_light
.Base.ThemeOverlay.AppCompat.Light
e Platform.AppCompat.Light
.android:textColorSecondary
e android:textColorTertiary
no Base.ThemeOverlay.AppCompat.Light
.android:textColorSecondary
.Theme.AppCompat.Light
e não o ThemeOverlay.AppCompat.Light
).Base.ThemeOverlay.AppCompat.Light
. Teve um filho ThemeOverlay.AppCompat.Light
.ThemeOverlay.AppCompat.Light
, encontrei seu uso no Base.Theme.AppCompat.Light.DarkActionBar
tema como o actionBarPopupTheme
valor do atributo.Theme.AppCompat.Light.DarkActionBar
era filho do encontrado, Base.Theme.AppCompat.Light.DarkActionBar
para que eu pudesse usar esse atributo nos meus styles.xml sem problemas.ThemeOverlay.AppCompat.Light
e alterei o android:textColorSecondary
atributo.A solução de Sephy não funciona. É possível substituir a aparência do texto do item de menu de opções usando o método descrito acima, mas não o item ou menu. Para fazer isso, existem essencialmente três maneiras:
Consulte o Problema 4441: Tema do menu Opções personalizadas para obter mais dicas.
tente 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
Se você deseja definir cores para um item de menu individual, a personalização de um tema da barra de ferramentas não é a solução certa. Para conseguir isso, você pode usar o android: actionLayout e uma exibição de ação para o item de menu.
Primeiro, crie um arquivo de layout XML para a visualização de ação. Neste exemplo, usamos um botão como uma visualização de ação:
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>
No snippet de código acima, usamos android:textColor="?android:attr/colorAccent"
para personalizar a cor do texto do botão.
Em seguida, no seu arquivo de layout XML para o menu, inclua app:actionLayout="@layout/menu_button"
como mostrado abaixo:
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 substituição do onCreateOptionsMenu()
método em sua atividade:
@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;
}
... ou 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 mais detalhes sobre visualizações de ação, consulte o guia do desenvolvedor do Android .
É assim que você pode colorir um item de menu específico com cores e funciona em todos os níveis da 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));
}
}
}
}
});
}
}
}
}
Ao fazer isso, você perde o efeito seletor de plano de fundo, eis o código para aplicar um seletor de plano de fundo personalizado a todos os filhos do item de menu.
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);
}
}
}
}
}
});
}
}
}
}
Aqui está a função auxiliar também:
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 alterar a cor do texto, você pode apenas definir uma exibição personalizada para o MenuItem e, em seguida, definir a cor do texto.
Código de exemplo: MenuItem.setActionView ()