Jak _ naprawdę_ programowo zmienić kolor podstawowy i akcentujący w Android Lollipop?

Przede wszystkim to pytanie stawia bardzo podobne pytanie. Jednak moje pytanie ma subtelną różnicę.

Chciałabym wiedzieć, czy można programowo zmienić colorPrimaryatrybut motywu na dowolny kolor?

Na przykład mamy:

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

W czasie wykonywania użytkownik decyduje, że chce użyć #ccffffkoloru podstawowego. Oczywiście nie ma możliwości tworzenia motywów dla wszystkich możliwych kolorów.

Nie mam nic przeciwko temu, że muszę robić hakerskie rzeczy, takie jak poleganie na prywatnych wewnętrznych elementach Androida, o ile działa on przy użyciu publicznego SDK.

Moim celem jest, aby w końcu mieć ActionBar i wszystkie widżety, jak CheckBoxkorzystać z tego koloru podstawowego.

Motywy są niezmienne, nie możesz.

Czytałem komentarze na temat aplikacji kontaktów i tego, jak używa ona motywu dla każdego kontaktu.

Prawdopodobnie aplikacja do kontaktów ma pewne predefiniowane motywy (dla każdego koloru podstawowego z tego materiału: http://www.google.com/design/spec/style/color.html ).

Motyw można zastosować przed metodą setContentView w metodzie onCreate.

Następnie aplikacja do kontaktów może losowo zastosować motyw dla każdego użytkownika.

Ta metoda to:

setTheme(R.style.MyRandomTheme);

Ale ta metoda ma problem, na przykład może zmienić kolor paska narzędzi, kolor efektu przewijania, kolor tętnienia itp., Ale nie może zmienić koloru paska stanu i koloru paska nawigacji (jeśli chcesz go również zmienić).

Następnie, aby rozwiązać ten problem, możesz użyć metody przed i:

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

Te dwie metody zmieniają kolor paska nawigacji i stanu. Pamiętaj, że jeśli ustawisz pasek nawigacji jako półprzezroczysty, nie możesz zmienić jego koloru.

To powinien być ostateczny kod:

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

}

Możesz użyć przełącznika i wygenerować losową liczbę, aby użyć losowych motywów lub, tak jak w aplikacji kontaktów, każdy kontakt prawdopodobnie ma przypisany wstępnie zdefiniowany numer.

Próbka motywu:

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

Przepraszam za mój angielski.

Możesz użyć Theme.applyStyle, aby zmodyfikować swój motyw w czasie wykonywania, stosując do niego inny styl.

Załóżmy, że masz te definicje stylu:

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

Teraz możesz załatać swój motyw w czasie wykonywania, na przykład:

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

Metoda applyStylemusi zostać wywołana, zanim układ zostanie zawyżony! Jeśli więc nie załadujesz widoku ręcznie, powinieneś zastosować style do motywu przed wywołaniem setContentViewdziałania.

Oczywiście nie można tego użyć do określenia dowolnego koloru, tj. Jednego z 16 milionów (256 ³ ) kolorów. Ale jeśli napiszesz mały program, który generuje dla ciebie definicje stylów i kod Javy, to coś w rodzaju jednego z 512 (8 ³ powinno być możliwe ).

To, co sprawia, że ​​jest to interesujące, to fakt, że możesz używać różnych nakładek stylu dla różnych aspektów motywu. Po prostu dodaj na przykład kilka definicji nakładek colorAccent. Teraz możesz niemal dowolnie łączyć różne wartości koloru podstawowego i koloru akcentującego .

Należy się upewnić, że definicje motywów nakładek nie dziedziczą przypadkowo wielu definicji stylów z definicji stylu nadrzędnego. Na przykład styl o nazwie AppTheme.OverlayRedniejawnie dziedziczy wszystkie style zdefiniowane w programie, AppThemea wszystkie te definicje zostaną również zastosowane podczas łatania motywu głównego. Więc albo unikaj kropek w nazwach motywów nakładki, albo użyj czegoś podobnego Overlay.Redi zdefiniuj Overlayjako pusty styl.

Stworzyłem rozwiązanie do tworzenia motywów w dowolnym kolorze, może to się komuś przyda. API 9+

1. Najpierw utwórz " res / values-v9 / " i umieść tam ten plik: styles.xml i zwykły folder "res / values" będą używane z Twoimi stylami.

2. Umieść ten kod w swoim res / values ​​/ styles.xml:

<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. w AndroidManifest:

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

4. utwórz nową klasę o nazwie „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. MainActivity:

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

Aby zmienić kolor, po prostu zastąp Random swoim RGB, mam nadzieję, że to pomoże.

Oto pełny przykład: ColorTest.zip

Użyłem kodu Dahnark, ale muszę też zmienić tło ToolBar:

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

Nie możesz zmienićkoloru colorPrimary, ale możesz zmienić motyw swojej aplikacji, dodając nowy styl z innym koloremKolor podstawowy

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

i wewnątrz motywu zestawu czynności

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

z aktywności, którą możesz wykonać:

getWindow().setStatusBarColor(i color);

UŻYJ PASKA NARZĘDZIOWEGO

Możesz ustawić niestandardowy pasek narzędzi dynamicznie kolor elementu tworząc niestandardową klasę paska narzędzi:

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



}

następnie odwołaj się do tego w pliku układu. Teraz możesz ustawić własny kolor za pomocą

toolbar.setItemColor(Color.Red);

Źródła:

Informacje, jak to zrobić, znalazłem tutaj: Jak dynamicznie zmieniać kolor ikon paska narzędzi Android

a potem go wyedytowałem, poprawiłem i opublikowałem tutaj: GitHub: AndroidDynamicToolbarItemColor

Oto, co MOŻESZ zrobić:

napisz plik w folderze do rysowania, nazwijmy go 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>

następnie ustaw swój układ (lub cokolwiek tak jest) android:background="@drawable/background"

przy ustawianiu motywu ten kolor będzie reprezentował to samo.