Jak powinienem zweryfikować adres e-mail?

320

Jaka jest dobra technika sprawdzania poprawności adresu e-mail (np. Z pola wprowadzania użytkownika) w systemie Android? org.apache.commons.validator.routines.EmailValidator nie wydaje się być dostępny. Czy robią to inne biblioteki, które są już zawarte w Androidzie, czy też muszę korzystać z RegExp?

znq
źródło
proszę odnieść się do tego, niech ci to pomoże: stackoverflow.com/questions/12947620/…
Hiren Patel 15.04.2013
1
@ user2757064 cóż, to pytanie powinno pomóc w innym pytaniu, które podłączyłeś. To pytanie zostało zadane 3 lata później. :)
Sufian

Odpowiedzi:

48

Nie używaj reg-ex.

Najwyraźniej poniżej znajduje się reg-ex, który poprawnie sprawdza poprawność większości adresów e-mail zgodnych z RFC 2822 (i nadal nie powiedzie się na przykładach takich jak „uż[email protected]”, podobnie jak 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])+)\])

Być może najprostszym sposobem na sprawdzenie poprawności wiadomości e-mail jest wysłanie wiadomości e-mail z potwierdzeniem na podany adres. Odbija się, a następnie jest nieważna.

Jeśli chcesz wykonać podstawowe kontrole, możesz po prostu sprawdzić, czy jest w formularzu *@*

Jeśli masz jakieś zatwierdzenie specyficzne dla logiki biznesowej, możesz to zrobić za pomocą wyrażenia regularnego, np. Musi to być konto gmail.com lub coś takiego.

Dolina górska
źródło
5
Wiem, że ta odpowiedź ma około dwóch lat, ale kiedy próbuję tego wyrażenia regularnego za pomocą regexr.com, sprawdza się [email protected], a nawet dłużej, jak .museum. Czy coś brakuje? Nie chcę blokować żadnego z moich użytkowników, nie weryfikując ich prawidłowego adresu e-mail, ale wydaje się, że działa to na wszystko, co tylko mogę wymyślić.
Bob Vork,
@ Bob sprawdza adres e-mail na serwerze .. sprawdź aplikację foursquare robi to samo
Harsha MV,
107
Jestem trochę zdezorientowany, dlaczego zaczynasz tę odpowiedź od „Nie używaj reg-ex”, a następnie przejdź do dostarczenia reg-ex.
howettl
7
Proszę czytaj dalej. Lepszym rozwiązaniem jest poniżej, które nie używa wyrażenia regularnego.
loeschg
1
@Glen. Czy dotyczy to wzorca Androida . EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
zulkarnain shah
1036

Inną opcją są wbudowane Wzory zaczynające się od API Poziom 8:

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

Widoczne źródło wzorów

LUB

Jedno liniowe rozwiązanie @AdamvandenHoven:

public final static boolean isValidEmail(CharSequence target) {
  return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
Mindriot
źródło
30
+1, ale wolę zastąpić (target == null)z TextUtils.isEmpty(target):)
Houcine
35
Odpowiedzi takie jak te sprawiają, że nie lubię akceptowanych odpowiedzi wyświetlanych na górze, zamiast odpowiedzi z większością głosów.
Jeshurun
11
Czy nie byłoby sensowniej (pod względem czytelności) po prostu połączyć to w jedną linię: return! TextUtils.isEmpty (target) && android.util.Patterns.EMAIL_ADDRESS.matcher (target) .matches ();
Adam van den Hoven
1
@Houcine, prawda, ale powyższa metoda zwraca wartość logiczną, więc nie mamy tych informacji, gdy są fałszywe. W każdym razie można wznieść toast lub zaktualizować interfejs użytkownika z wnętrza funkcji (musi być uruchomiony w wątku interfejsu użytkownika). Dla takich jak ja, którzy sprawdzają pocztę e-mail uzyskaną programowo i bez żadnej interakcji użytkownika, możemy po prostu trzymać się „== null” i w większości przypadków zaoszczędzić kilka cykli zegara.
AJ
2
Bądź ostrożny. Ten dopasowywacz przyjmuje [email protected]jako prawidłowy e
Joaquin Iurchuk
101

Następny wzór jest używany w poczcie 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}" +
          ")+"
      );

Możesz użyć funkcji

private boolean checkEmail(String email) {
        return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}
Andrei Buneyeu
źródło
74
Dlaczego nie użyć android.util.Patterns.EMAIL_ADDRESS?
Siergiej Metłow
9
ponieważ istnieje od wersji API tylko 8
Andrei Buneyeu
pomogło mi to bardzo dzięki i +1 za prostą odpowiedź .. :)
Deepthi
FYI: w klasach postaci metaznaki są znacznie mniejsze, a łącznik jest automatycznie uciekany po umieszczeniu na granicy, możesz uprościć pierwszą klasę [a-zA-Z0-9+._%-]i pozostałe[a-zA-Z0-9-]
Robin
Zwraca to tylko prawda, jeśli składnia wiadomości e-mail jest taka sama, jak adres e-mail, próbowałem usunąć iz @gmail.comniej wartość true. To samo w `@yaho.com.
RoCk RoCk
70

Od API 8 (Android 2.2) istnieje wzorzec: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Możesz więc użyć go do sprawdzenia poprawności e-maila:

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

zwraca true, jeśli adres e-mail jest prawidłowy

UPD: Kod źródłowy tego wzoru to:

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

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

Możesz więc zbudować go samodzielnie dla kompatybilności z API <8.

Luten
źródło
45

Mamy teraz prosty dopasowywanie wzorców e-maili

 private static boolean isValidEmail(String email) {
        return !TextUtils.isEmpty(email) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
    }
Salman Nazir
źródło
19

Użyj prostego kodu jednokreskowego do sprawdzania poprawności wiadomości e-mail

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

użyj jak ...

if (!isValidEmail(yourEdittext.getText().toString()) {
    Toast.makeText(context, "your email is not valid", 2000).show();
}
Pankaj Talaviya
źródło
15

Oto sugestie Android Studio:

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
Matteo
źródło
1
czek zerowy email == nulljest redandunt, ponieważ TextUtils sprawdza go w środku
Wołodymyr,
@VolodymyrKhodonovych masz rację, ale sprawdzanie wartości zerowej odbywa się w stanie OR, nie zrobienie tego może prowadzić do NPE podczas przekazywania wiadomości e-mail do metody matcher ().
Matteo,
11

Możesz użyć do tego wyrażenia regularnego. Coś takiego jak poniżej.

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

String email = "[email protected]";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Uwaga: Sprawdź podane powyżej wyrażenie regularne, nie używaj go takim, jakim jest.

Mudassir
źródło
3
To nie działa na następującej ważnego adresu e-mail: "Example Guy" <[email protected]>. Chociaż technicznie możesz sprawdzić poprawność wiadomości e-mail za pomocą wyrażenia regularnego , jest to trochę absurdalne.
Cory Petosky
1
To nie tylko adres e-mail.
Brill Pappin
11

użyj Androida: inputType = "textEmailAddress" jak poniżej:

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

i:

       boolean isEmailValid(CharSequence email) {
        return android.util.Patterns.EMAIL_ADDRESS.matcher(email)
                .matches();
      }
Victor Odiah
źródło
11

Możesz napisać rozszerzenie Kotlin w następujący sposób:

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

A potem nazwij to tak:

email.isValidEmail()
Danilo Lemes
źródło
kim jest „Wzory”?
Jemshit Iskenderov
android.util.Patterns
Danilo Lemes
9

Istnieje Patternspakiet w pakiecie, android.utilktóry jest tutaj korzystny. Poniżej znajduje się metoda, której zawsze używam do sprawdzania poprawności wiadomości e-mail i wielu innych rzeczy

private boolean isEmailValid(String email) {
    return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
Jimit Patel
źródło
5

Zadzwoń do tej metody, pod którą chcesz zweryfikować identyfikator 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;
   }
}
Sumit Sharma
źródło
5

W przypadku sprawdzania poprawności adresu e-mail Android udostępnia wzorzec InBuilt. Ale obsługuje tylko interfejs API w wersji 8 i wyższej .

Oto kod używający tego wzorca do sprawdzania poprawności wiadomości e-mail.

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

Upewnij się, że po wykonaniu tej metody powinieneś sprawdzić, czy jeśli ta metoda zwróci wartość true, możesz pozwolić na zapisanie wiadomości e-mail, a jeśli ta metoda zwróci wartość false, wyświetl komunikat, że wiadomość e-mail jest „nieprawidłowa”.

Mam nadzieję, że dostaniesz odpowiedź, dziękuję.

AMI CHARADAVA
źródło
4

Czy mogę KONIECZNIE zalecić, aby nie próbować „sprawdzać poprawności” adresów e-mail, po prostu dostaniesz się do pracy bez powodu.

Tylko upewnij się, że to, co jest wprowadzone, nie złamie twojego kodu - np. Nie będzie spacji lub niedozwolonych znaków, które mogłyby spowodować wyjątek.

Wszystko inne spowoduje tylko dużo pracy przy minimalnym zwrocie ...


źródło
3
Podczas pracy z subskrypcjami i płatnościami nie jest to przydatna rada. Jeśli ktoś zapomni hasło, musimy mieć możliwość bezpiecznego zresetowania hasła, aby umożliwić mu dalsze korzystanie z usługi, za którą zapłacono. Czasami więc najlepiej jest upewnić się, że wprowadzają prawidłowy adres e-mail dla siebie.
Dean Wild
1
Żeby wyjaśnić, co powiedziałem - jeśli ktoś chce wprowadzić fałszywy / zły adres - żadna weryfikacja go nie zatrzyma. Sprawdzanie głupich błędów, takich jak spacje i brak „@” itp., Jest w porządku - sprawdzanie czegokolwiek innego jest w „malejących zwrotach” ...
3
Jedynym sposobem zidentyfikowania fałszywej wiadomości e-mail jest wysłanie wiadomości e-mail na ten identyfikator wiadomości e-mail i sprawdzenie, czy otrzymasz niedostarczony raport ...
Sreekanth Karumanaghat
John, wielu użytkowników nie będzie chciało wprowadzić fałszywego / złego adresu, ale może wprowadzić go niepoprawnie przez przypadek. Wykonanie prostej kontroli może być bardzo przydatne i, jak pokazano w odpowiedzi Mindriota, nie wymaga dużo pracy. Z mojego doświadczenia wynika, że ​​większość osób poprawnie wpisuje adresy e-mail, a kilka nieprawidłowych e-maili najczęściej wydaje się być spowodowanych niewinną literówką.
zakaz geoinżynierii
Jeśli ważne jest, aby e-mail użytkownika działał, wyślij wiadomość e-mail z potwierdzeniem. Cała reszta to bzdury.
Niesamowity
4

Sprawdź poprawność formatu adresu e-mail. [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
źródło
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
źródło
2

Jeśli używasz interfejsu API 8 lub nowszego, możesz użyć łatwo dostępnej Patternsklasy do sprawdzania poprawności wiadomości e-mail. Przykładowy kod:

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

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

Przypadkowo, jeśli w ogóle obsługujesz poziom API mniejszy niż 8, możesz po prostu skopiować Patterns.javaplik do swojego projektu i odwołać się do niego. Możesz pobrać kod źródłowy Patterns.javaz tego linku

Mahendra Liya
źródło
2

Tutaj jest 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 dopasuje to, jeśli

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

Przykład jakiegoś specjalnego adresu e-mail

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

Możesz zmodyfikować ten wzór dla swojej sprawy, a następnie zatwierdzić przez

fun isValidEmail(email: String): Boolean {
    return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}
Phan Van Linh
źródło
1

Wypróbuj tę prostą metodę, która nie może zaakceptować adresu e-mail zaczynającego się od cyfr:

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
źródło
1

Wypróbuj ten kod .. To naprawdę działa ..

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

Wykorzystałem następujące. Zawiera jednak dodatkowe znaki niż zwykłe wiadomości e-mail, ale był to dla mnie wymóg.

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

Odpowiedź na to pytanie: - Wymóg potwierdzenia adresu e-mail z podanymi punktami

Wyjaśnienie-

  1. (?!. *? ..) „Negative Lookhead”, aby zanegować 2 kolejne kropki.
  2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Zdefiniowano co najmniej jeden znak. („\” służy do zmiany znaczenia).
  3. @ Może być jeden „@”.
  4. [A-Za-z0-9] + następnie zdefiniowano co najmniej jeden znak.
  5. [A-Za-z0-9 -.] * Zero lub dowolne zdefiniowane powtórzenie znaku.
  6. [A-Za-z0-9] + Przynajmniej jeden znak po kropce.
Vipin Sharma
źródło
1

Kluczem tutaj jest to, że chcesz w pełni zweryfikować adres e-mail. Nie chcesz tylko sprawdzać poprawności składniowej, chcesz sprawdzić, czy adres e-mail jest prawdziwy.

Dwa oczywiste powody: prawdziwi użytkownicy często źle wpisują swoje adresy e-mail, a niektórzy użytkownicy mogą podawać fałszywe adresy e-mail. Dlatego chcesz wykonać kontrolę składniową i kontrolę istnienia.

Najlepszym sposobem na to, co znalazłem na Androidzie, jest użycie do tego darmowego API Cloudmersive Validation API .

Kod wygląda następująco:

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

Używam tego we wszystkich moich aplikacjach i jest to świetne, ponieważ mogę sprawdzić adresy e-mail w UX w punkcie wejścia.

5377037
źródło
1

Najprostsze rozwiązanie Kotlin wykorzystujące funkcje rozszerzeń:

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

a następnie możesz sprawdzić w następujący sposób:

"[email protected]".isEmailValid()
Gulzar Bhat
źródło
0

Pamiętaj, że większość wyrażeń regularnych jest niepoprawna dla międzynarodowych nazw domen (IDN) i nowych domen najwyższego poziomu, takich jak .mobi lub .info (jeśli sprawdzasz kody krajów lub .org, .com, .gov i tak dalej).

Prawidłowe sprawdzenie powinno oddzielić część lokalną (przed znakiem) i część domeny. Należy również wziąć pod uwagę maksymalną długość części lokalnej i domeny (łącznie 255 znaków, w tym znak at).

Najlepszym rozwiązaniem jest przekształcenie adresu w formacie zgodnym z IDN (jeśli jest wymagany), sprawdzenie części lokalnej (RFC), sprawdzenie długości adresu i sprawdzenie dostępności domeny (wyszukiwanie DNS MX) lub po prostu wysłanie wiadomości e-mail .

Thorsten
źródło
0

Użyłem następującego kodu. Działa to z rusztem. Mam nadzieję, że ci to pomoże.

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

i zastosuj metodę podążania. Zwraca wartość true, jeśli wiadomość e-mail jest poprawna.

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

email to twój 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();

    }
kyogs
źródło
0

Dla miłośników wyrażeń regularnych najlepszy (np. Zgodny z RFC 822) wzór wiadomości e-mail, jaki kiedykolwiek znalazłem, jest następujący (przed dostarczeniem filtrów PHP). Myślę, że łatwo jest to przetłumaczyć na Javę - dla osób grających z 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
źródło
0

Za pomocą pliku oval.jar możesz bardzo łatwo przeprowadzić dowolną weryfikację w systemie Android. OVal to pragmatyczne i rozszerzalne ogólne narzędzie do sprawdzania poprawności dla dowolnego rodzaju obiektów Java.

Śledź ten link: http://oval.sourceforge.net/userguide.html

Możesz pobrać to stąd: http://oval.sourceforge.net/userguide.html#download

Możesz użyć walidacji, ustawiając tagi w zmiennych

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
źródło
0

Możesz także użyć

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

Jeśli adres e-mail jest nieprawidłowy, wygeneruje wyjątek adresu .

Niestety, Android nie obsługuje jndi-dns , ale aby dać ci wyobrażenie o bardziej skutecznym sprawdzaniu poprawności wiadomości e-mail, możesz użyć jej do sprawdzenia domeny. Może guru od Androida mógłby pomóc i pokazać, czy istnieją podobne alternatywy ... Przykładowa implementacja z „regularną” javą jest dostępna tutaj .

EDYTOWAĆ

Właśnie zdałem sobie sprawę, że javax.mail nie obsługuje też ... Ale ten post pokazuje obejście .

Bob Rivers
źródło