Wie ändere ich die Hintergrundfarbe des Optionsmenüs?

Dies ist eindeutig ein problem, das viele Programmierer haben und was hat Google noch zu bieten eine zufriedenstellende Lösung unterstützt.

Gibt es eine Menge von Absichten gekreuzt und Missverständnisse im Umlauf Beiträge zu diesem Thema, so Lesen Sie bitte die ganze Antwort, bevor Sie reagieren.

Unten habe ich eine mehr "verfeinert" und gut kommentierte version des hack von anderen Antworten auf dieser Seite, auch unter Einbeziehung von Ideen aus diesen sehr eng mit Fragen:

Ändern der Hintergrundfarbe des android-Menü

So ändern Sie die Hintergrundfarbe des Menü "Optionen"?

Android: anpassen der Anwendung-Menü (e.g hintergrund-Farbe)

http://www.macadamian.com/blog/post/android_-_theming_the_unthemable/

Android-Item Menu-Toggle-Button

Ist es möglich, das Android-Menü "Optionen" hintergrund nicht lichtdurchlässig?

http://www.codeproject.com/KB/android/AndroidMenusMyWay.aspx

Einstellung der Menü-hintergrund undurchsichtig

Getestet habe ich diesen hack auf 2.1 (simulator), 2.2 (2 echte Geräte) und 2.3 (2 echte Geräte). Ich habe keine 3.X-Tabletten zu probieren, aber veröffentlichen alle erforderlichen änderungen hier, wenn/falls ich das tun. Da 3.X-Tabletten verwenden-Action-Bars anstelle von Optionen, Menüs, wie hier beschrieben:

http://developer.android.com/guide/topics/ui/menus.html#options-menu

dieser hack wird sicherlich nahezu nichts zu tun (kein Schaden und keine gute) auf 3.X-Tabletten.

ERKLÄRUNG DES PROBLEMS (Lesen Sie diese vor der trigger-Antworten mit einem negativen Kommentar):

Optionen-Menü hat sehr unterschiedliche Formate auf unterschiedlichen Geräten. Rein schwarz mit weißem text auf einige, rein weiß mit schwarzen text auf einigen. Ich und viele andere Entwickler möchten, kontrollieren Sie die Hintergrundfarbe des Menü "Optionen" - Zellen , sowie die Farbe der Optionen im Menü text.

Bestimmte app-Entwickler müssen nur aus der Zelle die Hintergrundfarbe (nicht die text-Farbe), und Sie können dies tun, in eine sauberere Art und Weise mit dem android:panelFullBackground Stil beschrieben, der in einer anderen Antwort. Derzeit gibt es jedoch keine Kontrolle über das Optionen-Menü-text-Farbe-Stile, und so kann man diese Methode nur verwenden, ändern Sie den hintergrund zu einer anderen Farbe, die nicht den text "verschwinden".

Würden wir uns freuen, dies zu tun mit einer dokumentierten, zukunftssichere Lösung, aber man ist einfach nicht verfügbar ab Android <= 2.3. Also müssen wir eine Lösung, die funktioniert in den aktuellen Versionen und ist entworfen, um zu minimieren die Chancen der Absturz/Bruch in zukünftigen Versionen. Wir wollen eine Lösung, die fehl anmutig zurück auf die default-Verhalten, wenn es zu scheitern.

Es gibt viele legitime Gründe, warum man brauchen kann, um Steuern Sie das Aussehen des Optionen-Menüs (in der Regel mit einem visuellen Stil für den rest der app), damit ich nicht wohnen.

Es ist ein Google-Android-bug gepostet dazu: fügen Sie bitte Ihre Unterstützung, indem Sie die Hauptrolle spielen dieser bug (Hinweis: Google rät von "me-too" - Kommentare: nur ein Stern ist genug):

http://code.google.com/p/android/issues/detail?id=4441

ZUSAMMENFASSUNG DER LÖSUNGEN SO WEIT:

Mehrere Plakate haben vorgeschlagen, einen hack mit LayoutInflater.Factory. Die empfohlene hack arbeitete für Android <= 2.2 und nicht für Android 2.3, weil der hack gemacht, eine undokumentierte Annahme: dass man anrufen könnte, LayoutInflater.getView() direkt, ohne derzeit in einem Aufruf LayoutInflater.inflate() auf die gleiche LayoutInflater Instanz. Neuen code in der Android 2.3 brach diese Annahme und führten zu einer NullPointerException.

Meine leicht verfeinert hack unten nicht verlassen sich auf diese Annahme.

Darüber hinaus die hacks verlassen sich ebenfalls auf die Verwendung eines internen, undokumentierten class Namen "com.android.intern.Blick.Menü.IconMenuItemView" als string (und nicht als Java-Typ). Ich sehe keinen Weg, dies zu vermeiden und immer noch erreichen, das erklärte Ziel. Es ist jedoch auch möglich, das hack in einer sorgfältigen Weise, die fallen zurück, wenn "com.android.intern.Blick.Menü.IconMenuItemView" erscheint nicht auf dem aktuellen system.

Wieder verstehen, dass dies ist ein hack, und ich bin keineswegs fordern, das auf allen Plattformen funktioniert. Aber wir Entwickler Leben nicht in einer fantasy-akademischen Welt, wo alles durch das Buch: wir haben ein problem zu lösen und wir haben es zu lösen, so gut wir können. Zum Beispiel scheint es unwahrscheinlich, dass "com.android.intern.Blick.Menü.IconMenuItemView" existieren wird am 3.X-tablets, da diese Aktion Balken statt des Optionen-Menüs.

Schließlich, einige Entwickler haben dieses problem gelöst, indem völlig die Unterdrückung der Android-Optionen-Menü und schreiben Sie Ihre eigene Menü-Klasse (siehe einige der links oben). Ich habe nicht versucht, diese, aber wenn Sie Zeit haben, schreiben Sie Ihre eigenen Anzeigen und herausfinden, wie zu ersetzen, die Android - (ich bin mir sicher, der Teufel steckt im Detail hier), dann ist es vielleicht eine nette Lösung, die nicht erfordert keine undokumentierten hacks.

HACK:

Hier ist der code.

Diesen code verwenden, nennen addOptionsMenuHackerInflaterFactory() EINMAL von Ihrer Aktivität onCreate() oder activity onCreateOptionsMenu(). Es setzt einen Standard-Fabrik, die Auswirkungen auf die nachfolgende Erstellung von Optionen-Menü. Es hat keinen Einfluss auf Optionen-Menüs, die bereits erstellt wurden (die vorherigen hacks verwendet eine Funktion namens setMenuBackground(), das ist sehr irreführend, da die Funktion nicht, legen Sie Sie in einem beliebigen Menü Eigenschaften, bevor es zurück).

@SuppressWarnings("rawtypes")
static Class       IconMenuItemView_class = null;
@SuppressWarnings("rawtypes")
static Constructor IconMenuItemView_constructor = null;

//standard signature of constructor expected by inflater of all View classes
@SuppressWarnings("rawtypes")
private static final Class[] standard_inflater_constructor_signature = 
new Class[] { Context.class, AttributeSet.class };

protected void addOptionsMenuHackerInflaterFactory()
{
    final LayoutInflater infl = getLayoutInflater();

    infl.setFactory(new Factory()
    {
        public View onCreateView(final String name, 
                                 final Context context,
                                 final AttributeSet attrs)
        {
            if (!name.equalsIgnoreCase("com.android.internal.view.menu.IconMenuItemView"))
                return null; //use normal inflater

            View view = null;

            //"com.android.internal.view.menu.IconMenuItemView" 
            //- is the name of an internal Java class 
            //  - that exists in Android <= 3.2 and possibly beyond
            //  - that may or may not exist in other Android revs
            //- is the class whose instance we want to modify to set background etc.
            //- is the class we want to instantiate with the standard constructor:
            //    IconMenuItemView(context, attrs)
            //- this is what the LayoutInflater does if we return null
            //- unfortunately we cannot just call:
            //    infl.createView(name, null, attrs);
            //  here because on Android 3.2 (and possibly later):
            //  1. createView() can only be called inside inflate(),
            //     because inflate() sets the context parameter ultimately
            //     passed to the IconMenuItemView constructor's first arg,
            //     storing it in a LayoutInflater instance variable.
            //  2. we are inside inflate(),
            //  3. BUT from a different instance of LayoutInflater (not infl)
            //  4. there is no way to get access to the actual instance being used
            //- so we must do what createView() would have done for us
            //
            if (IconMenuItemView_class == null)
            {
                try
                {
                    IconMenuItemView_class = getClassLoader().loadClass(name);
                }
                catch (ClassNotFoundException e)
                {
                    //this OS does not have IconMenuItemView - fail gracefully
                    return null; //hack failed: use normal inflater
                }
            }
            if (IconMenuItemView_class == null)
                return null; //hack failed: use normal inflater

            if (IconMenuItemView_constructor == null)
            {
                try
                {
                    IconMenuItemView_constructor = 
                    IconMenuItemView_class.getConstructor(standard_inflater_constructor_signature);
                }
                catch (SecurityException e)
                {
                    return null; //hack failed: use normal inflater
                }
                catch (NoSuchMethodException e)
                {
                    return null; //hack failed: use normal inflater
                }
            }
            if (IconMenuItemView_constructor == null)
                return null; //hack failed: use normal inflater

            try
            {
                Object[] args = new Object[] { context, attrs };
                view = (View)(IconMenuItemView_constructor.newInstance(args));
            }
            catch (IllegalArgumentException e)
            {
                return null; //hack failed: use normal inflater
            }
            catch (InstantiationException e)
            {
                return null; //hack failed: use normal inflater
            }
            catch (IllegalAccessException e)
            {
                return null; //hack failed: use normal inflater
            }
            catch (InvocationTargetException e)
            {
                return null; //hack failed: use normal inflater
            }
            if (null == view) //in theory handled above, but be safe... 
                return null; //hack failed: use normal inflater


            //apply our own View settings after we get back to runloop
            //- android will overwrite almost any setting we make now
            final View v = view;
            new Handler().post(new Runnable()
            {
                public void run()
                {
                    v.setBackgroundColor(Color.BLACK);

                    try
                    {
                        //in Android <= 3.2, IconMenuItemView implemented with TextView
                        //guard against possible future change in implementation
                        TextView tv = (TextView)v;
                        tv.setTextColor(Color.WHITE);
                    }
                    catch (ClassCastException e)
                    {
                        //hack failed: do not set TextView attributes
                    }
                }
            });

            return view;
        }
    });
}

Vielen Dank für das Lesen und genießen!

InformationsquelleAutor der Antwort Louis Semprini

Dem style-Attribut für den Menü-hintergrund ist android:panelFullBackground.

Trotz allem, was die Dokumentation sagt, es braucht, um eine Ressource (z.B. @android:color/black oder @drawable/my_drawable), es wird Abstürzen, wenn Sie eine Farbe verwenden Wert direkt ein.

Diese auch loszuwerden, die Artikel Grenzen, ich war nicht in der Lage zu ändern oder zu entfernen, indem Sie primalpop Lösung.

Als für die Farbe für den text, ich habe nicht gefunden, einen Weg, um es durch Stile in 2.2 und ich bin sicher, ich habe alles versucht (das ist, wie ich entdeckte, den Menü-hintergrund-Attribut). Du brauchst primalpop Lösung.

InformationsquelleAutor der Antwort Pilot_51

Lief einfach in dieses Problem auch, auf eine App, die müssten kompatibel werden mit Lebkuchen und behalten immer noch so viel von dem styling von Holo-fähigen Geräten wie möglich.

Fand ich eine relativ saubere Lösung, die funktionierte OK für mich.

In das Thema, dem ich ein 9-patch-drawable hintergrund um eine benutzerdefinierte Hintergrundfarbe:

<style name="Theme.Styled" parent="Theme.Sherlock">
   ...
   <item name="android:panelFullBackground">@drawable/menu_hardkey_panel</item>
</style>

Gab ich den Versuch auf, den Stil, die Farbe für den text, und nur ein Spannable die text-Farbe für meinen Artikel code:

@Override
public boolean onCreateOptionsMenu(Menu menu) {
   MenuInflater inflater = getSupportMenuInflater();
   inflater.inflate(R.menu.actions_main, menu);

   if (android.os.Build.VERSION.SDK_INT < 
        android.os.Build.VERSION_CODES.HONEYCOMB) {

        SpannableStringBuilder text = new SpannableStringBuilder();
        text.append(getString(R.string.action_text));
        text.setSpan(new ForegroundColorSpan(Color.WHITE), 
                0, text.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

        MenuItem item1 = menu.findItem(R.id.action_item1);
        item1.setTitle(text);
   }

   return true;
}

InformationsquelleAutor der Antwort Nicolai Buch-Andersen

    /* 
     *The Options Menu (the one that pops up on pressing the menu button on the emulator) 
     * can be customized to change the background of the menu 
     *@primalpop  
   */ 

    package com.pop.menu;

    import android.app.Activity;
    import android.content.Context;
    import android.os.Bundle;
    import android.os.Handler;
    import android.util.AttributeSet;
    import android.util.Log;
    import android.view.InflateException;
    import android.view.LayoutInflater;
    import android.view.Menu;
    import android.view.MenuInflater;
    import android.view.View;
    import android.view.LayoutInflater.Factory;

    public class Options_Menu extends Activity {

        private static final String TAG = "DEBUG";

        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);

        }

        /* Invoked when the menu button is pressed */

        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            //TODO Auto-generated method stub
            super.onCreateOptionsMenu(menu);
            MenuInflater inflater = new MenuInflater(getApplicationContext());
            inflater.inflate(R.menu.options_menu, menu);
            setMenuBackground();
            return true;
        }

        /*IconMenuItemView is the class that creates and controls the options menu 
         * which is derived from basic View class. So We can use a LayoutInflater 
         * object to create a view and apply the background.
         */
        protected void setMenuBackground(){

            Log.d(TAG, "Enterting setMenuBackGround");
            getLayoutInflater().setFactory( new Factory() {

                @Override
                public View onCreateView ( String name, Context context, AttributeSet attrs ) {

                    if ( name.equalsIgnoreCase( "com.android.internal.view.menu.IconMenuItemView" ) ) {

                        try { //Ask our inflater to create the view
                            LayoutInflater f = getLayoutInflater();
                            final View view = f.createView( name, null, attrs );
                            /* 
                             * The background gets refreshed each time a new item is added the options menu. 
                             * So each time Android applies the default background we need to set our own 
                             * background. This is done using a thread giving the background change as runnable
                             * object
                             */
                            new Handler().post( new Runnable() {
                                public void run () {
                                    view.setBackgroundResource( R.drawable.background);
                                }
                            } );
                            return view;
                        }
                        catch ( InflateException e ) {}
                        catch ( ClassNotFoundException e ) {}
                    }
                    return null;
                }
            });
        }
    }

InformationsquelleAutor der Antwort primpap

protected void setMenuBackground() {
    getLayoutInflater().setFactory(new Factory() {
        @Override
        public View onCreateView (String name, Context context, AttributeSet attrs) {
            if (name.equalsIgnoreCase("com.android.internal.view.menu.IconMenuItemView")) {
                try {
                    //Ask our inflater to create the view
                    LayoutInflater f = getLayoutInflater();
                    final View view = f.createView(name, null, attrs);
                    //Kind of apply our own background
                    new Handler().post( new Runnable() {
                        public void run () {
                            view.setBackgroundResource(R.drawable.gray_gradient_background);
                        }
                    });
                    return view;
                }
                catch (InflateException e) {
                }
                catch (ClassNotFoundException e) {
                }
            }
            return null;
        }
    });
}

dies ist die XML-Datei

gradient 
    android:startColor="#AFAFAF" 
    android:endColor="#000000"
    android:angle="270"
shape

InformationsquelleAutor der Antwort Android

Dies ist, wie ich das gelöst mine. Ich habe gerade angegeben, die hintergrund Farbe und text Farbe
im Stile. ie res > values > styles.xml Datei.

<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
    <item name="android:itemBackground">#ffffff</item>
    <item name="android:textColor">#000000</item>
</style>

InformationsquelleAutor der Antwort Bukunmi