Comment dois-je valider une adresse e-mail?


320

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?


s'il vous plaît se réfère à celui-ci, qu'il vous aide: stackoverflow.com/questions/12947620/…
Hiren Patel

1
@ user2757064 et cette question devrait aider l'autre question que vous avez liée. Cette question a été posée 3 ans après. :)
Sufian

Réponses:


48

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.


5
Je sais que cette réponse a environ deux ans, mais lorsque j'essaie cette expression régulière à l'aide de regexr.com, elle valide user@gmail.com.nospamet même des tld plus longs comme .museum. Suis-je en train de manquer quelque chose? Je ne veux bloquer aucun de mes utilisateurs en échouant à valider leur adresse e-mail valide, mais cela semble fonctionner pour tout ce à quoi je peux penser.
Bob Vork

@Bob valide l'adresse e-mail sur le serveur .. vérifiez l'application foursquare, il en va de même
Harsha MV

107
Je suis un peu confus pourquoi vous commencez cette réponse par "N'utilisez pas de reg-ex", puis continuez à fournir un reg-ex.
howettl

7
Continuez à lire. Une meilleure solution est ci-dessous qui n'utilise pas l'expression régulière.
loeschg

1
@Glen. Cela serait-il vrai pour le modèle d'Android . EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
zulkarnain shah

1036

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

30
+1, mais je préfère remplacer le (target == null)par TextUtils.isEmpty(target):)
Houcine

36
Des réponses comme celles-ci sont pourquoi je n'aime pas les réponses acceptées affichées en haut, au lieu des réponses avec la plupart des votes.
Jeshurun

11
Ne serait-il pas plus logique (en termes de lisibilité) de simplement combiner cela en une seule ligne: return! TextUtils.isEmpty (target) && android.util.Patterns.EMAIL_ADDRESS.matcher (target) .matches ();
Adam van den Hoven

1
@Houcine, true mais la méthode ci-dessus renvoie un booléen donc nous n'avons pas cette information quand elle est fausse. Quoi qu'il en soit, on peut porter un toast ou mettre à jour l'interface utilisateur depuis l'intérieur de la fonction (doit être exécuté dans le thread d'interface utilisateur). Pour ceux comme moi, qui valident un e-mail obtenu par programmation et sans aucune interaction avec l'utilisateur, nous pouvons simplement nous en tenir à '== null' et peut-être enregistrer quelques cycles d'horloge dans la plupart des cas.
AJ

2
Faites attention. Ce match accepte email@111.222.333.44444comme un email valide
Joaquin Iurchuk

101

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

74
Pourquoi ne pas utiliser android.util.Patterns.EMAIL_ADDRESS?
Sergey Metlov

9
car il existe depuis l'API niveau 8 uniquement
Andrei Buneyeu

cela m'a beaucoup aidé merci et +1 pour la réponse simple .. :)
Deepthi

FYI: à l'intérieur des classes de caractères, les métacaractères sont beaucoup moins nombreux et le trait d'union est automatiquement échappé lorsqu'il est placé à une bordure, vous pouvez simplifier la première classe [a-zA-Z0-9+._%-]et les autres[a-zA-Z0-9-]
Robin

Cela ne retourne vrai si la syntaxe e - mail est le même que le courrier électronique fait, j'ai essayé de retirer ide @gmail.comce retourne vrai. Idem dans `@yaho.com.
RoCk RoCk

70

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.


45

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

19

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

15

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

1
null check email == nullest redandunt comme TextUtils le vérifie à l'intérieur
Volodymyr

@VolodymyrKhodonovych vous avez raison, mais la vérification nulle est effectuée dans un état OU, ne pas le faire pourrait conduire à un NPE lors du passage de courrier électronique à la méthode matcher ().
Matteo

11

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.


3
Cela échoue sur l'adresse e - mail valide suivante: "Example Guy" <guy@example.com>. Bien que vous puissiez techniquement valider un e-mail avec une expression régulière , il est un peu absurde de le faire.
Cory Petosky

1
Ce n'est pas seulement une adresse e-mail.
Brill Pappin

11

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

11

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

qui est "Patterns"?
Jemshit Iskenderov

android.util.Patterns
Danilo Lemes

9

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

5

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

5

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.


4

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 ...


3
Lorsque vous travaillez avec des abonnements et des paiements, ce conseil n'est guère utile. Si quelqu'un oublie son mot de passe, nous devons avoir un moyen de réinitialiser son mot de passe en toute sécurité pour lui permettre de continuer à utiliser le service pour lequel il a payé. Il est donc parfois préférable que nous nous assurions qu'ils saisissent une adresse e-mail valide pour eux-mêmes.
Dean Wild

1
Juste pour être clair sur ce que j'ai dit - si quelqu'un a l'intention de saisir une fausse / mauvaise adresse - aucun montant de validation ne les arrêtera. bien dans les «rendements décroissants» ...

3
La seule façon d'identifier un faux e-mail est d'envoyer un e-mail à cet e-mail et de vérifier si vous recevez un rapport non remis ...
Sreekanth Karumanaghat

John, de nombreux utilisateurs n'auront pas l' intention de saisir une fausse / mauvaise adresse, mais peuvent la saisir incorrectement par accident. Ainsi, effectuer une simple vérification peut être très utile et, comme le montre la réponse de mindriot, ce n'est pas beaucoup de travail. D'après mon expérience, la plupart des gens saisissent correctement leurs adresses e-mail, et les quelques e-mails invalides semblent être le plus souvent dus à des fautes de frappe innocentes.
ban-geoengineering du

S'il est important que l'e-mail de l'utilisateur fonctionne, vous envoyez un e-mail de confirmation. Tout le reste est un non-sens.
L'incroyable

4

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

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

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


2

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

1

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

1

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

1

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.

1

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.


1

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

0

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 .



0

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

0

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

    }

0

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

0

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

0

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 .

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.