Modifica del colore della riga inferiore di EditText con appcompat v7


310

Sto usando appcompat v7 per ottenere un aspetto coerente su Android 5 e meno. Funziona piuttosto bene. Tuttavia, non riesco a capire come cambiare il colore della linea di fondo e il colore dell'accento per EditTexts. È possibile?

Ho provato a definire un'abitudine android:editTextStyle(vedi sotto) ma sono riuscito a cambiare solo il colore di sfondo completo o il colore del testo, ma non la linea di fondo né il colore dell'accento. C'è un valore di proprietà specifico da utilizzare? devo usare un'immagine disegnabile personalizzata attraverso la android:backgroundproprietà? non è possibile specificare un colore in hexa?

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

Secondo fonti dell'API 21 di Android, EditTexts con design dei materiali sembra usare colorControlActivatede colorControlNormal. Pertanto, ho provato a sovrascrivere queste proprietà nella definizione di stile precedente ma non ha alcun effetto. Probabilmente appcompat non lo utilizza. Sfortunatamente, non riesco a trovare le fonti per l'ultima versione di appcompat con il design dei materiali.


definire il tema per la modifica del testo
Meenal,

Grazie per il tuo suggerimento, ma l'ho già fatto. Ho aggiornato la mia domanda per mostrare cosa ho già provato a fare. Il mio problema riguarda l'attributo da utilizzare nello stile del tema per cambiare il colore della linea di fondo edittext. Idealmente, sto cercando una soluzione in cui posso specificare direttamente il colore in hexa.
Laurent,

Nessuna di queste risposte funziona per me su 4.3. Hai una soluzione funzionante?
Robert Baker,

Ho dovuto estendere AppCompatEditText, a quanto pare.
EpicPandaForce,

Risposte:


479

Finalmente ho trovato una soluzione. Essa consiste semplicemente sovrascrivendo il valore colorControlActivated, colorControlHighlighte colorControlNormalnella definizione app tema e non è il tuo stile EditText. Quindi, pensa di utilizzare questo tema per qualsiasi attività desideri. Di seguito è riportato un esempio:

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

9
Vedo il colore del menu hamburger, pulsante Indietro e barra di scorrimento cambiati in colorControlNormal.
Ario,

11
Questo cambia il colore della linea di fondo ma cambia anche ogni altro controllo come caselle di controllo, pulsanti di opzione ecc. Cambia anche ogni testo di modifica in tutta l'applicazione / attività. Se vuoi cambiare la linea di fondo di un singolo EditText (come faccio io), devi sovrascrivere la proprietà android: background per quel EditText. Non c'è altro modo AFAIK.
Emanuel Moecklin,

68
Se si utilizza la libreria di supporto V22 AppCompat, è possibile specificare il tema nella EditText come: android:theme="@style/Theme.App.Base. Ciò garantirà che lo stile non influisca anche su altre viste nei layout che non si desidera modificare.
Alex Lockwood,

8
Non ha funzionato su Jelly Bean (4.2) ma ha lavorato su Lollipop
Mangesh

3
L'attività dovrebbe ereditare da AppCompatActivity. Non funzionerà se eredita da Activity.
Bharathwaaj,

187

Mi sembrava che fosse necessaria una risposta nel caso in cui qualcuno volesse cambiare un solo edittext. Lo faccio così:

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

1
Ma come posso ripristinare lo sfondo predefinito, ho molti bug dopo aver chiamato editText.getBackground (). ResetColorFilter () su Lollipop?
ultraon,

Attenzione! l'aggiunta di questo può causare la modifica del colore di editText in TUTTA l'app. Testato su Nexus 5. OS 6.0.1.
Alex Perevozchykov,

1
@AlexPerevozchykov potresti avere ragione. Prova ad aggiungere .mutate () dopo .getBackground (). Questo dovrebbe farlo.
hordurh,

@hordurh sì, è stato, ho ricevuto questo suggerimento un po 'prima, i drawable condividono un pool quindi prima di cambiare dobbiamo mutarlo
Alex Perevozchykov

1
Se uso edittext, funziona, ma questo metodo non funziona con l'app compat edittext su lollipop. sai come posso risolvere il problema?
Selin,

145

Sebbene la soluzione di Laurents sia corretta, presenta alcuni inconvenienti come descritto nei commenti poiché non solo la linea di fondo EditTextviene tinta, ma anche il pulsante Indietro di Toolbar, CheckBoxesecc.

fortunatamente v22.1 di appcompat-v7introdotto alcune nuove possibilità. Ora è possibile assegnare un tema specifico solo a una vista. Direttamente dal log delle modifiche :

Uso obsoleto dell'app: tema per lo styling della barra degli strumenti. Ora puoi usare android: tema per barre degli strumenti su tutti i dispositivi API livello 7 e superiori e android: supporto per temi per tutti i widget su API livello 11 e superiori.

Quindi, invece di impostare il colore desiderato in un tema globale, ne creiamo uno nuovo e lo assegniamo solo a EditText.

Esempio:

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

1
Non penso sia necessario. colorControlNormalsenza il prefisso Android utilizza il metodo appcompat per colorare i widget mentre con il prefisso ricade sul metodo di sistema e questo è disponibile solo nei dispositivi API 21+.
reVerse

hmm, ho provato sul mio dispositivo lecca-lecca e non si tinge del colore personalizzato a meno che non lo implementi in stili v21 anche con lo spazio dei nomi Android.
utente2968401

Sto usando la 22.2.0versione di AppCompat ma questo trucco non funziona :(
Shajeel Afzal

1
using <item name = "colorAccent"> # 000000 </item> ha funzionato per me invece di colorControlNormal.
MikeOscarEcho,

Perfetto per cambiare solo un testo di modifica nell'app! (Esattamente quello di cui avevo bisogno! Grazie)
Romain Barbier,

99

Questo può essere modificato in XML usando:

Per API di riferimento> = 21 compatibilità utilizzare:

android:backgroundTint="@color/blue"

Per compatibilità con le API precedenti <21 utilizzare:

app:backgroundTint="@color/blue"

10
Sì, tuttavia funziona solo per le versioni dell'API Android 21+ (kitkat e lolipop). Probabilmente si proverebbe a creare una soluzione compatibile con le versioni precedenti.
DaMachk,

12
Basta usare backgroundTint="@color/blue"invece di android:backgroundTint="@color/blue"un supporto compatibile con le versioni precedenti
Kishan Vaghela,

11
@KishanVaghela, invece di utilizzare android:backgroundTint="@color/blue", utilizza app:backgroundTint="@color/blue"per supportare i dispositivi pre-Lollipop, grazie per il tuo commento!
progetto

2
@blueware Se si desidera utilizzarlo con stile, non è necessario utilizzare "app".
Kishan Vaghela,

aggiungere tools:ignore="MissingPrefix"se compare una sottolineatura rossa sottoapp:backgroundTint="<your color>"
Moses Aprico

47

Ecco la soluzione per API <21 e successive

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
}

inserisci qui la descrizione dell'immagine

Spero che sia d'aiuto


@CoolMind mi dispiace per la risposta in ritardo. Ho controllo di nuovo questo codice nella libreria di supporto 24.2.1, 25.1.1, 25.2.0per il dispositivo <21 e> 21 ed è ancora funzionante. Controlla questa semplice demo drive.google.com/file/d/0B_poNaia6t8kSzU3bDFVazRSSDA/… . Non so perché questo codice non funzioni per te, quindi per favore fammi sapere. grazie
Phan Van Linh,

@Renjith mi dispiace per la risposta tardiva, per favore controlla il mio commento sopra
Phan Van Linh

Come si ripristina il colore predefinito con questo codice?
Neph

35

La risposta accettata è un po 'più per cosa base di stile, ma la cosa più efficiente da fare è aggiungere l' attributo colorAccent nel tuo stile AppTheme in questo modo:

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

L'attributo colorAccent viene utilizzato per la colorazione dei widget in tutta l'app e quindi deve essere usato per coerenza


8
@Tomasz non richiede API 21+ perché il tema principale è AppCompat che scende ad API 7
TanmayP

Ughhh. Grazie per questo, stavo usando name="android:colorAccent"erroneamente
Jules

29

Se stai usando appcompat-v7:22.1.0+, puoi usare DrawableCompat per colorare i tuoi widget

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

che salvavita è fantastico, peccato che non lo sappia bene
pt123

Scorri verso il basso e vedi la mia risposta per la libreria di design 23.2.0. Questo metodo è inutile in questo momento.
ywwynm,

21

Uso:

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

Questo supporterà i dispositivi pre-Lollipop non solo +21


@ powder366, puoi pubblicare il tema principale della tua app?
progetto

1
<style name = "AppTheme" parent = "Theme.AppCompat.Light.DarkActionBar">
powder366

2
@ powder366, prova questo: <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">e dovrebbe funzionare
blueware

19

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


Funziona! Come la domanda si pone, dovrebbe essere risolta nello stile / tema, questa dovrebbe essere la risposta corretta.
Ninja,

Sono d'accordo. questa dovrebbe essere la risposta corretta poiché è una soluzione globale
Santacrab,

Ciò è scomodo se controlli diversi richiedono colori diversi.
Giulio,

12

Una soluzione rapida per il tuo problema è guardare in yourappspackage / build / intermediates / exploded-aar / com.android.support / appcompat-v7 / res / drawable / for abc_edit_text_material.xml e copiare quel file xml nella tua cartella drawable. Quindi è possibile modificare il colore dei 9 file di patch all'interno di questo selettore, al fine di soddisfare le proprie preferenze.


9

È molto semplice aggiungere l' android:backgroundTintattributo nel tuo 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"/>

2
backgroundTinta sopra API leve 21
Ashwin H,

ViewCompat.setBackgroundTintList (EditText, ColorStateList.valueOf (Color.YELLOW))
Arst

1
app:backgroundTint="@color/blue"funziona su tutti i livelli di API .. anche se per qualsiasi motivo si sta ancora trasformando in un colore diverso quando selezionato XD
EpicPandaForce

8

Ecco una parte del codice sorgente della TextInputLayoutlibreria di progettazione di supporto ( AGGIORNATO per la versione 23.2.0 ), che cambia EditTextil colore della linea di fondo in un modo più semplice:

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

Sembra che tutto il codice sopra diventi inutile proprio ora in 23.2.0 se si desidera cambiare il colore a livello di codice.

E se vuoi supportare tutte le piattaforme, ecco il mio metodo:

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

Che cos'è AppCompatDrawableManager? setBackground richiede API 16.
CoolMind

8

Anch'io sono rimasto bloccato su questo problema per troppo tempo.

Avevo bisogno di una soluzione che funzionasse per le versioni sopra e sotto la v21.

Alla fine ho scoperto una soluzione molto semplice forse non ideale ma efficace: basta impostare il colore di sfondo su transparentnelle proprietà EditText.

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

Spero che questo salvi qualcuno qualche volta.


1
Questo sta cambiando l'intero colore di sfondo e vogliamo cambiare solo il colore sottolineato.
Shahzain ali,

@shahzain ali La sottolineatura di EditText è uno sfondo. Se non lo imposti su null, se ne va. E questo è il motivo per cui sarà lavorato backgroundTint (ma non cambierà colore quando attivato)
nyconing

7

Per me ho modificato sia AppTheme sia un valore colors.xml Sia colorControlNormal che colorAccent mi hanno aiutato a cambiare il colore del bordo EditText. Così come il cursore e il "|" all'interno di un 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>

Ecco il colors.xml

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

Ho rimosso l'attributo android: textCursorDrawable per @null che ho inserito nello stile editText. Quando ho provato a usarlo, i colori non cambiano.


2
Questa dovrebbe essere la risposta
Mina Samy,

Ha funzionato come un fascino. Grazie
Däñish Shärmà del

6

Per ottenere ciò, puoi impostare lo sfondo di edittext su un rettangolo con un'imbottitura negativa a sinistra, a destra e in alto. Ecco l'esempio xml:

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

Sostituisci la forma con un selettore se desideri fornire larghezza e colore diversi per edittext focalizzato.


5

In Activit.XML aggiungi il codice

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

Dove BackgroundTint=colorper il tuo colore desiderato


5

Uso questo metodo per cambiare il colore della linea con PorterDuff, senza altri disegni.

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

Esiste un identificatore simile per accedere alla riga inferiore di un semplice EditText?
Rémi P,

4

Se vuoi cambiare la linea di fondo senza usare i colori delle app, usa queste linee nel tuo tema:

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

Non conosco un'altra soluzione.


4

Ho trovato una soluzione funzionante a questo problema dopo 2 giorni di difficoltà, di seguito la soluzione è perfetta per coloro che vogliono cambiare solo pochi testi di modifica, cambiare / attivare il colore tramite il codice Java e vogliono superare i problemi di comportamento diverso nelle versioni del sistema operativo dovuto utilizzare il metodo setColorFilter ().

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

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

Aggiungi linee con stile

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

codice java per alternare il colore

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

2

Ero assolutamente sconcertato da questo problema. Avevo provato di tutto in questo thread e in altri, ma qualunque cosa facessi non potevo cambiare il colore della sottolineatura con qualcosa di diverso dal blu predefinito.

Alla fine ho capito cosa stava succedendo. Stavo (erroneamente) usando android.widget.EditTextquando creavo una nuova istanza (ma il resto dei miei componenti proveniva dalla libreria di appcompat). Avrei dovuto usare android.support.v7.widget.AppCompatEditText. Ho sostituito new EditText(this)con new AppCompatEditText(this) e il problema è stato immediatamente risolto. Si scopre che, se si sta effettivamente utilizzando AppCompatEditText, rispetterà solo il accentColortema (come menzionato in diversi commenti sopra) e non è necessaria alcuna configurazione aggiuntiva.


2

Questo è il più semplice ed efficiente / riutilizzabile / funziona su tutte le API.
Crea una classe EditText personalizzata in questo modo:

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

Quindi usalo in questo modo:

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

2

Per modificare dinamicamente lo sfondo EditText, è possibile utilizzare ColorStateList .

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

Crediti: questa risposta SO su ColorStateList è fantastica .


E quale metodo usare? setBackgroundTintList? Richiede API 21.
CoolMind


0

Aggiungi app:backgroundTintper sotto api livello 21. Altrimenti usaandroid:backgroundTint .

Per livelli inferiori api 21.

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

Per livelli superiori a api 21.

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

-2

Modifica questo metodo in base alle tue necessità. Questo ha funzionato per me!

  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());
        }
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.