¿Cómo debo validar una dirección de correo electrónico?

320

¿Cuál es una buena técnica para validar una dirección de correo electrónico (por ejemplo, desde un campo de entrada del usuario) en Android? org.apache.commons.validator.routines.EmailValidator no parece estar disponible. ¿Hay alguna otra biblioteca haciendo esto que ya esté incluida en Android o tendría que usar RegExp?

znq
fuente
por favor refiérase a este, que lo pueda ayudar: stackoverflow.com/questions/12947620/…
Hiren Patel
1
@ user2757064 bueno, esta pregunta debería ayudar a la otra pregunta que vinculó. Esa pregunta se hizo 3 años después de esto. :)
Sufian

Respuestas:

48

No uses un reg-ex.

Aparentemente, el siguiente es un registro que valida correctamente la mayoría de las direcciones de correo electrónico que cumplen con RFC 2822 , (y aún fallará en cosas como "[email protected]", como lo hará org.apache.commons.validator. rutinas.Validator de correo electrónico)

(?:[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])+)\])

Posiblemente, la forma más fácil de validar un correo electrónico es simplemente enviar un correo electrónico de confirmación a la dirección proporcionada y que rebote y luego no sea válido.

Si desea realizar algunas comprobaciones básicas, puede comprobar que está en el formulario *@*

Si tiene alguna validación específica de lógica empresarial, puede realizarla utilizando una expresión regular, por ejemplo, debe ser una cuenta de gmail.com o algo así.

Cañada
fuente
55
Sé que esta respuesta tiene aproximadamente dos años, pero cuando pruebo esta expresión regular usando regexr.com, valida [email protected]e incluso más tiempo como .museum. ¿Me estoy perdiendo de algo? No quiero bloquear a ninguno de mis usuarios al no validar su dirección de correo electrónico válida, pero esto parece estar funcionando para todo lo que se me ocurre.
Bob Vork
@Bob valida la dirección de correo electrónico en el servidor ... comprueba la aplicación cuadrangular que hace lo mismo
Harsha MV
107
Estoy un poco confundido por qué comienza esta respuesta con "No use un reg-ex" y luego proceda a proporcionar un reg-ex.
howettl
77
Por favor sigue leyendo. A continuación se encuentra una mejor solución que no utiliza expresiones regulares.
loeschg
1
@Glen. ¿Sería esto cierto para el patrón de Android ? EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
zulkarnain shah
1036

Otra opción son los patrones integrados que comienzan con el nivel 8 de API:

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

Fuente visible de patrones

O

Solución de una línea de @AdamvandenHoven:

public final static boolean isValidEmail(CharSequence target) {
  return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
mindriot
fuente
30
+1, pero prefiero reemplazar el (target == null)con TextUtils.isEmpty(target):)
Houcine
36
Respuestas como estas son las razones por las que no me gustan las respuestas aceptadas que se muestran arriba, en lugar de las respuestas con la mayoría de los votos.
Jeshurun
11
¿No tendría más sentido (legibilidad sabia) simplemente combinar esto en una línea: return! TextUtils.isEmpty (target) && android.util.Patterns.EMAIL_ADDRESS.matcher (target) .matches ();
Adam van den Hoven
1
@Houcine, verdadero, pero el método anterior devuelve boolean, por lo que no tenemos esa información cuando es falsa. De todos modos, uno puede brindar o actualizar la interfaz de usuario desde el interior de la función (debe ejecutarse en el hilo de la interfaz de usuario). Para aquellos como yo, que están validando un correo electrónico obtenido mediante programación y sin interacción del usuario, podemos seguir con '== nulo' y tal vez ahorrar un par de ciclos de reloj en la mayoría de los casos.
AJ
2
Ten cuidado. Este comparador acepta [email protected]como correo electrónico válido
Joaquin Iurchuk
101

El siguiente patrón se usa en el correo 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}" +
          ")+"
      );

Puedes usar la función

private boolean checkEmail(String email) {
        return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}
Andrei Buneyeu
fuente
74
¿Por qué no usar android.util.Patterns.EMAIL_ADDRESS?
Sergey Metlov
99
porque existe desde API Nivel 8 solamente
Andrei Buneyeu
esto me ayudó mucho gracias y +1 por la respuesta simple .. :)
Deepthi
FYI: dentro de las clases de caracteres, los metacaracteres son mucho menos numerosos y el guión se escapa automáticamente cuando se coloca en un borde, puede simplificar la primera clase [a-zA-Z0-9+._%-]y las demás a[a-zA-Z0-9-]
Robin
Esto solo devuelve verdadero si la sintaxis del correo electrónico es la misma que el correo electrónico, traté de eliminar ide @gmail.comella devolverá verdadero. Lo mismo en `@yaho.com.
RoCk RoCk
70

Desde API 8 (android 2.2) hay un patrón: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Para que pueda usarlo para validar suEmailString:

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

devuelve verdadero si el correo electrónico es válido

UPD: este código fuente de patrón es:

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

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

Para que pueda compilarlo usted mismo para compatibilidad con API <8.

Luten
fuente
45

Tenemos un simple patrón de correspondencia de correo electrónico ahora

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

Use un código simple de una línea para la validación de correo electrónico

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

usar como ...

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

Estas son sugerencias de Android Studio:

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
Matteo
fuente
1
cheque nulo email == nulles redandunt como textutils cheques dentro
Volodymyr
@VolodymyrKhodonovych tiene razón, pero la verificación nula se realiza en un estado OR, no hacerlo podría generar una NPE al pasar el correo electrónico al método matcher ().
Matteo
11

Puede usar expresiones regulares para hacerlo. Algo como lo siguiente.

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

String email = "[email protected]";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Nota: Verifique la expresión regular dada anteriormente, no la use como está.

Mudassir
fuente
3
Esta falla en la siguiente dirección de correo electrónico válida: "Example Guy" <[email protected]>. Si bien técnicamente puede validar el correo electrónico con una expresión regular , es un poco absurdo hacerlo.
Cory Petosky
1
Sin embargo, eso no es solo una dirección de correo electrónico.
Brill Pappin el
11

use android: inputType = "textEmailAddress" como se muestra a continuación:

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

y:

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

Podrías escribir una extensión de Kotlin como esta:

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

Y luego llámalo así:

email.isValidEmail()
Danilo Lemes
fuente
¿Quién es "Patrones"?
Jemshit Iskenderov
android.util.Patterns
Danilo Lemes
9

Hay una Patternsclase en el paquete android.utilque es beneficiosa aquí. A continuación se muestra el método que siempre uso para validar el correo electrónico y muchas otras cosas.

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

Llame a este método donde desee validar la identificación de correo electrónico.

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;
   }
}
Sumit Sharma
fuente
5

Para una validación de correo electrónico, Android proporciona un patrón InBuilt. Pero solo es compatible con el nivel de API 8 y superior .

Aquí hay un código para usar ese patrón para verificar la validación del correo electrónico.

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

Asegúrese de que después de ejecutar este método, debe verificar que si este método devuelve verdadero, entonces permite guardar el correo electrónico y si este método devuelve falso , muestre el mensaje de que el correo electrónico es "No válido".

Espero que obtengas tu respuesta, gracias.

AMI CHARADAVA
fuente
4

¿Puedo recomendar ENCARECIDAMENTE que no intentes 'validar' las direcciones de correo electrónico, solo te meterás en un montón de trabajo sin una buena razón?

Solo asegúrese de que lo que ingrese no rompa su propio código, por ejemplo, sin espacios o caracteres ilegales que puedan causar una excepción.

Cualquier otra cosa solo le causará mucho trabajo por un retorno mínimo ...


fuente
3
Al trabajar con suscripciones y pagos, este no es un consejo útil. Si alguien olvida su contraseña, debemos tener una forma de restablecerla de manera segura para permitirle continuar usando el servicio que ha pagado. Entonces, a veces es mejor que nos aseguremos de que ingresen una dirección de correo electrónico válida por su propio bien.
Dean Wild
1
Solo para que quede claro lo que dije: si alguien tiene la intención de ingresar una dirección falsa / incorrecta, ninguna cantidad de validación los detendrá. Verificar errores tontos como espacios y no '@', etc. está bien, verificar cualquier otra cosa es bien en 'rendimientos decrecientes' ...
3
La única forma de identificar un correo electrónico falso es mediante el envío de un correo electrónico a esa identificación de correo electrónico y verificar si recibe un informe no entregado ...
Sreekanth Karumanaghat
John, muchos usuarios no intentarán ingresar una dirección falsa / incorrecta, pero pueden ingresarla incorrectamente por accidente. Por lo tanto, realizar una verificación simple puede ser muy útil y, como se muestra en la respuesta de mindriot, no es mucho trabajo. Según mi experiencia, la mayoría de las personas ingresan sus direcciones de correo electrónico correctamente, y los pocos correos electrónicos no válidos a menudo parecen ser errores tipográficos inocentes.
prohibición de geoingeniería el
Si es importante que el correo electrónico del usuario funcione, envíe un correo electrónico de confirmación. Todo lo demás es una tontería.
El increíble Jan
4

Valide su formato de dirección de correo electrónico. [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();
}
Virag Brahme
fuente
3
    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;
}
Atif Mahmood
fuente
2

Si está utilizando API 8 o superior, puede usar la Patternsclase fácilmente disponible para validar el correo electrónico. Código de muestra:

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

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

Por casualidad, si incluso admite un nivel de API inferior a 8, simplemente puede copiar el Patterns.javaarchivo en su proyecto y hacer referencia a él. Puede obtener el código fuente Patterns.javade este enlace

Mahendra Liya
fuente
2

Aquí está 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 lo igualará 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, -)

Ejemplo de correo electrónico de un partido especial

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

Puede modificar este patrón para su caso y luego validarlo

fun isValidEmail(email: String): Boolean {
    return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}
Phan Van Linh
fuente
1

Pruebe este método simple que no puede aceptar la dirección de correo electrónico que comienza con dígitos:

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;
}
Arman
fuente
1

Prueba este código ... Realmente funciona ...

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

Lo siguiente fue usado por mí. Sin embargo, contiene caracteres adicionales que los correos electrónicos normales, pero esto fue un requisito para mí.

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

Respuesta a esta pregunta: - Requisito para validar una dirección de correo electrónico con puntos dados

Explicación-

  1. (?!. *? ..) "Negative Lookhead" para negar 2 puntos consecutivos.
  2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Al menos un carácter definido. ("\" se usa para escapar).
  3. @ Puede haber una "@".
  4. [A-Za-z0-9] + luego al menos un carácter definido.
  5. [A-Za-z0-9 -.] * Cero o cualquier repetición de carácter definido.
  6. [A-Za-z0-9] + Al menos un personaje después del punto.
Vipin Sharma
fuente
1

La clave aquí es que desea validar completamente la dirección de correo electrónico. No solo desea verificar si la corrección sintáctica es correcta, sino verificar si la dirección de correo electrónico es real.

Dos razones obvias: los usuarios reales a menudo escriben mal sus direcciones de correo electrónico y algunos usuarios pueden ingresar direcciones de correo electrónico falsas. Por lo tanto, desea hacer una verificación sintáctica y una verificación de existencia.

La mejor manera de hacer esto que he encontrado en Android es usar la API gratuita de validación de Cloudmersive para esto.

El código se ve así:

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

Estoy usando esto en todas mis aplicaciones y es genial porque puedo validar las direcciones de correo electrónico en la UX en el punto de entrada.

5377037
fuente
1

La solución más simple de Kotlin usando funciones de extensión:

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

y luego puedes validar así:

"[email protected]".isEmailValid()
Gulzar Bhat
fuente
0

Tenga en cuenta que la mayoría de las expresiones regulares no son válidas para nombres de dominio internacionales (IDN) y nuevos dominios de nivel superior como .mobi o .info (si verifica los códigos de país o .org, .com, .gov, etc.).

Una verificación válida debe separar la parte local (antes del signo de at) y la parte del dominio. También debe considerar la longitud máxima de la parte local y el dominio (en suma 255 caracteres, incluido el signo de at).

El mejor enfoque es transformar la dirección en un formato compatible con IDN (si es necesario), validar la parte local (RFC), verificar la longitud de la dirección y verificar la disponibilidad del dominio (búsqueda DNS MX) o simplemente enviar un correo electrónico .

Thorsten
fuente
0

He usado el siguiente código. Esto funciona bien. Espero que esto te ayude.

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

y utilice el siguiente método. Esto devuelve verdadero si el correo electrónico es válido.

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

El correo electrónico es su correo electrónico.

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

    }
kyogs
fuente
0

Para los amantes de las expresiones regulares, el mejor patrón de correo electrónico (por ejemplo, compatible con RFC 822) que he encontrado desde ahora es el siguiente (antes de los filtros suministrados por PHP). Supongo que es fácil traducir esto a Java, para aquellos que juegan 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 ;
}
hornetbzz
fuente
0

Puede hacer cualquier tipo de validación en Android muy fácilmente mediante el archivo oval.jar. OVal es un marco de validación de propósito general pragmático y extensible para cualquier tipo de objetos Java.

siga este enlace: http://oval.sourceforge.net/userguide.html

Puede descargar esto desde aquí: http://oval.sourceforge.net/userguide.html#download

Puede usar la validación configurando etiquetas en 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));
                }
            }
        }
}
Muhammad Aamir Ali
fuente
0

También podrías usar

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

Si el correo electrónico no es válido, arrojará una excepción de dirección .

Desafortunadamente, Android no admite jndi-dns , pero solo para darle una idea de una validación de correo electrónico más potente, puede usarla para validar el dominio de correo electrónico. Tal vez un gurú de Android podría ayudar y mostrar si hay alternativas similares ... Un ejemplo de implementación con Java "regular" está disponible aquí .

EDITAR

Me acabo de dar cuenta de que javax.mail tampoco es compatible ... Pero esta publicación muestra una solución alternativa .

Bob Rivers
fuente