How should I validate an e-mail address?

What's a good technique for validating an e-mail address (e.g. from a user input field) in Android? org.apache.commons.validator.routines.EmailValidator doesn't seem to be available. Are there any other libraries doing this which are included in Android already or would I have to use RegExp?

Another option is the built in [Patterns][1] starting with API Level 8:

public final static boolean isValidEmail(CharSequence target) {
  if (TextUtils.isEmpty(target)) {
    return false;
  } else {
    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
  }
}

[Patterns viewable source][2]

OR

One line solution from @AdamvandenHoven:

public final static boolean isValidEmail(CharSequence target) {
  return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

[1]: http://developer.android.com/reference/android/util/Patterns.html "Patterns" [2]: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.3.5_r1/android/util/Patterns.java "Patterns viewable source"

Next pattern is used in K-9 mail:

public static final Pattern EMAIL_ADDRESS_PATTERN = Pattern.compile(
          "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
          "\\@" +
          "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
          "(" +
          "\\." +
          "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
          ")+"
      );

You can use function

private boolean checkEmail(String email) {
		return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}

Since API 8 (android 2.2) there is a pattern: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

So you can use it to validate yourEmailString:

private boolean isValidEmail(String email) {
    Pattern pattern = Patterns.EMAIL_ADDRESS;
    return pattern.matcher(email).matches();
}

returns true if the email is valid

UPD: This pattern source code is:

public static final Pattern EMAIL_ADDRESS
    = Pattern.compile(
        "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
        "\\@" +
        "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
        "(" +
            "\\." +
            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
        ")+"
    );

refer to: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

So you can build it yourself for compatibility with API < 8.

We have a simple Email pattern matcher now.

Java:

 private static boolean isValidEmail(String email) {
        return !TextUtils.isEmpty(email) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
    }

Kotlin Function:

 private fun isValidEmail(email: String): Boolean {
        return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches()
    }

Kotlin Extension:

fun String.isValidEmail() =
    !TextUtils.isEmpty(this) && Patterns.EMAIL_ADDRESS.matcher(this).matches()

Don't use a reg-ex.

Apparently the following is a reg-ex that correctly validates most e-mails addresses that conform to RFC 2822, (and will still fail on things like "[email protected]", as will org.apache.commons.validator.routines.EmailValidator)

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

Possibly the easiest way to validate an e-mail to just send a confirmation e-mail to the address provided and it it bounces then it's not valid.

If you want to perform some basic checks you could just check that it's in the form *@*

If you have some business logic specific validation then you could perform that using a regex, e.g. must be a gmail.com account or something.

Use simple one line code for email Validation

public static boolean isValidEmail(CharSequence target) {
    return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

use like...

if (!isValidEmail(yourEdittext.getText().toString()) {
    Toast.makeText(context, "your email is not valid", 2000).show();
}

You could write a Kotlin extension like this:

fun String.isValidEmail() =
        isNotEmpty() && android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()

And then call it like this:

email.isValidEmail()

This is Android Studio suggestions:

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}

use android:inputType="textEmailAddress" as below:

       <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="email"
        android:inputType="textEmailAddress"
        android:id="@+id/email"
        />

and:

       boolean isEmailValid(CharSequence email) {
        return android.util.Patterns.EMAIL_ADDRESS.matcher(email)
                .matches();
      }

You can use regular expression to do so. Something like the following.

Pattern pattern = Pattern.compile(".+@.+\\.[a-z]+");
String email = "[email protected]";
Matcher matcher = pattern.matcher(email);
boolean matchFound = matcher.matches();

Note: Check the regular expression given above, don't use it as it is.

There is a Patterns class in package android.util which is beneficial here. Below is the method I always use for validating email and many other stuffs

private boolean isEmailValid(String email) {
    return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches();
}

this is the best way in kotlin Useing Extension Function

fun String.isEmailValid(): Boolean {
        return !TextUtils.isEmpty(this) && android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()
    }

Simplest Kotlin solution using extension functions:

fun String.isEmailValid() =
            Pattern.compile(
                    "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
                            "\\@" +
                            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
                            "(" +
                            "\\." +
                            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
                            ")+"
            ).matcher(this).matches()

and then you can validate like this:

"[email protected]".isEmailValid()

If you are in kotlin-multiplatform without access to Pattern, this is the equivalent:

fun String.isValidEmail() = Regex(emailRegexStr).matches(this)

Call This Method where you want to validate email ID.

public static boolean isValid(String email)
{
   String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
   CharSequence inputStr = email;
   Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
   Matcher matcher = pattern.matcher(inputStr);
   if (matcher.matches()) 
   {
      return true;
   }
   else{
   return false;
   }
}

For an Email validation android provide some InBuilt Pattern.But it only support API level 8 and above.

Here is code for use that pattern to check email validation.

  private boolean Email_Validate(String email) 
  {
    return android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
  }

Make sure that after execute this method you should check that if this method return true then you allow to save email and if this method return false then display message that email is "Invalid".

Hope you get your answer, Thanks you.

Can I STRONGLY recommend you don't try to 'validate' email addresses, you'll just get yourself into a lot of work for no good reason.

Just make sure what is entered won't break your own code - e.g. no spaces or illegal characters which might cause an Exception.

Anything else will just cause you a lot of work for minimal return...

Validate your email address format. [email protected]

public boolean emailValidator(String email) 
{
    Pattern pattern;
    Matcher matcher;
    final String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
    pattern = Pattern.compile(EMAIL_PATTERN);
    matcher = pattern.matcher(email);
    return matcher.matches();
}

	public boolean isValidEmail(String email)
{
	boolean isValidEmail = false;

	String emailExpression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
	CharSequence inputStr = email;

	Pattern pattern = Pattern.compile(emailExpression, Pattern.CASE_INSENSITIVE);
	Matcher matcher = pattern.matcher(inputStr);
	if (matcher.matches())
	{
		isValidEmail = true;
	}
	return isValidEmail;
}

If you are using API 8 or above, you can use the readily available Patterns class to validate email. Sample code:

public final static boolean isValidEmail(CharSequence target) {
    if (target == null) 
        return false;
    
    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

By chance if you are even supporting API level less than 8, then you can simply copy the Patterns.java file into your project and reference it. You can get the source code for Patterns.java from this link

Here is android.util.Patterns.EMAIL_ADDRESS

>[a-zA-Z0-9+._%-+]{1,256}@[a-zA-Z0-9][a-zA-Z0-9-]{0,64}(.[a-zA-Z0-9][a-zA-Z0-9-]{0,25})+

String will match it if

Start by 1->256 character in (a-z, A-Z, 0-9, +, ., _, %, - , +)  
then 1 '@' character  
then 1 character in (a-z, A-Z, 0-9)  
then 0->64 character in (a-z, A-Z, 0-9, -)  
then **ONE OR MORE** 
         1 '.' character   
    then 1 character in (a-z, A-Z, 0-9)   
    then 0->25 character in (a-z, A-Z, 0-9, -)

Example some special match email

a@b.c
a+@b-.c
a@b.c.d.e.f.g.h

You may modify this pattern for your case then validate by

fun isValidEmail(email: String): Boolean {
    return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}

Try this simple method which can not accept the email address beginning with digits:

boolean checkEmailCorrect(String Email) {
	if(signupEmail.length() == 0) {
		return false;
	}
	
	String pttn = "^\\D.+@.+\\.[a-z]+";
	Pattern p = Pattern.compile(pttn);
	Matcher m = p.matcher(Email);

	if(m.matches()) {
		return true;
	}
	
	return false;
}

Try this code.. Its really works..

            if (!email
					.matches("^[\\w-_\\.+]*[\\w-_\\.]\\@([\\w]+\\.)+[\\w]+[\\w]$"))
			{
				Toast.makeText(getApplicationContext(), "Email is invalid",
						Toast.LENGTH_LONG).show();
				return;
			}

Following was used by me. However it contains extra characters than normal emails but this was a requirement for me.

public boolean isValidEmail(String inputString) {
    String  s ="^((?!.*?\.\.)[A-Za-z0-9\.\!\#\$\%\&\'*\+\-\/\=\?\^_`\{\|\}\~]+@[A-Za-z0-9]+[A-Za-z0-9\-\.]+\.[A-Za-z0-9\-\.]+[A-Za-z0-9]+)$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(inputString);
    return matcher.matches();
}

Answer of this question:- https://stackoverflow.com/questions/50046703/requirement-to-validate-an-e-mail-address-with-given-points?noredirect=1#comment87109601_50046703

Explanation-

1. (?!.*?..) "Negative Lookhead" to negate 2 consecutive dots.

2. [A-Za-z0-9.!#$%&'*+-/=?^_`{|}~]+ Atleast one characters defined. ("" is used for escaping).

3. @ There might be one "@".

4. [A-Za-z0-9]+ then atleast one character defined.

5. [A-Za-z0-9-.]* Zero or any repetition of character defined.

6. [A-Za-z0-9]+ Atleast one char after dot.

The key here is that you want to fully validate the email address. You don’t just want to check it for syntactic correctness, you want to check whether the email address is real.

Two obvious reasons: real users often mis-type their email addresses, and some users may put in fake email addresses. Therefore, you want to do a syntactic check and an existence check.

The best way to do this that I have found on Android is to use the free Cloudmersive Validation API for this.

The code looks like this:

ApiClient defaultClient = Configuration.getDefaultApiClient();

// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");

EmailApi apiInstance = new EmailApi();
String email = "email_example"; // String | Email address to validate, e.g. \"[email protected]\". The input is a string so be sure to enclose it in double-quotes.
try {
    FullEmailValidationResponse result = apiInstance.emailFullValidation(email);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling EmailApi#emailFullValidation");
    e.printStackTrace();
}

I’m using this in all my apps and it is great because I can validate the email addresses in the UX at the point of entry.

According to Patterns.EMAIL_ADDRESS, this email is correct "[email protected]". So I modified the regex in Patterns.EMAIL_ADDRESS and increased the minimum length for domain. Here is the function for Kotlin:

fun isEmailValid(email: String): Boolean =
    email.isNotEmpty() && Pattern.compile(
        "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
                "\\@" +
                "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
                "(" +
                "\\." +
                "[a-zA-Z0-9][a-zA-Z0-9\\-]{1,25}" +
                ")+"
    ).matcher(email).matches()

I just changed domain part from {0,25} to {1,25}.

Note that most of the regular expressions are not valid for international domain names (IDN) and new top level domains like .mobi or .info (if you check for country codes or .org, .com, .gov and so on).

A valid check should separate the local part (before the at-sign) and the domain part. You should also consider the max length of the local part and domain (in sum 255 chars including the at-sign).

The best approach is to transform the address in an IDN compatible format (if required), validate the local part (RFC), check the length of the address and the check the availability of the domain (DNS MX lookup) or simply send an email.

The Linkify class has some pretty useful helper methods that might be relevant, including regular expressions designed to pick up phone numbers and email addresses and such:

http://developer.android.com/reference/android/text/util/Linkify.html

I have used follwing code.This works grate.I hope this will help you.

if (validMail(yourEmailString)){
   //do your stuf
 }else{
 //email is not valid.
}

and use follwing method.This returns true if email is valid.

	private boolean validMail(String yourEmailString) {
	Pattern emailPattern = Pattern.compile(".+@.+\\.[a-z]+");
	Matcher emailMatcher = emailPattern.matcher(emailstring);
	return emailMatcher.matches();
}

email is your email-is.

public boolean validateEmail(String email) {
    
    Pattern pattern;
    Matcher matcher;
    String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
    pattern = Pattern.compile(EMAIL_PATTERN);
    matcher = pattern.matcher(email);
    return matcher.matches();
    
    }

For regex lovers, the very best (e.g. consistant with RFC 822) email's pattern I ever found since now is the following (before PHP supplied filters). I guess it's easy to translate this into Java - for those playing with API < 8 :

private static function email_regex_pattern() {
// Source:  http://www.iamcal.com/publish/articles/php/parsing_email
$qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
$dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
$atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c'.
	'\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
$quoted_pair = '\\x5c[\\x00-\\x7f]';
$domain_literal = "\\x5b($dtext|$quoted_pair)*\\x5d";
$quoted_string = "\\x22($qtext|$quoted_pair)*\\x22";
$domain_ref = $atom;
$sub_domain = "($domain_ref|$domain_literal)";
$word = "($atom|$quoted_string)";
$domain = "$sub_domain(\\x2e$sub_domain)*";
$local_part = "$word(\\x2e$word)*";
$pattern = "!^$local_part\\x40$domain$!";
return $pattern ;
}

You can do any type of validation in android very easily by the oval.jar file. OVal is a pragmatic and extensible general purpose validation framework for any kind of Java objects.

follow this link: http://oval.sourceforge.net/userguide.html

You can downlaod this from here: http://oval.sourceforge.net/userguide.html#download

You can use validation by setting tags in variables

public class Something{

	@NotEmpty  //not empty validation
	@Email     //email validation
	@SerializedName("emailAddress")
	private String emailAddress;
}

   private void checkValidation() {
		Something forgotpass.setEmailAddress(LoginActivity.this.dialog_email.getText().toString());
		Validator validator = new Validator();
		//collect the constraint violations
		List<ConstraintViolation> violations = validator.validate(forgotpass);
		if(violations.size()>0){
    		for (ConstraintViolation cv : violations){
    			if(cv.getMessage().contains("emailAddress")){
    				dialog_email.setError(ValidationMessage.formattedError(cv.getMessage(), forgotpass));
    			}
    		}
		}
}

You could also use

InternetAddress emailAddr = new InternetAddress(email);
emailAddr.validate();

If the email is not valid it will throw an AddressException.

Unfortunately Android doesn't support jndi-dns, but just to give you an idea of a more powerful email validation, you could use it to validate the email domain. Maybe an Android guru could help and show if there are similar alternatives... An example implementation with "regular" java is available here.

EDIT

I just realized that javax.mail isn't support neither... But this post shows a workaround.

I know that It's very too late, still I will give my answer.

I used this line of code to check the inputted Email format:

!TextUtils.isEmpty(getEmail) && android.util.Patterns.EMAIL_ADDRESS.matcher(getEmail).matches();

The problem is, it will only check for the FORMAT not the SPELLING.

When I entered @gmal.com missing i ,and @yaho.com missing another o . It return true. Since it satisfies the condition for Email Format.

What I did is, I used the code above. Since it will give / return true if the if the user inputted @gmail.com ONLY, no text at the start.

FORMAT CHECKER

If I enter this email it will give me: true but the spelling is wrong. In my textInputLayout error

EMAIL ADDRESS @yahoo.com , @gmail.com, @outlook.com CHECKER

 //CHECK EMAIL
public boolean checkEmailValidity(AppCompatEditText emailFormat){

    String getEmail = emailFormat.getText().toString();
    boolean getEnd;

    //CHECK STARTING STRING IF THE USER
    //entered @gmail.com / @yahoo.com / @outlook.com only
    boolean getResult = !TextUtils.isEmpty(getEmail) && android.util.Patterns.EMAIL_ADDRESS.matcher(getEmail).matches();

    //CHECK THE EMAIL EXTENSION IF IT ENDS CORRECTLY
    if (getEmail.endsWith("@gmail.com") || getEmail.endsWith("@yahoo.com") || getEmail.endsWith("@outlook.com")){
        getEnd = true;
    }else {
        getEnd = false;
    }

    //TEST THE START AND END
    return (getResult && getEnd);
}

RETURN: false

RETURN:true

XML:

<android.support.v7.widget.AppCompatEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/editTextEmailAddress"
            android:inputType="textEmailAddress|textWebEmailAddress"
            android:cursorVisible="true"
            android:focusable="true"
            android:focusableInTouchMode="true"
            android:singleLine="true"
            android:maxLength="50"
            android:theme="@style/EditTextCustom"/>

Note: I tried to get the value from EditText and used split on it and even StringTokenizer. Both return false to me.

Email Validation in Kotlin:

val email = etEmail.text.toString().trim() // get email from user

  if(isValidEmail(email)){ // call isValidEmail function and pass email in parameter
      // Your email ID is Valid
  }else{
      // Enter your valid email ID
  }

This method is used for checking valid email id formats.

    fun isValidEmail(email: CharSequence): Boolean {
        var isValid = true
        val expression = "^[\\w.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$"
        val pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE)
        val matcher = pattern.matcher(email)
        if (!matcher.matches()) {
            isValid = false
        }
        return isValid
    }

Simplest way of Email Validation.

EditText TF;
public Button checkButton;

public final Pattern EMAIL_ADDRESS_PATTERN = Pattern.compile(
          "[a-zA-Z0-9+._%-+]{1,256}" +
          "@" +
          "[a-zA-Z0-9][a-zA-Z0-9-]{0,64}" +
          "(" +
          "." +
          "[a-zA-Z0-9][a-zA-Z0-9-]{0,25}" +
          ")+"
      );
 @Override
 public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.main);

   TF=(EditText) findViewById(R.id.TF);
   checkButton=(Button) findViewById(R.id.checkButton);

    checkButton.setOnClickListener(new OnClickListener() {
    public void onClick(View v) {
           String email=TF.getText().toString();
           if(checkEmail(email))
              Toast.makeText(getApplicationContext(),"Valid Email Addresss", Toast.LENGTH_SHORT).show();
           else
              Toast.makeText(getApplicationContext(),"Invalid Email Addresss", Toast.LENGTH_SHORT).show();
    }
    });
}
private boolean checkEmail(String email) {
    return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}}

Kotlin Extension Function

fun EditText.isValidEmail() : Boolean{
    return if(Pattern
            .compile("^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$")
            .matcher(text.toString()).matches()){
        true
    }else {
        hint = context.getString(R.string.invalid_email_adress)
        false
    }
}

Use

if(!emailEt.isValidEmail()){
    return
}