Ändern der EditText-Grundfarbe mit appcompat v7

Ich hatte das Gefühl, dass ich eine Antwort brauche, falls jemand nur einen einzigen Edittext ändern möchte. So mach ich es:

editText.getBackground().mutate().setColorFilter(getResources().getColor(R.color.your_color), PorterDuff.Mode.SRC_ATOP);

Obwohl Laurents Lösung korrekt ist, weist es einige Nachteile auf, wie in den Kommentaren beschrieben, da nicht nur die untere Zeile des EditText, sondern auch der Zurück-Button des Toolbar getönt wird. CheckBoxes usw. auch.

Zum Glück hat v22.1 von appcompat-v7 einige neue Möglichkeiten eingeführt. Jetzt ist es möglich, nur einer Ansicht ein bestimmtes Thema zuzuweisen. Direkt aus dem Changelog :

Veraltete Verwendung von app: theme zum Gestalten der Symbolleiste. Sie können jetzt Android: theme für Symbolleisten auf allen API-Geräten der Stufe 7 und höher und Android: theme Unterstützung für alle Widgets auf API-Geräten der Stufe 11 und höher.

Anstatt die gewünschte Farbe in einem globalen Design festzulegen, erstellen wir eine neue und weisen sie nur dem EditText zu.

Beispiel:

<style name="MyEditTextTheme">
    <!-- Used for the bottom line when not selected / focused -->
    <item name="colorControlNormal">#9e9e9e</item>
    <!-- colorControlActivated & colorControlHighlight use the colorAccent color by default -->
</style>

<EditText
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content"
    Android:theme="@style/MyEditTextTheme"/>

Als Referenz. Dies kann in XML folgendermaßen geändert werden:

Android:backgroundTint="@color/blue"

Aus Gründen der Abwärtskompatibilität verwenden Sie:

app:backgroundTint="@color/blue"

Hier ist die Lösung für API <21 und höher

Drawable drawable = yourEditText.getBackground(); // get current EditText drawable 
drawable.setColorFilter(Color.GREEN, PorterDuff.Mode.SRC_ATOP); // change the drawable color

if(Build.VERSION.SDK_INT > 16) {
    yourEditText.setBackground(drawable); // set the new drawable to EditText
}else{
    yourEditText.setBackgroundDrawable(drawable); // use setBackgroundDrawable because setBackground required API 16
}

Hoffe es hilft

Die akzeptierte Antwort ist ein bisschen mehr auf Stilbasis. Am effizientesten ist es jedoch, das Attribut colorAccent in Ihren AppTheme-Stil wie folgt einzufügen:

<style name="AppTheme.Base" parent="Theme.AppCompat.Light.NoActionBar">
        <item name="colorAccent">@color/colorAccent</item>
        <item name="Android:editTextStyle">@style/EditTextStyle</item>
</style>

<style name="EditTextStyle" parent="Widget.AppCompat.EditText"/>

Das colorAccent-Attribut wird für die Widget-Tönung in der gesamten App verwendet und sollte daher aus Gründen der Konsistenz verwendet werden

Wenn Sie appcompat-v7:22.1.0+ verwenden, können Sie die Widgets mit DrawableCompat tönen

    public static void tintWidget(View view, int color) {
        Drawable wrappedDrawable = DrawableCompat.wrap(view.getBackground());
        DrawableCompat.setTint(wrappedDrawable.mutate(), getResources().getColor(color));
        view.setBackgroundDrawable(wrappedDrawable);
    }

Verwenden:

<EditText
    app:backgroundTint="@color/blue"/>

Dies wird Pre-Lollipop-Geräte nicht nur +21 unterstützen

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

    <item name="colorControlNormal">@color/colorAccent</item>
    <item name="colorControlActivated">@color/colorAccent</item>
    <item name="colorControlHighlight">@color/colorAccent</item>

</style>

Eine schnelle Lösung für Ihr Problem besteht darin, in Ihrem Anwendungspaket/build/intermediates/exploded-aar/com.Android.support/appcompat-v7/res/drawable/nach abc_edit_text_material.xml zu suchen und diese XML-Datei in Ihren drawable-Ordner zu kopieren. Anschließend können Sie die Farbe der 9 Patch-Dateien in dieser Auswahl ändern, um sie Ihren Wünschen anzupassen.

Es ist sehr einfach, einfach das Android:backgroundTint Attribut in Ihr EditText einzufügen.

Android:backgroundTint="@color/blue"
Android:backgroundTint="#ffffff"
Android:backgroundTint="@color/red"


 <EditText
     Android:layout_width="match_parent"
     Android:layout_height="wrap_content"
     Android:backgroundTint="#ffffff"/>

Auch ich war zu lange mit diesem Problem beschäftigt.

Ich benötigte eine Lösung, die für Versionen über und unter v21 funktioniert.

Schließlich habe ich eine sehr einfache, vielleicht nicht ideale, aber effektive Lösung gefunden: Setzen Sie die Hintergrundfarbe in den EditText-Eigenschaften einfach auf transparent.

<EditText
    Android:background="@Android:color/transparent"/>

Ich hoffe das spart jemandem etwas Zeit.

Für mich habe ich sowohl das AppTheme als auch einen Wert colors.xml geändert. Sowohl colorControlNormal als auch colorAccent haben mir dabei geholfen, die Rahmenfarbe von EditText zu ändern. Sowie der Cursor und das "|" wenn in einem EditText.

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- Customize your theme here. -->
    <item name="colorControlNormal">@color/yellow</item>
    <item name="colorAccent">@color/yellow</item>
</style>

Hier ist die colors.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="yellow">#B7EC2A</color>
</resources>

Ich habe das Android: textCursorDrawable-Attribut für @null entfernt, das ich in den editText-Stil eingefügt habe. Wenn ich dies ausprobierte, änderten sich die Farben nicht.

Hier ist ein Teil des Quellcodes von TextInputLayout in der Support-Design-Bibliothek ( AKTUALISIERT für Version 23.2.0 ) , wodurch sich die Grundfarbe von EditText auf einfachere Weise ändert:

private void updateEditTextBackground() {
    ensureBackgroundDrawableStateWorkaround();

    final Drawable editTextBackground = mEditText.getBackground();
    if (editTextBackground == null) {
        return;
    }

    if (mErrorShown && mErrorView != null) {
        // Set a color filter of the error color
        editTextBackground.setColorFilter(
                AppCompatDrawableManager.getPorterDuffColorFilter(
                        mErrorView.getCurrentTextColor(), PorterDuff.Mode.SRC_IN));
    }
    ...
}

Es scheint, dass der gesamte obige Code in 23.2.0 jetzt unbrauchbar wird, wenn Sie die Farbe programmgesteuert ändern möchten.

Und wenn Sie alle Plattformen unterstützen möchten, ist hier meine Methode:

/**
 * Set backgroundTint to {@link View} across all targeting platform level.
 * @param view the {@link View} to tint.
 * @param color color used to tint.
 */
public static void tintView(View view, int color) {
    final Drawable d = view.getBackground();
    final Drawable nd = d.getConstantState().newDrawable();
    nd.setColorFilter(AppCompatDrawableManager.getPorterDuffColorFilter(
            color, PorterDuff.Mode.SRC_IN));
    view.setBackground(nd);
}

Sie können den Hintergrund von edittext auf ein Rechteck mit Minuspolstern links, rechts und oben einstellen, um dies zu erreichen. Hier ist das XML-Beispiel:

<layer-list xmlns:Android="http://schemas.Android.com/apk/res/Android">
    <item
        Android:top="-1dp"
        Android:left="-1dp"
        Android:right="-1dp"
        Android:bottom="1dp"
        >
        <shape Android:shape="rectangle">
            <stroke Android:width="1dp" Android:color="#6A9A3A"/>
        </shape>
    </item>
</layer-list>

Ersetzen Sie die Form durch eine Auswahl, wenn Sie für fokussierten Edittext eine andere Breite und Farbe festlegen möchten.

Ich benutze diese Methode, um die Farbe der Linie mit PorterDuff zu ändern.

public void changeBottomColorSearchView(int color) {
    int searchPlateId = mSearchView.getContext().getResources().getIdentifier("Android:id/search_plate", null, null);
    View searchPlate = mSearchView.findViewById(searchPlateId);
    searchPlate.getBackground().setColorFilter(color, PorterDuff.Mode.SRC_IN);
}

Ich habe nach 2 Tagen des Kampfes eine funktionierende Lösung für dieses Problem ausgearbeitet. Die folgende Lösung ist perfekt für diejenigen, die nur wenige bearbeitete Texte ändern, die Farbe durch Java Code ändern/umschalten und die Probleme überwinden möchten von unterschiedlichem Verhalten auf Betriebssystemversionen aufgrund der Verwendung der setColorFilter () -Methode.

    import Android.content.Context;
import Android.graphics.PorterDuff;
import Android.graphics.drawable.Drawable;
import Android.support.v4.content.ContextCompat;
import Android.support.v7.widget.AppCompatDrawableManager;
import Android.support.v7.widget.AppCompatEditText;
import Android.util.AttributeSet;
import com.newco.cooltv.R;

public class RqubeErrorEditText extends AppCompatEditText {

  private int errorUnderlineColor;
  private boolean isErrorStateEnabled;
  private boolean mHasReconstructedEditTextBackground;

  public RqubeErrorEditText(Context context) {
    super(context);
    initColors();
  }

  public RqubeErrorEditText(Context context, AttributeSet attrs) {
    super(context, attrs);
    initColors();
  }

  public RqubeErrorEditText(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    initColors();
  }

  private void initColors() {
    errorUnderlineColor = R.color.et_error_color_rule;

  }

  public void setErrorColor() {
    ensureBackgroundDrawableStateWorkaround();
    getBackground().setColorFilter(AppCompatDrawableManager.getPorterDuffColorFilter(
        ContextCompat.getColor(getContext(), errorUnderlineColor), PorterDuff.Mode.SRC_IN));
  }

  private void ensureBackgroundDrawableStateWorkaround() {
    final Drawable bg = getBackground();
    if (bg == null) {
      return;
    }
    if (!mHasReconstructedEditTextBackground) {
      // This is gross. There is an issue in the platform which affects container Drawables
      // where the first drawable retrieved from resources will propogate any changes
      // (like color filter) to all instances from the cache. We'll try to workaround it...
      final Drawable newBg = bg.getConstantState().newDrawable();
      //if (bg instanceof DrawableContainer) {
      //  // If we have a Drawable container, we can try and set it's constant state via
      //  // reflection from the new Drawable
      //  mHasReconstructedEditTextBackground =
      //      DrawableUtils.setContainerConstantState(
      //          (DrawableContainer) bg, newBg.getConstantState());
      //}
      if (!mHasReconstructedEditTextBackground) {
        // If we reach here then we just need to set a brand new instance of the Drawable
        // as the background. This has the unfortunate side-effect of wiping out any
        // user set padding, but I'd hope that use of custom padding on an EditText
        // is limited.
        setBackgroundDrawable(newBg);
        mHasReconstructedEditTextBackground = true;
      }
    }
  }

  public boolean isErrorStateEnabled() {
    return isErrorStateEnabled;
  }

  public void setErrorState(boolean isErrorStateEnabled) {
    this.isErrorStateEnabled = isErrorStateEnabled;
    if (isErrorStateEnabled) {
      setErrorColor();
      invalidate();
    } else {
      getBackground().mutate().clearColorFilter();
      invalidate();
    }
  }
}

Verwendet in XML

<com.rqube.ui.widget.RqubeErrorEditText
            Android:id="@+id/f_signup_et_referral_code"
            Android:layout_width="match_parent"
            Android:layout_height="wrap_content"
            Android:layout_alignParentTop="true"
            Android:layout_toEndOf="@+id/referral_iv"
            Android:layout_toRightOf="@+id/referral_iv"
            Android:ems="10"
            Android:hint="@string/lbl_referral_code"
            Android:imeOptions="actionNext"
            Android:inputType="textEmailAddress"
            Android:textSize="@dimen/text_size_sp_16"
            Android:theme="@style/EditTextStyle"/>

Fügen Sie Linien im Stil hinzu

<style name="EditTextStyle" parent="Android:Widget.EditText">
    <item name="Android:textColor">@color/txt_color_change</item>
    <item name="Android:textColorHint">@color/et_default_color_text</item>
    <item name="colorControlNormal">@color/et_default_color_rule</item>
    <item name="colorControlActivated">@color/et_engagged_color_rule</item>
  </style>

Java-Code zum Umschalten der Farbe

myRqubeEditText.setErrorState(true);
myRqubeEditText.setErrorState(false);

Wenn Sie das Endergebnis ändern möchten, ohne App-Farben zu verwenden, verwenden Sie diese Zeilen in Ihrem Thema:

<item name="Android:editTextStyle">@Android:style/Widget.EditText</item>
<item name="editTextStyle">@Android:style/Widget.EditText</item>

Ich kenne keine andere Lösung.

Fügen Sie in Activit.XML den Code hinzu

<EditText
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content"
        Android:inputType="textPersonName"
        Android:ems="10"
        Android:id="@+id/editText"
        Android:hint="Informe o usuário"
        Android:backgroundTint="@Android:color/transparent"/>

Wo BackgroundTint=color für Ihre gewünschte Farbe

Ich war absolut verblüfft über dieses Problem. Ich hatte alles in diesem und in anderen Themen ausprobiert, aber egal was ich tat, ich konnte die Farbe der Unterstreichung nicht in etwas anderes als das Standardblau ändern.

Ich fand endlich heraus, was los war. Ich habe beim Erstellen einer neuen Instanz (fälschlicherweise) Android.widget.EditText verwendet (aber der Rest meiner Komponenten stammte aus der appcompat-Bibliothek). Ich hätte Android.support.v7.widget.AppCompatEditText verwenden sollen. Ich habe new EditText(this) durch new AppCompatEditText(this) ersetzt und das Problem wurde sofort behoben. Es stellt sich heraus, dass, wenn Sie tatsächlich AppCompatEditText verwenden, nur das accentColor aus Ihrem Thema berücksichtigt wird (wie oben in mehreren Kommentaren erwähnt) und keine zusätzliche Konfiguration erforderlich ist.

Dies ist die einfachste und effizienteste/wiederverwendbare/Funktioniert auf allen APIs
Erstellen Sie eine benutzerdefinierte EditText-Klasse wie folgt:

public class EditText extends Android.widget.EditText {
    public EditText(Context context) {
        super(context);
        init();
    }

    public EditText(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public EditText(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        getBackground().mutate().setColorFilter(ContextCompat.getColor(getContext(), R.color.colorAccent), PorterDuff.Mode.SRC_ATOP);
    }
}

Dann benutze es so:

 <company.com.app.EditText
        Android:layout_width="200dp"
        Android:layout_height="wrap_content"/>

Um den EditText-Hintergrund dynamisch zu ändern, können Sie ColorStateList verwenden.

int[][] states = new int[][] {
    new int[] { Android.R.attr.state_enabled}, // enabled
    new int[] {-Android.R.attr.state_enabled}, // disabled
    new int[] {-Android.R.attr.state_checked}, // unchecked
    new int[] { Android.R.attr.state_pressed}  // pressed
};

int[] colors = new int[] {
    Color.BLACK,
    Color.RED,
    Color.GREEN,
    Color.BLUE
};

ColorStateList colorStateList = new ColorStateList(states, colors);

Credits: Diese SO Antwort über ColorStateList ist fantastisch .