Come devo convalidare un indirizzo e-mail?

Qual è una buona tecnica per convalidare un indirizzo e-mail (ad es. Da un campo di input dell'utente) in Android? org.apache.commons.validator.routines.EmailValidator non sembra essere disponibile. Ci sono altre librerie che fanno questo che sono già incluse in Android o dovrei usare RegExp?

Non usare un reg-ex.

Apparentemente il seguente è un reg-ex che convalida correttamente la maggior parte degli indirizzi e-mail conformi a RFC 2822 , (e fallirà comunque su cose come "user@gmail.com.nospam", come 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])+)\])

Forse il modo più semplice per convalidare un'e-mail per inviare semplicemente un'e-mail di conferma all'indirizzo fornito e rimbalza quindi non è valido.

Se vuoi eseguire alcuni controlli di base, puoi semplicemente verificare che sia nel modulo *@*

Se si dispone di una convalida specifica per la logica aziendale, è possibile eseguire tale operazione utilizzando un regex, ad esempio deve essere un account gmail.com o qualcosa del genere.

Un'altra opzione è i Pattern integrati che iniziano con 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();
  }
}

Fonte visualizzabile di modelli

O

Una soluzione di linea di @AdamvandenHoven:

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

Il modello successivo viene utilizzato nella posta 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}" +
          ")+"
      );

Puoi usare la funzione

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

Dall'API 8 (Android 2.2) esiste un modello: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Quindi puoi usarlo per convalidare il tuo EmailString:

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

ritorna vero se l'e-mail è valida

UPD: questo codice sorgente del modello è:

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

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

Quindi puoi costruirlo tu stesso per la compatibilità con API <8.

Ora abbiamo un semplice abbinatore di modelli di email

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

Utilizza un semplice codice di una riga per la convalida dell'email

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

usa come ...

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

Ecco i suggerimenti di Android Studio:

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

È possibile utilizzare l'espressione regolare per farlo. Qualcosa di simile al seguente.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Nota: controlla l'espressione regolare indicata sopra, non usarla così com'è.

usa android: inputType = "textEmailAddress" come di seguito:

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

e:

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

Puoi scrivere un'estensione di Kotlin in questo modo:

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

E poi chiamalo così:

email.isValidEmail()

C'è una Patternsclasse nel pacchetto android.utilche è utile qui. Di seguito è riportato il metodo che uso sempre per convalidare la posta elettronica e molti altri elementi

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

Chiama questo metodo dove desideri convalidare l'ID 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;
   }
}

Per una convalida via e-mail Android fornisce alcuni InBuilt Pattern . Ma supporta solo API livello 8 e superiore .

Ecco il codice per utilizzare quel modello per verificare la convalida dell'email.

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

Assicurarsi che dopo aver eseguito questo metodo sia necessario verificare che se questo metodo restituisce true, si consenta di salvare la posta elettronica e se questo metodo restituisce false, visualizzare il messaggio che la posta elettronica è "Non valida".

Spero che tu abbia la tua risposta, grazie.

Posso consigliare vivamente di non provare a "convalidare" gli indirizzi e-mail, ti impegnerai in un sacco di lavoro senza una buona ragione.

Assicurati solo che ciò che viene inserito non rompa il tuo codice, ad esempio senza spazi o caratteri illegali che potrebbero causare un'eccezione.

Qualsiasi altra cosa ti causerà molto lavoro per un ritorno minimo ...

Convalida il formato del tuo indirizzo email. 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;
}

Se si utilizza API 8 o versione successiva, è possibile utilizzare la Patternsclasse prontamente disponibile per convalidare la posta elettronica. Codice di esempio:

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

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

Per caso se stai persino supportando un livello API inferiore a 8, puoi semplicemente copiare il Patterns.javafile nel tuo progetto e fare riferimento a esso. È possibile ottenere il codice sorgente per Patterns.javada questo link

Qui è android.util.Patterns.EMAIL_ADDRESS

[A-zA-Z0-9 + ._ \% - +] {1256} \ @ [a-zA-Z0-9] [a-zA-Z0-9 -]. {0,64} ([a- zA-Z0-9] [a-zA-Z0-9 -] {0,25}) +

String lo abbinerà se

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

Esempio di e-mail di corrispondenza speciale

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

Puoi modificare questo modello per il tuo caso, quindi confermare

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

Prova questo semplice metodo che non può accettare l'indirizzo e-mail che inizia con le cifre:

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

Prova questo codice .. Funziona davvero ..

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

Il seguito è stato usato da me. Tuttavia contiene caratteri extra rispetto alle normali e-mail, ma questo era un requisito per 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();
}

Risposta a questa domanda: - Requisito per convalidare un indirizzo e-mail con determinati punti

Spiegazione-

1. (?!. *? ..) "Negative Lookhead" per negare 2 punti consecutivi.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Almeno uno definito. ("\" viene utilizzato per la escape).
3. @ Potrebbe esserci un "@".
4. [A-Za-z0-9] + quindi almeno un personaggio definito.
5. [A-Za-z0-9 -.] * Zero o qualsiasi ripetizione del carattere definita.
6. [A-Za-z0-9] + almeno un carattere dopo punto.

La chiave qui è che vuoi validare completamente l'indirizzo email. Non vuoi solo verificarne la correttezza sintattica, ma vuoi verificare se l'indirizzo e-mail è reale.

Due ovvi motivi: gli utenti reali spesso digitano male i loro indirizzi e -mail e alcuni utenti possono inserire indirizzi e-mail falsi. Pertanto, si desidera eseguire un controllo sintattico e un controllo di esistenza.

Il modo migliore per farlo che ho trovato su Android è utilizzare l' API di convalida Cloudmersive gratuita per questo.

Il codice è simile al seguente:

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

Lo sto usando in tutte le mie app ed è fantastico perché posso convalidare gli indirizzi e-mail nella UX al punto di entrata.

La soluzione Kotlin più semplice che utilizza le funzioni di estensione:

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

e quindi puoi convalidare in questo modo:

"testemail6589@gmail.com".isEmailValid()

Nota che la maggior parte delle espressioni regolari non sono valide per nomi di dominio internazionali (IDN) e nuovi domini di primo livello come .mobi o .info (se controlli i codici paese o .org, .com, .gov e così via).

Un controllo valido dovrebbe separare la parte locale (prima del segno di at) e la parte del dominio. Dovresti anche considerare la lunghezza massima della parte locale e del dominio (in somma 255 caratteri incluso il segno at).

L'approccio migliore è trasformare l'indirizzo in un formato compatibile IDN (se richiesto), convalidare la parte locale (RFC), verificare la lunghezza dell'indirizzo e verificare la disponibilità del dominio (ricerca DNS MX) o semplicemente inviare un'e-mail .

La classe Linkify ha alcuni metodi di aiuto piuttosto utili che potrebbero essere rilevanti, tra cui espressioni regolari progettate per raccogliere numeri di telefono e indirizzi e-mail e simili:

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

Ho usato il codice seguente: funziona bene, spero che questo ti possa aiutare.

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

e utilizza il metodo follwing. Questo restituisce true se l'e-mail è valida.

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

l'email è la tua email.

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

    }

Per gli amanti dei regex, il modello di email migliore (ad es. Coerente con RFC 822) che abbia mai trovato da ora è il seguente (prima che PHP fornisse i filtri). Immagino sia facile tradurlo in Java - per chi gioca con 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 ;
}

Puoi eseguire qualsiasi tipo di convalida in Android molto facilmente dal file oval.jar. OVal è un framework pragmatico ed estensibile di validazione per tutti gli oggetti Java.

segui questo link: http://oval.sourceforge.net/userguide.html

Puoi scaricarlo da qui: http://oval.sourceforge.net/userguide.html#download

È possibile utilizzare la convalida impostando i tag nelle variabili

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

Puoi anche usare

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

Se l'e-mail non è valida, verrà generata una AddressException .

Sfortunatamente Android non supporta jndi-dns , ma solo per darti un'idea di una più potente convalida e-mail, puoi usarla per convalidare il dominio e-mail. Forse un guru di Android potrebbe aiutare e mostrare se ci sono alternative simili ... Un'implementazione di esempio con Java "normale" è disponibile qui .

MODIFICARE

Mi sono appena reso conto che javax.mail non supporta neanche ... Ma questo post mostra una soluzione alternativa .