Ändern der Grundfarbe von EditText mit appcompat v7

Ich verwende Appcompat v7, um ein einheitliches Erscheinungsbild für Android 5 und weniger zu erzielen. Es funktioniert ziemlich gut. Ich kann jedoch nicht herausfinden, wie ich die Grundfarbe und die Akzentfarbe für EditTexts ändern kann. Ist es möglich?

Ich habe versucht, eine benutzerdefinierte android:editTextStyleFarbe zu definieren (siehe unten), aber es ist mir nur gelungen, die vollständige Hintergrund- oder Textfarbe zu ändern, nicht jedoch die untere Zeile oder die Akzentfarbe. Gibt es einen bestimmten zu verwendenden Eigenschaftswert? Muss ich ein benutzerdefiniertes Zeichenbild über die android:backgroundEigenschaft verwenden? Ist es nicht möglich, eine Farbe in Hexa anzugeben?

 <style name="Theme.App.Base" parent="Theme.AppCompat.Light.DarkActionBar">
     <item name="android:editTextStyle">@style/Widget.App.EditText</item>
 </style>

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

Laut Quellen der Android API 21 scheinen EditTexts mit Materialdesign colorControlActivatedund zu verwenden colorControlNormal. Daher habe ich versucht, diese Eigenschaften in der vorherigen Stildefinition zu überschreiben, aber es hat keine Auswirkung. Wahrscheinlich verwendet Appcompat es nicht. Leider kann ich die Quellen für die letzte Version von appcompat mit Materialdesign nicht finden.

Endlich habe ich eine Lösung gefunden. Es besteht lediglich aus Überschreiben der Wert für colorControlActivated, colorControlHighlightund colorControlNormalin der App Thema Definition und nicht Ihre EditText Stil. Denken Sie dann daran, dieses Thema für jede gewünschte Aktivität zu verwenden. Unten ist ein Beispiel:

<style name="Theme.App.Base" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="colorControlNormal">#c5c5c5</item>
    <item name="colorControlActivated">@color/accent</item>
    <item name="colorControlHighlight">@color/accent</item>
</style>

Ich hatte das Gefühl, dass dies eine Antwort brauchte, falls jemand nur einen einzigen Edittext ändern wollte. So mach ich es:

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

Die Laurents-Lösung ist zwar korrekt, weist jedoch einige Nachteile auf, wie in den Kommentaren beschrieben, da nicht nur das Endergebnis des EditTextgetönt wird, sondern auch der Zurück-Button des Toolbar,CheckBoxes usw. als auch.

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

Veraltete Verwendung der App: Thema für die Gestaltung der Symbolleiste. Sie können nun Thema für Symbolleiste auf alle API - Ebene 7 und höher Geräte und: android android: Thema Unterstützung für alle Widgets auf API - Ebene 11 und höher Geräte.

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

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

Dies kann in XML geändert werden, indem Folgendes verwendet wird:

Verwenden Sie für die Referenz-API> = 21 Kompatibilität:

android:backgroundTint="@color/blue"

Verwenden Sie für die Abwärts-API <21-Kompatibilität Folgendes:

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 etwas mehr pro Stilbasis , aber am effizientesten ist es, das colorAccent- Attribut wie folgt in Ihren AppTheme-Stil 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 verwenden appcompat-v7:22.1.0+, können Sie den DrawableCompat verwenden, um Ihre Widgets zu 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 unterstützt Pre-Lollipop-Geräte nicht nur +21

<!-- 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 Paket / 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 Zeichenordner zu kopieren. Anschließend können Sie die Farbe der 9 Patch-Dateien in diesem Selektor ändern, um sie Ihren Einstellungen anzupassen.

Es ist sehr einfach, einfach ein android:backgroundTintAttribut in Ihr hinzuzufügen EditText.

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

Hier ist ein Teil des Quellcodes der TextInputLayoutSupport Design Library ( AKTUALISIERT für Version 23.2.0 ), mit dem die EditTextGrundfarbe auf einfachere Weise geändert wird :

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

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

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

Endlich habe ich eine sehr einfache, vielleicht nicht ideale, aber effektive Lösung gefunden: Setzen Sie einfach die Hintergrundfarbe transparentin den EditText-Eigenschaften auf.

<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 color.xml geändert. Sowohl colorControlNormal als auch colorAccent haben mir geholfen, die Rahmenfarbe von EditText zu ändern. Sowie der Cursor und das "|" 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 colours.xml

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

Ich habe das Attribut android: textCursorDrawable für @null entfernt, das ich im editText-Stil platziert habe. Wenn ich dies versuchte, änderten sich die Farben nicht.

Sie können den Hintergrund von edittext auf ein Rechteck mit Minus-Auffüllung links, rechts und oben setzen, 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 einen Selektor, wenn Sie für fokussierten Edittext eine andere Breite und Farbe bereitstellen möchten.

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=colorfür Ihre gewünschte Farbe

Ich verwende diese Methode, um die Farbe der Linie mit PorterDuff zu ändern, ohne dass eine andere Zeichnung möglich ist.

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

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.

Ich habe nach 2 Tagen Kampf eine funktionierende Lösung für dieses Problem erarbeitet. Die folgende Lösung ist perfekt für diejenigen, die nur wenige Bearbeitungstexte ändern, die Farbe durch Java-Code ändern / umschalten und die Probleme unterschiedlichen Verhaltens bei Betriebssystemversionen überwinden möchten 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 stilvolle Linien 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);

Ich war absolut verblüfft über dieses Problem. Ich hatte alles in diesem Thread und in anderen 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 (fälschlicherweise) android.widget.EditTextbeim Erstellen einer neuen Instanz verwendet (aber der Rest meiner Komponenten stammte aus der Appcompat-Bibliothek). Ich hätte verwenden sollen android.support.v7.widget.AppCompatEditText. Ich ersetzte new EditText(this)mit new AppCompatEditText(this) und das Problem wurde sofort gelöst. Es stellt sich heraus, dass, wenn Sie tatsächlich verwenden AppCompatEditText, nur das accentColorvon Ihrem Thema (wie in mehreren Kommentaren oben erwähnt) berücksichtigt wird 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 zu ColorStateList ist fantastisch .

Fügen Sie app:backgroundTintfür unter api Ebene 21 Ansonsten verwenden android:backgroundTint.

Für unter API Level 21.

<EditText
     android:id="@+id/edt_name"
     android:layout_width="300dp"
     android:layout_height="wrap_content"
     android:textColor="#0012ff"
     app:backgroundTint="#0012ff"/>

Für höher als API Level 21.

<EditText
     android:id="@+id/edt_name"
     android:layout_width="300dp"
     android:layout_height="wrap_content"
     android:textColor="#0012ff"
     android:backgroundTint="#0012ff"/>

Bitte ändern Sie diese Methode nach Ihren Wünschen. Das hat bei mir funktioniert!

  private boolean validateMobilenumber() {
        if (mobilenumber.getText().toString().trim().isEmpty() || mobilenumber.getText().toString().length() < 10) {
            input_layout_mobilenumber.setErrorEnabled(true);
            input_layout_mobilenumber.setError(getString(R.string.err_msg_mobilenumber));
           // requestFocus(mobilenumber);
            return false;
        } else {
            input_layout_mobilenumber.setError(null);
            input_layout_mobilenumber.setErrorEnabled(false);
            mobilenumber.setBackground(mobilenumber.getBackground().getConstantState().newDrawable());
        }