Bagaimana saya harus memvalidasi alamat email?


320

Apa teknik yang baik untuk memvalidasi alamat email (mis. Dari bidang input pengguna) di Android? org.apache.commons.validator.routines.EmailValidator tampaknya tidak tersedia. Apakah ada perpustakaan lain yang melakukan ini yang sudah termasuk dalam Android atau haruskah saya menggunakan RegExp?


silakan rujuk yang ini, semoga akan membantu Anda: stackoverflow.com/questions/12947620/…
Hiren Patel

1
@ user2757064 baik pertanyaan ini akan membantu pertanyaan lain yang Anda tautkan. Pertanyaan itu diajukan 3 tahun setelah ini. :)
Sufian

Jawaban:


48

Jangan gunakan reg-ex.

Rupanya yang berikut ini adalah reg-ex yang secara benar memvalidasi sebagian besar alamat email yang sesuai dengan RFC 2822 , (dan masih akan gagal pada hal-hal seperti "user@gmail.com.nospam", seperti yang akan 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])+)\])

Mungkin cara termudah untuk memvalidasi email hanya mengirim email konfirmasi ke alamat yang diberikan dan itu memantul maka itu tidak valid.

Jika Anda ingin melakukan beberapa pemeriksaan dasar, Anda bisa mengeceknya dalam formulir *@*

Jika Anda memiliki beberapa validasi logika bisnis khusus maka Anda dapat melakukan itu menggunakan regex, misalnya harus menjadi akun gmail.com atau sesuatu.


5
Saya tahu jawaban ini sekitar dua tahun, tetapi ketika saya mencoba regex ini menggunakan regexr.com, itu memvalidasi user@gmail.com.nospam, dan bahkan lebih lama lagi seperti .museum. Apakah saya melewatkan sesuatu? Saya tidak ingin memblokir salah satu pengguna saya dengan gagal memvalidasi alamat email mereka yang valid, tetapi ini tampaknya berfungsi untuk apa pun yang dapat saya pikirkan.
Bob Vork

@ Bob memvalidasi Alamat Email di server .. periksa aplikasi foursquare itu melakukan hal yang sama
Harsha MV

107
Saya agak bingung mengapa Anda memulai jawaban ini dengan "Jangan gunakan reg-ex" dan kemudian lanjutkan untuk memberikan reg-ex.
howettl

7
Silakan terus membaca. Solusi yang lebih baik di bawah ini yang tidak menggunakan regex.
loeschg

1
@Glen. Apakah ini berlaku untuk Pola Android . EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
zulkarnain shah

1036

Opsi lain adalah Pola bawaan yang dimulai dengan 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();
  }
}

Sumber yang dapat dilihat pola

ATAU

Solusi satu baris dari @AdamvandenHoven:

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

30
+1, tetapi saya lebih suka mengganti (target == null)dengan TextUtils.isEmpty(target):)
Houcine

36
Jawaban seperti inilah mengapa saya tidak suka jawaban yang diterima ditampilkan di atas, bukan jawaban dengan suara terbanyak.
Jeshurun

11
Apakah lebih masuk akal (lebih mudah dipahami) untuk hanya menggabungkan ini menjadi satu baris: return! TextUtils.isEmpty (target) && android.util.Patterns.EMAIL_ADDRESS.matcher (target) .matches ();
Adam van den Hoven

1
@ Houcine, benar tetapi metode di atas mengembalikan boolean sehingga kami tidak memiliki informasi itu ketika itu salah. Bagaimanapun, seseorang dapat bersulang atau memperbarui ui dari dalam fungsi (harus dijalankan di utas UI). Bagi mereka seperti saya, yang memvalidasi email yang diperoleh secara terprogram dan tanpa interaksi pengguna apa pun, kita bisa tetap menggunakan '== null' dan mungkin menyimpan beberapa siklus jam dalam banyak kasus.
AJ

2
Hati-hati. Pencocokan ini menerima email@111.222.333.44444sebagai email yang valid
Joaquin Iurchuk

101

Pola selanjutnya digunakan dalam surat 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}" +
          ")+"
      );

Anda dapat menggunakan fungsi

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

74
Kenapa tidak digunakan android.util.Patterns.EMAIL_ADDRESS?
Sergey Metlov

9
sebab itu ada sejak API Level 8 saja
Andrei Buneyeu

ini banyak membantu saya, terima kasih dan +1 untuk jawaban sederhana .. :)
Deepthi

FYI: di dalam kelas karakter metacharacters lebih sedikit dan tanda hubung secara otomatis lolos ketika diletakkan di perbatasan, Anda dapat menyederhanakan kelas pertama ke [a-zA-Z0-9+._%-]dan yang lain untuk[a-zA-Z0-9-]
Robin

Hal ini hanya mengembalikan true jika sintaks email sama dengan email tidak, saya mencoba untuk menghapus idari @gmail.comitu akan kembali benar. Sama di `@yaho.com.
RoCk RoCk

70

Sejak API 8 (android 2.2) ada pola: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Jadi Anda bisa menggunakannya untuk memvalidasi yourEmailString Anda:

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

mengembalikan true jika email tersebut valid

UPD: Kode sumber pola ini adalah:

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

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

Jadi, Anda dapat membuatnya sendiri untuk kompatibilitas dengan API <8.


45

Kami memiliki pencocokan pola Email sederhana sekarang

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

19

Gunakan kode satu baris sederhana untuk Validasi email

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

gunakan seperti ...

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

15

Ini adalah saran Android Studio:

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

1
null check email == nulladalah redandunt karena TextUtils memeriksanya di dalam
Volodymyr

@VolodymyrKhodonovych Anda benar, tetapi pemeriksaan nol dilakukan dalam keadaan ATAU, tidak melakukan hal ini dapat menyebabkan NPE saat mengirim email ke metode matcher ().
Matteo

11

Anda dapat menggunakan ekspresi reguler untuk melakukannya. Sesuatu seperti yang berikut ini.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Catatan: Periksa ekspresi reguler yang diberikan di atas, jangan gunakan apa adanya.


3
Ini gagal pada alamat email yang valid berikut: "Example Guy" <guy@example.com>. Meskipun secara teknis Anda dapat memvalidasi email dengan regex , agak tidak masuk akal untuk melakukannya.
Cory Petosky

1
Itu bukan hanya alamat email.
Brill Pappin

11

gunakan android: inputType = "textEmailAddress" seperti di bawah ini:

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

dan:

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

11

Anda dapat menulis ekstensi Kotlin seperti ini:

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

Dan menyebutnya seperti ini:

email.isValidEmail()

siapa "Pola"?
Jemshit Iskenderov

android.util.Patterns
Danilo Lemes

9

Ada Patternskelas dalam paket android.utilyang bermanfaat di sini. Di bawah ini adalah metode yang selalu saya gunakan untuk memvalidasi email dan banyak hal lainnya

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

5

Panggil Metode Ini di mana Anda ingin memvalidasi ID email.

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

5

Untuk Android validasi Email, berikan beberapa Pola InBuilt . Tapi itu hanya mendukung API level 8 ke atas .

Berikut adalah kode untuk menggunakan pola itu untuk memeriksa validasi email.

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

Pastikan bahwa setelah menjalankan metode ini Anda harus memeriksa bahwa jika metode ini mengembalikan true maka Anda mengizinkan untuk menyimpan email dan jika metode ini kembali salah maka tampilkan pesan bahwa email itu "Tidak Valid".

Semoga Anda mendapatkan jawaban Anda, Terima kasih.


4

Dapatkah saya SANGAT merekomendasikan Anda tidak mencoba 'memvalidasi' alamat email, Anda hanya akan mendapatkan banyak pekerjaan tanpa alasan yang baik.

Pastikan saja apa yang dimasukkan tidak akan merusak kode Anda sendiri - mis. Tidak ada spasi atau karakter ilegal yang dapat menyebabkan Pengecualian.

Hal lain hanya akan menyebabkan Anda banyak pekerjaan untuk pengembalian minimal ...


3
Ketika bekerja dengan langganan dan pembayaran, saran ini hampir tidak berguna. Jika seseorang lupa kata sandi mereka, kami harus memiliki cara mengatur ulang kata sandi mereka secara aman agar mereka dapat terus menggunakan layanan yang telah mereka bayar. Jadi terkadang yang terbaik adalah kita memastikan mereka memasukkan alamat email yang valid untuk kepentingan mereka sendiri.
Dean Wild

1
Hanya untuk memperjelas apa yang saya katakan - jika seseorang berniat memasukkan alamat palsu / salah - tidak ada jumlah validasi yang akan menghentikan mereka .. Memeriksa kesalahan konyol seperti spasi dan tidak ada '@' dll baik-baik saja - memeriksa hal lain adalah jauh menjadi 'hasil berkurang' ...

3
Satu-satunya cara untuk mengidentifikasi email palsu adalah melalui mengirim email ke id email itu dan memeriksa apakah Anda menerima laporan yang tidak terkirim ...
Sreekanth Karumanaghat

John, banyak pengguna tidak akan bermaksud memasukkan alamat palsu / salah, tetapi mungkin memasukkannya secara tidak sengaja. Jadi melakukan pemeriksaan sederhana bisa sangat berguna dan, seperti yang ditunjukkan dalam jawaban mindriot, tidak banyak pekerjaan. Dari pengalaman saya, kebanyakan orang memasukkan alamat email mereka dengan benar, dan beberapa email tidak valid yang paling sering tampaknya adalah kesalahan ketik.
larangan geoengineering

Jika penting agar email pengguna berfungsi, Anda mengirim email konfirmasi. Yang lainnya omong kosong.
Jan

4

Validasikan format alamat email Anda. 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();
}

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

2

Jika Anda menggunakan API 8 atau lebih, Anda dapat menggunakan Patternskelas yang tersedia untuk memvalidasi email. Kode sampel:

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

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

Secara kebetulan jika Anda bahkan mendukung level API kurang dari 8, maka Anda cukup menyalin Patterns.javafile ke proyek Anda dan merujuknya. Anda bisa mendapatkan kode sumber Patterns.javadari tautan ini


2

Disini adalah 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 akan cocok jika

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

Contoh beberapa email pertandingan khusus

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

Anda dapat mengubah pola ini untuk kasus Anda kemudian divalidasi oleh

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

1

Coba metode sederhana ini yang tidak dapat menerima alamat email yang dimulai dengan angka:

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

1

Coba kode ini .. Ini benar-benar berfungsi ..

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

1

Mengikuti digunakan oleh saya. Namun itu berisi karakter tambahan dari email normal tetapi ini merupakan persyaratan bagi saya.

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

Jawaban dari pertanyaan ini: - Persyaratan untuk memvalidasi alamat email dengan poin yang diberikan

Penjelasan-

  1. (?!. *? ..) "Negative Lookhead" untuk meniadakan 2 titik berturut-turut.
  2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Setidaknya satu karakter yang ditentukan. ("\" digunakan untuk melarikan diri).
  3. @ Mungkin ada satu "@".
  4. [A-Za-z0-9] + lalu atleast satu karakter yang ditentukan.
  5. [A-Za-z0-9 -.] * Nol atau pengulangan karakter apa pun yang ditentukan.
  6. [A-Za-z0-9] + Setidaknya satu karakter setelah titik.

1

Kuncinya di sini adalah Anda ingin memvalidasi alamat email sepenuhnya. Anda tidak hanya ingin memeriksa kebenaran sintaksisnya, Anda ingin memeriksa apakah alamat emailnya asli.

Dua alasan yang jelas: pengguna nyata sering salah mengetik alamat email mereka, dan beberapa pengguna mungkin memasukkan alamat email palsu. Oleh karena itu, Anda ingin melakukan pemeriksaan sintaksis dan pemeriksaan keberadaan.

Cara terbaik untuk melakukan ini yang saya temukan di Android adalah dengan menggunakan API Validasi Cloudmersive gratis untuk ini.

Kode ini terlihat seperti ini:

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

Saya menggunakan ini di semua aplikasi saya dan itu bagus karena saya dapat memvalidasi alamat email di UX pada titik masuk.


1

Solusi Kotlin sederhana menggunakan fungsi ekstensi:

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

dan kemudian Anda dapat memvalidasi seperti ini:

"testemail6589@gmail.com".isEmailValid()

0

Perhatikan bahwa sebagian besar ekspresi reguler tidak valid untuk nama domain internasional (IDN) dan domain tingkat atas baru seperti .mobi atau .info (jika Anda memeriksa kode negara atau .org, .com, .gov, dan sebagainya).

Pemeriksaan yang valid harus memisahkan bagian lokal (sebelum tanda-di) dan bagian domain. Anda juga harus mempertimbangkan panjang maksimal bagian dan domain lokal (dalam jumlah 255 karakter termasuk pada tanda).

Pendekatan terbaik adalah mengubah alamat dalam format IDN yang kompatibel (jika diperlukan), memvalidasi bagian lokal (RFC), memeriksa panjang alamat dan memeriksa ketersediaan domain (pencarian DNS MX) atau cukup mengirim email .



0

Saya telah menggunakan kode follwing. Ini berfungsi. Saya harap ini akan membantu Anda.

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

dan gunakan metode follwing. Ini mengembalikan true jika email valid.

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

0

email adalah email-is Anda.

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

    }

0

Untuk pecinta regex, pola email terbaik (misalnya konsisten dengan RFC 822) yang pernah saya temukan sejak sekarang adalah yang berikut (sebelum filter yang disediakan PHP). Saya kira mudah untuk menerjemahkan ini ke dalam Java - bagi mereka yang bermain dengan 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 ;
}

0

Anda dapat melakukan semua jenis validasi di android dengan sangat mudah menggunakan file oval.jar. OVal adalah kerangka kerja validasi tujuan umum pragmatis dan dapat diperluas untuk segala jenis objek Java.

ikuti tautan ini: http://oval.sourceforge.net/userguide.html

Anda dapat menurunkan ini dari sini: http://oval.sourceforge.net/userguide.html#download

Anda dapat menggunakan validasi dengan menetapkan tag dalam variabel

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

0

Anda juga bisa menggunakannya

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

Jika email tidak valid maka akan membuang AddressException .

Sayangnya Android tidak mendukung jndi-dns , tetapi hanya untuk memberi Anda gambaran validasi email yang lebih kuat, Anda dapat menggunakannya untuk memvalidasi domain email. Mungkin seorang guru Android dapat membantu dan menunjukkan jika ada alternatif yang serupa ... Contoh implementasi dengan java "reguler" tersedia di sini .

EDIT

Saya baru menyadari bahwa javax.mail juga tidak mendukung ... Tapi pos ini menunjukkan solusi .

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.