Comment dois-je valider une adresse e-mail?

Quelle est une bonne technique pour valider une adresse e-mail (par exemple à partir d'un champ de saisie utilisateur) dans Android? org.apache.commons.validator.routines.EmailValidator ne semble pas être disponible. Existe-t-il déjà d'autres bibliothèques qui sont incluses dans Android ou devrais-je utiliser RegExp?

N'utilisez pas de reg-ex.

Apparemment, ce qui suit est un reg-ex qui valide correctement la plupart des adresses électroniques conformes à la RFC 2822 (et échouera toujours sur des choses comme "user@gmail.com.nospam", tout comme 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])+)\])

Peut-être le moyen le plus simple de valider un e-mail pour simplement envoyer un e-mail de confirmation à l'adresse fournie et il rebondit alors il n'est pas valide.

Si vous souhaitez effectuer des vérifications de base, vous pouvez simplement vérifier que c'est dans le formulaire *@*

Si vous avez une validation spécifique à la logique métier, vous pouvez effectuer cela en utilisant une expression régulière, par exemple doit être un compte gmail.com ou quelque chose.

Une autre option est les modèles intégrés commençant par l'API niveau 8:

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

Source visible des motifs

OU

Solution en ligne de @AdamvandenHoven:

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

Le modèle suivant est utilisé dans le courrier K-9:

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

Vous pouvez utiliser la fonction

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

Depuis l'API 8 (Android 2.2), il existe un modèle: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Vous pouvez donc l'utiliser pour valider votreEmailString:

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

renvoie vrai si l'e-mail est valide

UPD: Ce code source de modèle est:

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

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

Vous pouvez donc le créer vous-même pour assurer la compatibilité avec l'API <8.

Nous avons maintenant un simple modèle de correspondance des modèles d'e-mail

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

Utilisez un code d'une seule ligne pour la validation des e-mails

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

utiliser comme ...

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

Voici les suggestions d'Android Studio:

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

Vous pouvez utiliser une expression régulière pour ce faire. Quelque chose comme ce qui suit.

Pattern pattern = Pattern.compile(".+@.+\\.[a-z]+");

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Remarque: Vérifiez l'expression régulière donnée ci-dessus, ne l'utilisez pas telle quelle.

utilisez android: inputType = "textEmailAddress" comme ci-dessous:

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

et:

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

Vous pouvez écrire une extension Kotlin comme ceci:

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

Et puis appelez-le comme ceci:

email.isValidEmail()

Il y a une Patternsclasse dans le package android.utilqui est bénéfique ici. Voici la méthode que j'utilise toujours pour valider les e-mails et bien d'autres choses

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

Appelez cette méthode où vous souhaitez valider l'ID de l'e-mail.

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

Pour une validation Email android fournir un modèle de INBUILT .Mais il ne supporte que le niveau de l' API 8 et au- dessus .

Voici le code pour utiliser ce modèle pour vérifier la validation des e-mails.

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

Assurez-vous qu'après avoir exécuté cette méthode, vous devez vérifier que si cette méthode renvoie true, vous autorisez à enregistrer le courrier électronique et si cette méthode retourne false, affichez le message que le courrier électronique est "invalide".

J'espère que vous aurez votre réponse, merci.

Puis-je FORTEMENT vous recommander de ne pas essayer de «valider» les adresses e-mail, vous allez simplement vous lancer dans beaucoup de travail sans raison valable.

Assurez-vous simplement que ce qui est entré ne cassera pas votre propre code - par exemple, aucun espace ou caractère illégal qui pourrait provoquer une exception.

Tout le reste vous causera beaucoup de travail pour un rendement minimal ...

Validez le format de votre adresse e-mail. Ex-virag@gmail.com

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

Si vous utilisez l'API 8 ou supérieure, vous pouvez utiliser la Patternsclasse facilement disponible pour valider les e-mails. Exemple de code:

public final static boolean isValidEmail(CharSequence target) {
    if (target == null) 
        return false;

    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

Par chance, si vous prenez même en charge un niveau d'API inférieur à 8, vous pouvez simplement copier le Patterns.javafichier dans votre projet et le référencer. Vous pouvez obtenir le code source Patterns.javade ce lien

Voici 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 correspondra si

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

Exemple d'e-mail de match spécial

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

Vous pouvez modifier ce modèle pour votre cas, puis valider en

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

Essayez cette méthode simple qui ne peut pas accepter l'adresse e-mail commençant par des chiffres:

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

Essayez ce code .. Il fonctionne vraiment ..

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

Ce qui suit a été utilisé par moi. Cependant, il contient des caractères supplémentaires par rapport aux e-mails normaux, mais c'était une exigence pour moi.

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

Réponse à cette question: - Obligation de valider une adresse e-mail avec des points donnés

Explication-

1. (?!. *? ..) "Négatif Lookhead" pour annuler 2 points consécutifs.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Au moins un caractère défini. ("\" est utilisé pour s'échapper).
3. @ Il peut y avoir un "@".
4. [A-Za-z0-9] + puis au moins un caractère défini.
5. [A-Za-z0-9 -.] * Zéro ou toute répétition de caractère définie.
6. [A-Za-z0-9] + Au moins un caractère après le point.

La clé ici est que vous souhaitez valider entièrement l'adresse e-mail. Vous ne voulez pas seulement vérifier l'exactitude syntaxique, vous voulez vérifier si l'adresse e-mail est réelle.

Deux raisons évidentes: les vrais utilisateurs tapent souvent mal leurs adresses e-mail et certains utilisateurs peuvent saisir de fausses adresses e-mail. Par conséquent, vous souhaitez effectuer une vérification syntaxique et une vérification d'existence.

La meilleure façon de le faire que j'ai trouvée sur Android est d'utiliser l' API Cloudmersive Validation gratuite pour cela.

Le code ressemble à ceci:

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. \"support@cloudmersive.com\". 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();
}

J'utilise cela dans toutes mes applications et c'est génial car je peux valider les adresses e-mail dans l' UX au point d'entrée.

Solution Kotlin la plus simple utilisant des fonctions d'extension:

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

et ensuite vous pouvez valider comme ceci:

"testemail6589@gmail.com".isEmailValid()

Notez que la plupart des expressions régulières ne sont pas valides pour les noms de domaine internationaux (IDN) et les nouveaux domaines de premier niveau comme .mobi ou .info (si vous vérifiez les codes de pays ou .org, .com, .gov, etc.).

Une vérification valide doit séparer la partie locale (avant le signe at) et la partie domaine. Vous devez également tenir compte de la longueur maximale de la partie locale et du domaine (en somme 255 caractères, y compris le signe at).

La meilleure approche consiste à transformer l'adresse dans un format compatible IDN (si nécessaire), à ​​valider la partie locale (RFC), à vérifier la longueur de l'adresse et à vérifier la disponibilité du domaine (recherche DNS MX) ou simplement envoyer un e-mail .

La classe Linkify a quelques méthodes d'assistance très utiles qui pourraient être pertinentes, y compris des expressions régulières conçues pour récupérer des numéros de téléphone et des adresses e-mail et autres:

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

J'ai utilisé le code follwing.Cela fonctionne, j'espère que cela vous aidera.

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

et utilisez la méthode follwing. Cela renvoie vrai si l'e-mail est valide.

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

l'e-mail est votre e-mail.

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

    }

Pour les amateurs de regex, le meilleur modèle de courrier électronique (conforme à la RFC 822) que j'ai jamais trouvé depuis est le suivant (avant les filtres fournis par PHP). Je suppose qu'il est facile de traduire cela en Java - pour ceux qui jouent avec l'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 ;
}

Vous pouvez effectuer n'importe quel type de validation dans Android très facilement par le fichier oval.jar. OVal est un cadre de validation pragmatique et extensible à usage général pour tout type d'objets Java.

suivez ce lien: http://oval.sourceforge.net/userguide.html

Vous pouvez télécharger ceci à partir d'ici: http://oval.sourceforge.net/userguide.html#download

Vous pouvez utiliser la validation en définissant des balises dans les 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));
                }
            }
        }
}

Vous pouvez également utiliser

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

Si l'e-mail n'est pas valide, il lèvera une exception AddressException .

Malheureusement, Android ne prend pas en charge jndi-dns , mais juste pour vous donner une idée d'une validation de messagerie plus puissante, vous pouvez l'utiliser pour valider le domaine de messagerie. Peut-être qu'un gourou Android pourrait vous aider et montrer s'il existe des alternatives similaires ... Un exemple d'implémentation avec Java "normal" est disponible ici .

ÉDITER

Je viens de réaliser que javax.mail n'est pas compatible non plus ... Mais ce post montre une solution de contournement .