Wie kann man die Primär- und Akzentfarbe in Android Lollipop wirklich programmgesteuert ändern?

Zunächst einmal diese Frage fragt eine sehr ähnliche Frage. Meine Frage hat jedoch einen subtilen Unterschied.

Ich möchte wissen, ob es möglich ist, das colorPrimaryAttribut eines Themas programmgesteuert in eine beliebige Farbe zu ändern .

So haben wir zum Beispiel:

<style name="AppTheme" parent="android:Theme.Material.Light">
    <item name="android:colorPrimary">#ff0000</item>
    <item name="android:colorAccent">#ff0000</item>
</style>

Zur Laufzeit entscheidet der Benutzer, dass er #ccffffals Primärfarbe verwenden möchte . Natürlich kann ich auf keinen Fall Themen für alle möglichen Farben erstellen.

Es macht mir nichts aus, wenn ich hackige Dinge tun muss, wie mich auf die privaten Interna von Android zu verlassen, solange es mit dem öffentlichen SDK funktioniert.

Mein Ziel ist es schließlich , die haben ActionBar und alle Widgets wie eine CheckBoxdieser Primärfarbe zu verwenden.

Themen sind unveränderlich, können Sie nicht.

Ich habe die Kommentare zur Kontakt-App gelesen und wie sie für jeden Kontakt ein Thema verwendet.

Wahrscheinlich hat die Kontakt-App einige vordefinierte Themen (für jede Materialprimärfarbe von hier: http://www.google.com/design/spec/style/color.html ).

Sie können ein Thema vor der setContentView-Methode in der onCreate-Methode anwenden.

Dann kann die Kontakt-App jedem Benutzer zufällig ein Thema zuweisen.

Diese Methode ist:

setTheme(R.style.MyRandomTheme);

Diese Methode hat jedoch ein Problem, z. B. kann sie die Farbe der Symbolleiste, die Farbe des Bildlaufeffekts, die Farbe der Welligkeit usw. ändern, aber die Farbe der Statusleiste und der Navigationsleiste kann nicht geändert werden (wenn Sie sie auch ändern möchten).

Um dieses Problem zu lösen, können Sie die Methode vor und verwenden:

if (Build.VERSION.SDK_INT >= 21) {
        getWindow().setNavigationBarColor(getResources().getColor(R.color.md_red_500));
        getWindow().setStatusBarColor(getResources().getColor(R.color.md_red_700));
    }

Diese beiden Methoden ändern die Farbe der Navigations- und Statusleiste. Denken Sie daran, wenn Sie Ihre Navigationsleiste durchscheinend einstellen, können Sie ihre Farbe nicht ändern.

Dies sollte der endgültige Code sein:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setTheme(R.style.MyRandomTheme);
    if (Build.VERSION.SDK_INT >= 21) {
        getWindow().setNavigationBarColor(getResources().getColor(R.color.myrandomcolor1));
        getWindow().setStatusBarColor(getResources().getColor(R.color.myrandomcolor2));
    }
    setContentView(R.layout.activity_main);

}

Sie können einen Schalter verwenden und eine Zufallszahl generieren, um zufällige Themen zu verwenden, oder wie in der Kontakt-App ist jedem Kontakt wahrscheinlich eine vordefinierte Nummer zugeordnet.

Ein Beispiel für ein Thema:

<style name="MyRandomTheme" parent="Theme.AppCompat.NoActionBar">
    <!-- Customize your theme here. -->
    <item name="colorPrimary">@color/myrandomcolor1</item>
    <item name="colorPrimaryDark">@color/myrandomcolor2</item>
    <item name="android:navigationBarColor">@color/myrandomcolor1</item>
</style>

Entschuldigung für mein Englisch.

Mit Theme.applyStyle können Sie Ihr Thema zur Laufzeit ändern, indem Sie einen anderen Stil darauf anwenden.

Angenommen, Sie haben diese Stildefinitionen:

<style name="DefaultTheme" parent="Theme.AppCompat.Light">
    <item name="colorPrimary">@color/md_lime_500</item>
    <item name="colorPrimaryDark">@color/md_lime_700</item>
    <item name="colorAccent">@color/md_amber_A400</item>
</style>

<style name="OverlayPrimaryColorRed">
    <item name="colorPrimary">@color/md_red_500</item>
    <item name="colorPrimaryDark">@color/md_red_700</item>
</style>

<style name="OverlayPrimaryColorGreen">
    <item name="colorPrimary">@color/md_green_500</item>
    <item name="colorPrimaryDark">@color/md_green_700</item>
</style>

<style name="OverlayPrimaryColorBlue">
    <item name="colorPrimary">@color/md_blue_500</item>
    <item name="colorPrimaryDark">@color/md_blue_700</item>
</style>

Jetzt können Sie Ihr Thema zur Laufzeit wie folgt patchen:

getTheme().applyStyle(R.style.OverlayPrimaryColorGreen, true);

Die Methode applyStylemuss aufgerufen werden, bevor das Layout aufgeblasen wird! Wenn Sie die Ansicht nicht manuell laden, sollten Sie dem Thema Stile zuweisen, bevor Sie setContentViewIhre Aktivität aufrufen .

Dies kann natürlich nicht verwendet werden, um eine beliebige Farbe anzugeben, dh eine von 16 Millionen (256 ³ ) Farben. Wenn Sie jedoch ein kleines Programm schreiben, das die Stildefinitionen und den Java-Code für Sie generiert, sollte so etwas wie eines von 512 (8 ³ ) möglich sein.

Was dies interessant macht, ist, dass Sie verschiedene Stilüberlagerungen für verschiedene Aspekte Ihres Themas verwenden können. Fügen Sie colorAccentzum Beispiel einfach einige Overlay-Definitionen hinzu . Jetzt können Sie verschiedene Werte für Primärfarbe und Akzentfarbe fast willkürlich kombinieren .

Sie sollten sicherstellen, dass Ihre Overlay-Designdefinitionen nicht versehentlich eine Reihe von Stildefinitionen von einer übergeordneten Stildefinition erben. Beispielsweise AppTheme.OverlayRederbt ein Stil, der implizit aufgerufen wird, alle in definierten Stile, AppThemeund alle diese Definitionen werden auch angewendet, wenn Sie das Masterthema patchen. Vermeiden Sie also entweder Punkte in den Namen der Overlay-Themen oder verwenden Sie so etwas wie Overlay.Redund definieren Sie es Overlayals leeren Stil.

Ich habe eine Lösung erstellt, um beliebige Farbthemen zu erstellen. Vielleicht kann dies für jemanden nützlich sein. API 9+

1. Erstellen Sie zuerst " res / values-v9 / " und legen Sie dort die folgende Datei ab: styles.xml und der reguläre Ordner "res / values" werden für Ihre Stile verwendet.

2. Fügen Sie diesen Code in Ihre Datei res / values ​​/ styles.xml ein:

<resources>
    <style name="AppTheme" parent="Theme.AppCompat.Light">
        <item name="colorPrimary">#000</item>
        <item name="colorPrimaryDark">#000</item>
        <item name="colorAccent">#000</item>
        <item name="android:windowAnimationStyle">@style/WindowAnimationTransition</item>
    </style>

    <style name="AppThemeDarkActionBar" parent="Theme.AppCompat.Light.DarkActionBar">
        <item name="colorPrimary">#000</item>
        <item name="colorPrimaryDark">#000</item>
        <item name="colorAccent">#000</item>
        <item name="android:windowAnimationStyle">@style/WindowAnimationTransition</item>
    </style>

    <style name="WindowAnimationTransition">
        <item name="android:windowEnterAnimation">@android:anim/fade_in</item>
        <item name="android:windowExitAnimation">@android:anim/fade_out</item>
    </style>
</resources>

3. in AndroidManifest:

<application android:theme="@style/AppThemeDarkActionBar">

4. Erstellen Sie eine neue Klasse mit dem Namen "ThemeColors.java".

public class ThemeColors {

    private static final String NAME = "ThemeColors", KEY = "color";

    @ColorInt
    public int color;

    public ThemeColors(Context context) {
        SharedPreferences sharedPreferences = context.getSharedPreferences(NAME, Context.MODE_PRIVATE);
        String stringColor = sharedPreferences.getString(KEY, "004bff");
        color = Color.parseColor("#" + stringColor);

        if (isLightActionBar()) context.setTheme(R.style.AppTheme);
        context.setTheme(context.getResources().getIdentifier("T_" + stringColor, "style", context.getPackageName()));
    }

    public static void setNewThemeColor(Activity activity, int red, int green, int blue) {
        int colorStep = 15;
        red = Math.round(red / colorStep) * colorStep;
        green = Math.round(green / colorStep) * colorStep;
        blue = Math.round(blue / colorStep) * colorStep;

        String stringColor = Integer.toHexString(Color.rgb(red, green, blue)).substring(2);
        SharedPreferences.Editor editor = activity.getSharedPreferences(NAME, Context.MODE_PRIVATE).edit();
        editor.putString(KEY, stringColor);
        editor.apply();

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) activity.recreate();
        else {
            Intent i = activity.getPackageManager().getLaunchIntentForPackage(activity.getPackageName());
            i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            activity.startActivity(i);
        }
    }

    private boolean isLightActionBar() {// Checking if title text color will be black
        int rgb = (Color.red(color) + Color.green(color) + Color.blue(color)) / 3;
        return rgb > 210;
    }
}

5. Hauptaktivität:

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new ThemeColors(this);
        setContentView(R.layout.activity_main);
    }

    public void buttonClick(View view){
        int red= new Random().nextInt(255);
        int green= new Random().nextInt(255);
        int blue= new Random().nextInt(255);
        ThemeColors.setNewThemeColor(MainActivity.this, red, green, blue);
    }
}

Um die Farbe zu ändern, ersetzen Sie einfach Random durch Ihr RGB. Ich hoffe, dies hilft.

Es gibt ein vollständiges Beispiel: ColorTest.zip

Ich habe den Dahnark-Code verwendet, muss aber auch den ToolBar-Hintergrund ändern:

if (dark_ui) {
    this.setTheme(R.style.Theme_Dark);

    if (Build.VERSION.SDK_INT >= 21) {
        getWindow().setNavigationBarColor(getResources().getColor(R.color.Theme_Dark_primary));
        getWindow().setStatusBarColor(getResources().getColor(R.color.Theme_Dark_primary_dark));
    }
} else {
    this.setTheme(R.style.Theme_Light);
}

setContentView(R.layout.activity_main);

toolbar = (Toolbar) findViewById(R.id.app_bar);

if(dark_ui) {
    toolbar.setBackgroundColor(getResources().getColor(R.color.Theme_Dark_primary));
}

Sie können die Farbe von colorPrimary nicht ändern, aber Sie können das Thema Ihrer Anwendung ändern, indem Sie einen neuen Stil mit einer anderen colorPrimary-Farbe hinzufügen

<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
    <!-- Customize your theme here. -->
    <item name="colorPrimary">@color/colorPrimary</item>
    <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
</style>

<style name="AppTheme.NewTheme" parent="Theme.AppCompat.Light.NoActionBar">
    <item name="colorPrimary">@color/colorOne</item>
    <item name="colorPrimaryDark">@color/colorOneDark</item>
</style>

und innerhalb des Aktivitätsset-Themas

 setTheme(R.style.AppTheme_NewTheme);
 setContentView(R.layout.activity_main);

von einer Aktivität, die Sie ausführen können:

getWindow().setStatusBarColor(i color);

BENUTZEN SIE EINE WERKZEUGLEISTE

Sie können eine benutzerdefinierte Symbolleistenelementfarbe dynamisch festlegen, indem Sie eine benutzerdefinierte Symbolleistenklasse erstellen:

package view;

import android.app.Activity;
import android.content.Context;
import android.graphics.ColorFilter;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffColorFilter;
import android.support.v7.internal.view.menu.ActionMenuItemView;
import android.support.v7.widget.ActionMenuView;
import android.support.v7.widget.Toolbar;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AutoCompleteTextView;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.TextView;

public class CustomToolbar extends Toolbar{

    public CustomToolbar(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // TODO Auto-generated constructor stub
    }

    public CustomToolbar(Context context, AttributeSet attrs) {
        super(context, attrs);
        // TODO Auto-generated constructor stub
    }

    public CustomToolbar(Context context) {
        super(context);
        // TODO Auto-generated constructor stub
        ctxt = context;
    }

    int itemColor;
    Context ctxt;

    @Override 
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        Log.d("LL", "onLayout");
        super.onLayout(changed, l, t, r, b);
        colorizeToolbar(this, itemColor, (Activity) ctxt);
    } 

    public void setItemColor(int color){
        itemColor = color;
        colorizeToolbar(this, itemColor, (Activity) ctxt);
    }



    /**
     * Use this method to colorize toolbar icons to the desired target color
     * @param toolbarView toolbar view being colored
     * @param toolbarIconsColor the target color of toolbar icons
     * @param activity reference to activity needed to register observers
     */
    public static void colorizeToolbar(Toolbar toolbarView, int toolbarIconsColor, Activity activity) {
        final PorterDuffColorFilter colorFilter
                = new PorterDuffColorFilter(toolbarIconsColor, PorterDuff.Mode.SRC_IN);

        for(int i = 0; i < toolbarView.getChildCount(); i++) {
            final View v = toolbarView.getChildAt(i);

            doColorizing(v, colorFilter, toolbarIconsColor);
        }

      //Step 3: Changing the color of title and subtitle.
        toolbarView.setTitleTextColor(toolbarIconsColor);
        toolbarView.setSubtitleTextColor(toolbarIconsColor);
    }

    public static void doColorizing(View v, final ColorFilter colorFilter, int toolbarIconsColor){
        if(v instanceof ImageButton) {
            ((ImageButton)v).getDrawable().setAlpha(255);
            ((ImageButton)v).getDrawable().setColorFilter(colorFilter);
        }

        if(v instanceof ImageView) {
            ((ImageView)v).getDrawable().setAlpha(255);
            ((ImageView)v).getDrawable().setColorFilter(colorFilter);
        }

        if(v instanceof AutoCompleteTextView) {
            ((AutoCompleteTextView)v).setTextColor(toolbarIconsColor);
        }

        if(v instanceof TextView) {
            ((TextView)v).setTextColor(toolbarIconsColor);
        }

        if(v instanceof EditText) {
            ((EditText)v).setTextColor(toolbarIconsColor);
        }

        if (v instanceof ViewGroup){
            for (int lli =0; lli< ((ViewGroup)v).getChildCount(); lli ++){
                doColorizing(((ViewGroup)v).getChildAt(lli), colorFilter, toolbarIconsColor);
            }
        }

        if(v instanceof ActionMenuView) {
            for(int j = 0; j < ((ActionMenuView)v).getChildCount(); j++) {

                //Step 2: Changing the color of any ActionMenuViews - icons that
                //are not back button, nor text, nor overflow menu icon.
                final View innerView = ((ActionMenuView)v).getChildAt(j);

                if(innerView instanceof ActionMenuItemView) {
                    int drawablesCount = ((ActionMenuItemView)innerView).getCompoundDrawables().length;
                    for(int k = 0; k < drawablesCount; k++) {
                        if(((ActionMenuItemView)innerView).getCompoundDrawables()[k] != null) {
                            final int finalK = k;

                            //Important to set the color filter in seperate thread, 
                            //by adding it to the message queue
                            //Won't work otherwise. 
                            //Works fine for my case but needs more testing

                            ((ActionMenuItemView) innerView).getCompoundDrawables()[finalK].setColorFilter(colorFilter);

//                              innerView.post(new Runnable() {
//                                  @Override
//                                  public void run() {
//                                      ((ActionMenuItemView) innerView).getCompoundDrawables()[finalK].setColorFilter(colorFilter);
//                                  }
//                              });
                        }
                    }
                }
            }
        }
    }



}

Beziehen Sie sich dann in Ihrer Layoutdatei darauf. Jetzt können Sie mit eine benutzerdefinierte Farbe festlegen

toolbar.setItemColor(Color.Red);

Quellen:

Die Informationen dazu finden Sie hier: So ändern Sie dynamisch die Farbe der Android-Symbolleistensymbole

und dann habe ich es bearbeitet, verbessert und hier gepostet: GitHub: AndroidDynamicToolbarItemColor

Folgendes können Sie tun:

Schreiben Sie eine Datei in einen zeichnbaren Ordner und nennen Sie sie background.xml

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android" >
    <solid android:color="?attr/colorPrimary"/>
</shape>

Stellen Sie dann Ihr Layout ein (oder was auch immer der Fall ist) android:background="@drawable/background"

Beim Festlegen Ihres Themas würde diese Farbe dieselbe darstellen.