it-swarm.com.de

Wie kann ich die Textfarbe des Menüelements in Android ändern?

Kann ich die Hintergrundfarbe eines Menüelements in Android ändern?

Bitte lassen Sie mich wissen, ob jemand eine Lösung dafür hat. Die letzte Option besteht natürlich darin, sie anzupassen. Es gibt jedoch eine Möglichkeit, die Textfarbe zu ändern, ohne sie anzupassen.

124
sunil

Eine einfache Zeile in Ihrem Thema :)

<item name="Android:actionMenuTextColor">@color/your_color</item>
279

Es scheint, dass ein

  <item name="Android:itemTextAppearance">@style/myCustomMenuTextAppearance</item>

in meinem Thema und

   <style name="myCustomMenuTextAppearance" parent="@Android:style/TextAppearance.Widget.IconMenu.Item">
        <item name="Android:textColor">@Android:color/primary_text_dark</item>
    </style>

in styles.xml ändern Sie den Stil von Listenelementen, jedoch nicht von Menüelementen.

91
Marcus Wolschon

Sie können die Farbe des MenuItem-Textes leicht ändern, indem Sie SpannableString anstelle von String verwenden.

@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);
}
70
max.mustermann

Wenn Sie die neue Symbolleiste mit dem Design Theme.AppCompat.Light.NoActionBar verwenden, können Sie sie auf folgende Weise gestalten.

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

Nach den Ergebnissen, die ich bekam,
Android:textColorPrimary ist die Textfarbe, die den Namen Ihrer Aktivität angibt. Dies ist der Haupttext der Symbolleiste. 

Android:textColorSecondary ist die Textfarbe für Untertitel und weitere Optionsschaltflächen (3 Punkte). (Ja, es hat seine Farbe entsprechend dieser Eigenschaft geändert!) 

Android:textColor ist die Farbe für alle anderen Texte einschließlich des Menüs .

Stellen Sie schließlich das Design auf die Symbolleiste ein

<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"/>
43
Sudara

Wenn Sie menu als <Android.support.design.widget.NavigationView /> verwenden, fügen Sie einfach die folgende Zeile in NavigationView hinzu:

app:itemTextColor="your color"

Auch als colorTint for icon erhältlich, wird die Farbe Ihres Icons ebenfalls überschrieben. Dafür müssen Sie folgende Zeile hinzufügen:

app:itemIconTint="your color"

Beispiel: 

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

Ich hoffe es wird dir helfen.

24
Mihir Trivedi

Ich ging programmatisch so vor:

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

wie Sie sehen können in diese Frage Sie sollten:

<item name="Android:textColorPrimary">yourColor</item>

Der obige Code ändert die Textfarbe der Menüaktionselemente für API> = v21.

<item name="actionMenuTextColor">@Android:color/holo_green_light</item>

Oben ist der Code für API <v21

14
pouya

Ich habe das HTML-Tag verwendet, um die Textfarbe eines einzelnen Elements zu ändern, wenn das Menüelement aufgeblasen ist. Ich hoffe es wäre hilfreich.

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

Die kurze Antwort lautet JA. Du Glückspilz!
Dazu müssen Sie einige Stile der Android-Standardstile überschreiben: 

Sehen Sie sich zuerst die Definition der Themen an in 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>

Das Aussehen des Textes im Menü ist also in @Android:style/TextAppearance.Widget.IconMenu.Item
Nun bei der Definition von der Stile

<style name="TextAppearance.Widget.IconMenu.Item" parent="TextAppearance.Small">
<item name="Android:textColor">?textColorPrimaryInverse</item>
</style>

Nun haben wir den Namen der fraglichen Farbe, wenn Sie im Farbordner der Ressourcen des Systems nachschauen: 

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

Zum Schluss müssen Sie Folgendes tun: 

Überschreiben Sie "TextAppearance.Widget.IconMenu.Item" und erstellen Sie Ihren eigenen Stil. Dann verlinke es mit deinem eigenen Selektor, um es so zu machen, wie du es willst.

6
Sephy

Vielen Dank für das Codebeispiel . Ich musste es ändern.

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

Bei mir funktioniert das mit Android 1.6, 2.03 und 4.03.

6
Michael Vogl

Das Optionsmenü in Android kann angepasst werden, um den Hintergrund festzulegen oder das Aussehen des Textes zu ändern. Die Hintergrund- und Textfarbe im Menü konnte nicht mit Designs und Stilen geändert werden. Der Android-Quellcode (data\res\layout\icon_menu_item_layout.xml) verwendet ein benutzerdefiniertes Element der Klasse „com.Android.internal.view.menu.IconMenuItem“ für das Menülayout. Wir können Änderungen in der obigen Klasse vornehmen, um das Menü anzupassen. Verwenden Sie dazu die Factory-Klasse LayoutInflater, und legen Sie die Hintergrund- und Textfarbe für die Ansicht fest.


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

6
Abhay Kumar

SIMPLEST-Methode zum Erstellen einer benutzerdefinierten Menüfarbe für einzelne Symbolleisten, nicht für 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>

gewöhnliche Symbolleiste in styles.xml

<style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar"/>

unser benutzerdefinierter Symbolleistenstil

<style name="AppTheme.AppBarOverlay.MenuBlue">
    <item name="actionMenuTextColor">@color/blue</item>
</style>
5
AndrewS

ich habe es Eureka gefunden !!

in Ihrem App-Thema:

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="Android:actionBarStyle">@style/ActionBarTheme</item>
    <!-- backward compatibility -->          
    <item name="actionBarStyle">@style/ActionBarTheme</item>        
</style>

hier ist dein Actionbar-Thema:

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

und hier ist dein Popup-Thema:

 <style name="ActionBarPopupTheme">
    <item name="Android:textColor">@color/menu_text_color</item>
    <item name="Android:background">@color/menu_bg_color</item>
 </style>

Prost ;)

5

Dank max.musterman ist dies die Lösung, mit der ich in Level 22 arbeiten konnte:

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

Der fest codierte Color.BLACK könnte ein zusätzlicher Parameter für die setMenuTextColor-Methode werden. Außerdem habe ich dies nur für Menüpunkte verwendet, die Android:showAsAction="never" waren.

4
lightkeeper

um die Textfarbe des Menüelements zu ändern, verwenden Sie den folgenden Code

<style name="AppToolbar" parent="Theme.AppCompat.Light.NoActionBar">
<item name="Android:itemTextAppearance">@style/menu_item_color</item>
</style>

woher 

<style name="menu_item_color">
<item name="Android:textColor">@color/app_font_color</item>
</style>
2

Sie können die Farbe programmgesteuert einstellen.

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

        }
    });
}
2
Victor Choy

Meine Situation war die Einstellung der Textfarbe im Optionsmenü (Hauptmenü der App wurde beim Drücken der Menütaste angezeigt).

Getestet in API 16 mit appcompat-v7-27.0.2 -Bibliothek, AppCompatActivity für MainActivity und AppCompat für die Anwendung in 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>

Ich weiß nicht, ob diese textColorSecondary sich auf andere Elemente auswirkt, aber sie steuert die Farbe des Menütextes.


Ich habe einige Beispiele zu diesem Thema gesucht, aber alle gebrauchsfertigen Snippets haben nicht funktioniert.

Daher wollte ich es mit dem Quellcode für die Bibliothek appcompat-v7 untersuchen (insbesondere mit dem Ordner res des Pakets .aar).

In meinem Fall habe ich Eclipse jedoch mit explodierten .aar - Abhängigkeiten verwendet. So konnte ich die Standardstile ändern und die Ergebnisse überprüfen. Sie können die Bibliotheken nicht explodieren, um sie direkt mit Gradle oder Android Studio zu verwenden. Es verdient eine weitere Untersuchung.

Mein Ziel war es also herauszufinden, welche Farbe in der Datei res/values ​​/ values.xml für den Menütext verwendet wird (ich war fast sicher, dass die Farbe dort war).

  1. Ich öffnete die Datei, kopierte dann alle Farben, setzte sie unter die Standardfarben, um sie zu überschreiben, und wies ihnen allen einen #f00-Wert zu.
  2. Starten Sie die App.
  3. Viele Elemente hatten einen roten Hintergrund oder eine Textfarbe. Und auch die Menüpunkte. Das war was ich brauchte.
  4. Nachdem ich meine hinzugefügten Farben in 5-10-Zeilen-Blöcken entfernt hatte, endete ich mit dem Farbelement secondary_text_default_material_light.
  5. Bei der Suche nach diesem Namen in den Dateien im Ordner res (oder besser in res/colors) habe ich nur ein Vorkommen in der Datei color/abc_secondary_text_material.light.xml gefunden (ich habe dafür Sublime-Text verwendet.) Operationen, damit es einfacher ist, das zu finden, was ich brauche).
  6. Zurück zu values.xml wurden 8 Verwendungen für den @color/abc_secondary_text_material_light gefunden.
  7. Es war ein Light - Thema, also 4 in 2 Themen: Base.ThemeOverlay.AppCompat.Light und Platform.AppCompat.Light.
  8. Das erste Thema war ein Kind des zweiten Themas. Es gab also nur zwei Attribute mit dieser Farbressource: Android:textColorSecondary und Android:textColorTertiary im Base.ThemeOverlay.AppCompat.Light.
  9. Wenn Sie ihre Werte direkt in values.xml ändern und die App ausführen, habe ich festgestellt, dass das letzte korrekte Attribut Android:textColorSecondary war.
  10. Als Nächstes brauchte ich ein Design oder ein anderes Attribut, damit ich es in style.xml meiner App ändern konnte (da mein Design als Ãœbergeordneter den Theme.AppCompat.Light und nicht den ThemeOverlay.AppCompat.Light hatte).
  11. Ich habe in der gleichen Datei nach dem Base.ThemeOverlay.AppCompat.Light gesucht. Es hatte ein Kind ThemeOverlay.AppCompat.Light.
  12. Bei der Suche nach ThemeOverlay.AppCompat.Light fand ich seine Verwendung im Base.Theme.AppCompat.Light.DarkActionBar-Design als actionBarPopupTheme-Attributwert.
  13. Das Thema Theme.AppCompat.Light.DarkActionBar meiner App war ein Kind des gefundenen Base.Theme.AppCompat.Light.DarkActionBar. Daher konnte ich dieses Attribut in meiner styles.xml problemlos verwenden.
  14. Wie im obigen Beispielcode zu sehen ist, habe ich aus dem genannten ThemeOverlay.AppCompat.Light ein untergeordnetes Design erstellt und das Android:textColorSecondary-Attribut geändert.

 https://i.imgur.com/LNfKdzC.png

2
mortalis

in Kotlin habe ich folgende Erweiterungen geschrieben:

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

und so benutzt:

menu.findItem(R.id.main_settings).setTitleColor(Color.RED)
2
Amir Khorsandi
@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
2
Bäda

Das Hinzufügen in meine styles.xml hat für mich funktioniert 

<item name="Android:textColorPrimary">?android:attr/textColorPrimaryInverse</item>
1
Asim

Sephys Lösung funktioniert nicht. Es ist möglich, die Textdarstellung des Optionsmenüelements mit der oben beschriebenen Methode zu überschreiben, nicht jedoch das Element oder Menü. Dafür gibt es im Wesentlichen drei Möglichkeiten:

  1. Wie kann ich die Hintergrundfarbe des Optionsmenüs ändern?
  2. Schreiben Sie Ihre eigene Ansicht, um onCreateOptionsMenu und onPrepareOptionsMenu anzuzeigen und zu überschreiben, um die gewünschten Ergebnisse zu erhalten. Ich sage dies im Allgemeinen, weil Sie im Allgemeinen tun können, was Sie mit diesen Methoden wollen, aber Sie wollen wahrscheinlich nicht super () aufrufen.
  3. Kopieren Sie den Code aus dem Open-Source-SDK und passen Sie ihn an Ihr Verhalten an. Die von Activity verwendete Standardmenüimplementierung wird nicht mehr angewendet.

Siehe Ausgabe 4441: Benutzerdefiniertes Optionsmenü für weitere Hinweise.

1
Tenacious

probiere diesen Code aus ....

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

Fügen Sie dies einfach zu Ihrem Thema hinzu

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

Getestet auf API 21

1
Pham Quan

So können Sie einen bestimmten Menüpunkt mit Farbe einfärben. Er funktioniert für alle API-Ebenen:

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

Dadurch verlieren Sie den Hintergrundauswahleffekt, so dass hier der Code zum Anwenden eines benutzerdefinierten Hintergrundauswählers auf alle untergeordneten Menüpunktelemente gilt.

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

Hier ist auch die Helferfunktion:

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

Um die Textfarbe zu ändern, können Sie einfach eine benutzerdefinierte Ansicht für das MenuItem festlegen und dann die Farbe für den Text festlegen.

Beispielcode: MenuItem.setActionView ()

0
leisure