Come _really_ modificare a livello di codice il colore primario e d'accento in Android Lollipop?

Prima di tutto, questa domanda pone una domanda molto simile. Tuttavia, la mia domanda ha una sottile differenza.

Quello che mi piacerebbe sapere è se è possibile modificare a livello di colorPrimarycodice l' attributo di un tema in un colore arbitrario ?

Quindi, ad esempio, abbiamo:

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

In fase di esecuzione, l'utente decide di voler utilizzare #ccffffcome colore primario. Ovviamente non è possibile creare temi per tutti i colori possibili.

Non mi importa se devo fare cose complicate, come fare affidamento sugli interni privati ​​di Android, purché funzioni usando l'SDK pubblico.

Il mio obiettivo è quello di avere finalmente le ActionBar e tutti i widget come una CheckBoxdi utilizzare questo colore primario.

I temi sono immutabili, non puoi.

Ho letto i commenti sull'app dei contatti e su come utilizzare un tema per ciascun contatto.

Probabilmente, l'app dei contatti ha alcuni temi predefiniti (per ogni colore primario del materiale da qui: http://www.google.com/design/spec/style/color.html ).

È possibile applicare un tema prima di un metodo setContentView all'interno del metodo onCreate.

Quindi l'app dei contatti può applicare un tema in modo casuale a ciascun utente.

Questo metodo è:

setTheme(R.style.MyRandomTheme);

Ma questo metodo ha un problema, ad esempio può cambiare il colore della barra degli strumenti, il colore dell'effetto di scorrimento, il colore dell'ondulazione, ecc., Ma non può cambiare il colore della barra di stato e il colore della barra di navigazione (se si desidera cambiarlo anche).

Quindi, per risolvere questo problema, è possibile utilizzare il metodo prima e:

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

Questi due metodi cambiano il colore della barra di stato e di navigazione. Ricorda, se imposti la tua barra di navigazione in modo traslucido, non puoi cambiarne il colore.

Questo dovrebbe essere il codice finale:

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

}

Puoi usare un interruttore e generare un numero casuale per usare temi casuali o, come nell'app dei contatti, probabilmente a ciascun contatto è associato un numero predefinito.

Un esempio di tema:

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

Mi scusi per il mio inglese.

Puoi usare Theme.applyStyle per modificare il tema in fase di esecuzione applicando un altro stile ad esso.

Supponiamo che tu abbia queste definizioni di stile:

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

Ora puoi rattoppare il tuo tema in fase di esecuzione in questo modo:

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

Il metodo applyStyledeve essere chiamato prima che il layout venga gonfiato! Quindi, a meno che non carichi manualmente la vista, devi applicare gli stili al tema prima di chiamare la setContentViewtua attività.

Naturalmente questo non può essere usato per specificare un colore arbitrario, cioè uno su 16 milioni (256 ³ ) di colori. Ma se scrivi un piccolo programma che genera le definizioni di stile e il codice Java per te, dovrebbe essere possibile qualcosa come uno su 512 (8 ³ ).

Ciò che rende questo interessante è che puoi usare sovrapposizioni di stili diversi per diversi aspetti del tuo tema. colorAccentPer esempio, aggiungi solo alcune definizioni di overlay . Ora puoi combinare valori diversi per il colore primario e il colore accento quasi arbitrariamente.

È necessario assicurarsi che le definizioni del tema di overlay non ereditino accidentalmente un gruppo di definizioni di stile da una definizione di stile padre. Ad esempio uno stile chiamato AppTheme.OverlayRederedita implicitamente tutti gli stili definiti AppThemee tutte queste definizioni verranno applicate anche quando si applica la patch al tema principale. Quindi, evita i punti nei nomi dei temi di sovrapposizione o usa qualcosa di simile Overlay.Rede definisci Overlayuno stile vuoto.

Ho creato una soluzione per creare temi di qualsiasi colore, forse questo può essere utile per qualcuno. API 9+

1. prima crea " res / valori-v9 / " e inserisci qui questo file: styles.xml e la normale cartella "res / valori" verranno usate con i tuoi stili.

2. inserisci questo codice nel tuo res / valori / 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. in per AndroidManifest:

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

4. crea una nuova classe con il nome "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. Attività principale:

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

Per cambiare colore, basta sostituire Casuale con il tuo RGB, spero che questo ti aiuti.

C'è un esempio completo: ColorTest.zip

Ho usato il codice di Dahnark ma devo anche cambiare lo sfondo della barra degli strumenti:

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

Non puoi cambiare il colore di colorPrimary, ma puoi cambiare il tema della tua applicazione aggiungendo un nuovo stile con un colore diverso Colore primario

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

e all'interno del set di attività

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

da un'attività che puoi fare:

getWindow().setStatusBarColor(i color);

USA UNA BARRA DEGLI STRUMENTI

È possibile impostare dinamicamente un colore dell'elemento della barra degli strumenti personalizzato creando una classe barra degli strumenti personalizzata:

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



}

quindi fare riferimento ad esso nel file di layout. Ora puoi impostare un colore personalizzato usando

toolbar.setItemColor(Color.Red);

fonti:

Ho trovato le informazioni per farlo qui: Come cambiare dinamicamente il colore delle icone di Android Toolbar

e poi l'ho modificato, migliorato e pubblicato qui: GitHub: AndroidDynamicToolbarItemColor

Questo è quello che PUOI fare:

scrivere un file in una cartella disegnabile, chiamiamolo 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>

quindi imposta il layout (o qualunque sia il caso) android:background="@drawable/background"

impostando il tema questo colore rappresenterebbe lo stesso.