Wie ändere ich die Farben eines Drawable in Android?

Ich arbeite an einer Android-Anwendung und habe eine Zeichnung, die ich von einem Quellbild lade. Auf diesem Bild möchte ich alle weißen Pixel in eine andere Farbe konvertieren, z. B. Blau, und dann das resultierende zeichnbare Objekt zwischenspeichern, damit ich es später verwenden kann.

Angenommen, ich habe eine 20x20-PNG-Datei mit einem weißen Kreis in der Mitte und alles außerhalb des Kreises ist transparent. Was ist der beste Weg, um diesen weißen Kreis blau zu machen und die Ergebnisse zwischenzuspeichern? Ändert sich die Antwort, wenn ich dieses Quellbild verwenden möchte, um mehrere neue Drawables zu erstellen (z. B. blau, rot, grün, orange usw.)?

Ich vermute, dass ich eine ColorMatrix irgendwie verwenden möchte, bin mir aber nicht sicher, wie.

Ich denke, Sie können tatsächlich nur verwenden Drawable.setColorFilter( 0xffff0000, Mode.MULTIPLY ). Dies würde weiße Pixel auf Rot setzen, aber ich glaube nicht, dass dies die transparenten Pixel beeinflussen würde.

Siehe Drawable # setColorFilter

Probieren Sie diesen Code aus:

ImageView lineColorCode = (ImageView)convertView.findViewById(R.id.line_color_code);
int color = Color.parseColor("#AE6118"); //The color u want             
lineColorCode.setColorFilter(color);

Ich weiß, dass diese Frage schon lange vor Lollipop gestellt wurde, aber ich möchte eine nette Möglichkeit hinzufügen, dies auf Android 5. + zu tun. Sie machen eine XML-Zeichnung, die auf die ursprüngliche verweist, und setzen die Farbe wie folgt darauf:

<?xml version="1.0" encoding="utf-8"?>
<bitmap
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:src="@drawable/ic_back"
    android:tint="@color/red_tint"/>

Die neue Unterstützung v4 bringt den Farbton zurück zu API 4.

Sie können es so machen

public static Drawable setTint(Drawable d, int color) {
    Drawable wrappedDrawable = DrawableCompat.wrap(d);
    DrawableCompat.setTint(wrappedDrawable, color);
    return wrappedDrawable;
}

Wenn Sie eine Zeichenfläche haben, die einfarbig ist, und Sie sie in eine andere einfarbige Farbe ändern möchten, können Sie eine verwenden ColorMatrixColorFilter. Die Transparenz bleibt erhalten.

int iColor = Color.parseColor(color);

int red   = (iColor & 0xFF0000) / 0xFFFF;
int green = (iColor & 0xFF00) / 0xFF;
int blue  = iColor & 0xFF;

float[] matrix = { 0, 0, 0, 0, red,
                   0, 0, 0, 0, green,
                   0, 0, 0, 0, blue,
                   0, 0, 0, 1, 0 };

ColorFilter colorFilter = new ColorMatrixColorFilter(matrix);
drawable.setColorFilter(colorFilter);

Ich benutze auch ImageViewfür Symbole (im ListViewoder Einstellungsbildschirm). Aber ich denke, es gibt einen viel einfacheren Weg, das zu tun.

Verwenden Sie tintdiese Option , um die Farbüberlagerung für das ausgewählte Symbol zu ändern.

In XML,

android:tint="@color/accent"
android:src="@drawable/ic_event" 

funktioniert gut, da es von kommt AppCompat

Sie sollten dies für alle APIs tun:

Drawable myIcon = getResources().getDrawable( R.drawable.button ); 
ColorFilter filter = new LightingColorFilter( Color.BLACK, Color.BLACK);
myIcon.setColorFilter(filter);

Ich konnte dies mit dem folgenden Code tun, der aus einer Aktivität stammt (das Layout ist sehr einfach, enthält nur eine ImageView und wird hier nicht veröffentlicht).

private static final int[] FROM_COLOR = new int[]{49, 179, 110};
private static final int THRESHOLD = 3;

public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.test_colors);

    ImageView iv = (ImageView) findViewById(R.id.img);
    Drawable d = getResources().getDrawable(RES);
    iv.setImageDrawable(adjust(d));
}

private Drawable adjust(Drawable d)
{
    int to = Color.RED;

    //Need to copy to ensure that the bitmap is mutable.
    Bitmap src = ((BitmapDrawable) d).getBitmap();
    Bitmap bitmap = src.copy(Bitmap.Config.ARGB_8888, true);
    for(int x = 0;x < bitmap.getWidth();x++)
        for(int y = 0;y < bitmap.getHeight();y++)
            if(match(bitmap.getPixel(x, y))) 
                bitmap.setPixel(x, y, to);

    return new BitmapDrawable(bitmap);
}

private boolean match(int pixel)
{
    //There may be a better way to match, but I wanted to do a comparison ignoring
    //transparency, so I couldn't just do a direct integer compare.
    return Math.abs(Color.red(pixel) - FROM_COLOR[0]) < THRESHOLD &&
        Math.abs(Color.green(pixel) - FROM_COLOR[1]) < THRESHOLD &&
        Math.abs(Color.blue(pixel) - FROM_COLOR[2]) < THRESHOLD;
}

Sie können es mit kompatiblen Bibliotheken für Android-Unterstützung lösen. :) :)

 // mutate to not share its state with any other drawable
 Drawable drawableWrap = DrawableCompat.wrap(drawable).mutate();
 DrawableCompat.setTint(drawableWrap, ContextCompat.getColor(getContext(), R.color.your_color))

In Ihrer Aktivität können Sie Ihre PNG-Bildressourcen mit einer einzigen Farbe tönen:

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    myColorTint();
    setContentView(R.layout.activity_main);
}

private void myColorTint() {
    int tint = Color.parseColor("#0000FF"); // R.color.blue;
    PorterDuff.Mode mode = PorterDuff.Mode.SRC_ATOP;
    // add your drawable resources you wish to tint to the drawables array...
    int drawables[] = { R.drawable.ic_action_edit, R.drawable.ic_action_refresh };
    for (int id : drawables) {
        Drawable icon = getResources().getDrawable(id);
        icon.setColorFilter(tint,mode);
    }
}

Wenn Sie jetzt das R.drawable. * Verwenden, sollte es mit dem gewünschten Farbton gefärbt sein. Wenn Sie zusätzliche Farben benötigen, sollten Sie in der Lage sein, das Zeichenobjekt zu mutieren ().

view.getDrawable().mutate().setColorFilter(0xff777777, PorterDuff.Mode.MULTIPLY); 

Danke an @sabadow

Wenn Sie Ihr Drawable auf ImageView eingestellt haben, können Sie dies mit einem 1-Liner tun:

yourImageView.setColorFilter(context.getResources().getColor(R.color.YOUR_COLOR_HERE);

Schauen Sie sich diesen Beispielcode " ColorMatrixSample.java " an.

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.android.apis.graphics;

import com.example.android.apis.R;

import android.app.Activity;
import android.content.Context;
import android.graphics.*;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.View;

public class ColorMatrixSample extends GraphicsActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new SampleView(this));
    }

    private static class SampleView extends View {
        private Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        private ColorMatrix mCM = new ColorMatrix();
        private Bitmap mBitmap;
        private float mSaturation;
        private float mAngle;

        public SampleView(Context context) {
            super(context);

            mBitmap = BitmapFactory.decodeResource(context.getResources(),
                                                   R.drawable.balloons);
        }

        private static void setTranslate(ColorMatrix cm, float dr, float dg,
                                         float db, float da) {
            cm.set(new float[] {
                   2, 0, 0, 0, dr,
                   0, 2, 0, 0, dg,
                   0, 0, 2, 0, db,
                   0, 0, 0, 1, da });
        }

        private static void setContrast(ColorMatrix cm, float contrast) {
            float scale = contrast + 1.f;
               float translate = (-.5f * scale + .5f) * 255.f;
            cm.set(new float[] {
                   scale, 0, 0, 0, translate,
                   0, scale, 0, 0, translate,
                   0, 0, scale, 0, translate,
                   0, 0, 0, 1, 0 });
        }

        private static void setContrastTranslateOnly(ColorMatrix cm, float contrast) {
            float scale = contrast + 1.f;
               float translate = (-.5f * scale + .5f) * 255.f;
            cm.set(new float[] {
                   1, 0, 0, 0, translate,
                   0, 1, 0, 0, translate,
                   0, 0, 1, 0, translate,
                   0, 0, 0, 1, 0 });
        }

        private static void setContrastScaleOnly(ColorMatrix cm, float contrast) {
            float scale = contrast + 1.f;
               float translate = (-.5f * scale + .5f) * 255.f;
            cm.set(new float[] {
                   scale, 0, 0, 0, 0,
                   0, scale, 0, 0, 0,
                   0, 0, scale, 0, 0,
                   0, 0, 0, 1, 0 });
        }

        @Override protected void onDraw(Canvas canvas) {
            Paint paint = mPaint;
            float x = 20;
            float y = 20;

            canvas.drawColor(Color.WHITE);

            paint.setColorFilter(null);
            canvas.drawBitmap(mBitmap, x, y, paint);

            ColorMatrix cm = new ColorMatrix();

            mAngle += 2;
            if (mAngle > 180) {
                mAngle = 0;
            }

            //convert our animated angle [-180...180] to a contrast value of [-1..1]
            float contrast = mAngle / 180.f;

            setContrast(cm, contrast);
            paint.setColorFilter(new ColorMatrixColorFilter(cm));
            canvas.drawBitmap(mBitmap, x + mBitmap.getWidth() + 10, y, paint);

            setContrastScaleOnly(cm, contrast);
            paint.setColorFilter(new ColorMatrixColorFilter(cm));
            canvas.drawBitmap(mBitmap, x, y + mBitmap.getHeight() + 10, paint);

            setContrastTranslateOnly(cm, contrast);
            paint.setColorFilter(new ColorMatrixColorFilter(cm));
            canvas.drawBitmap(mBitmap, x, y + 2*(mBitmap.getHeight() + 10),
                              paint);

            invalidate();
        }
    }
}

Die entsprechende API finden Sie hier :

Dies funktioniert mit allem mit Hintergrund:

Textansicht, Button ...

TextView text = (TextView) View.findViewById(R.id.MyText);
text.setBackgroundResource(Icon);    
text.getBackground().setColorFilter(getResources().getColor(Color), PorterDuff.Mode.SRC_ATOP);

Dieses Code-Snippet hat bei mir funktioniert:

PorterDuffColorFilter porterDuffColorFilter = new PorterDuffColorFilter(getResources().getColor(R.color.your_color),PorterDuff.Mode.MULTIPLY);

imgView.getDrawable().setColorFilter(porterDuffColorFilter);
imgView.setBackgroundColor(Color.TRANSPARENT)

Es gibt so viele Lösungen, aber niemand hat vorgeschlagen, wenn die XML- Datei der Farbressource bereits Farbe hat, können wir direkt von dort auch wie folgt auswählen:

ImageView imageView = (ImageView) findViewById(R.id.imageview);
imageView.setColorFilter(getString(R.color.your_color));

Kurzes Beispiel zum Ändern der Zeichenfarbe je nach isWorkingFeld.

Meine Form xml:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android" >
    <solid android:color="@android:color/holo_blue_bright" />
    <corners android:radius="30dp" />
    <size
        android:height="15dp"
        android:width="15dp" />
</shape>

Meine Methode zu ändern:

private Drawable getColoredDrawable(int drawableResId, boolean isworking) {
    Drawable d = getResources().getDrawable(R.drawable.shape);
    ColorFilter filter = new LightingColorFilter(
            isworking ? Color.GREEN : Color.RED,
            isworking ? Color.GREEN : Color.RED);
    d.setColorFilter(filter);
    return d;
}

Anwendungsbeispiel:

text1.setCompoundDrawablesWithIntrinsicBounds(getColoredDrawable(R.drawable.shape, isworking()), null, null, null);

Int color = Color.GRAY; 
// or int color = Color.argb(123,255,0,5);
// or int color = 0xaaff000;

in XML /res/values/color.xml

<?xml version="1.0" encoding="utf-8">
<resources>
    <color name="colorRed">#ff0000</color>
</resoures> 

Java Code

int color = ContextCompat.getColor(context, R.color.colorRed);

GradientDrawable drawableBg = yourView.getBackground().mutate();
drawableBg.setColor(color);

Zu spät, aber falls jemand es braucht:

   fun setDrawableColor(drawable: Drawable, color: Int) :Drawable {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            drawable.colorFilter = BlendModeColorFilter(color, BlendMode.SRC_ATOP)
            return drawable
        } else {
            drawable.setColorFilter(color, PorterDuff.Mode.SRC_ATOP)
            return drawable
        }
    }

Es funktioniert für einige einfache Drawables. Ich habe es auf einer einfachen einfarbigen, geraden Form mit abgerundeten Ecken verwendet und musste diese Farbe mit verschiedenen Layouts ändern.

Versuche dies

android:backgroundTint="#101010"

Es ist sehr, sehr einfach, wenn Sie eine Bibliothek verwenden, um dies für Sie zu tun. Versuche dies Bibliothek aus

Sie können so anrufen:

Icon.on(holderView).color(R.color.your_color).icon(R.mipmap.your_icon).put();