Envoi d'e-mails dans Android à l'aide de l'API JavaMail sans utiliser l'application par défaut / intégrée
J'essaie de créer une application d'envoi de courrier sous Android.
Si j'utilise:
Intent emailIntent = new Intent(Android.content.Intent.ACTION_SEND);
Ceci lancera l'application intégrée Android; J'essaie d'envoyer le mail sur le bouton, cliquez directement sans en utilisant cette application.
Envoyez un courrier électronique dans Android à l'aide de l'API JavaMail à l'aide de l'authentification Gmail.
Étapes pour créer un exemple de projet:
MailSenderActivity.Java:
public class MailSenderActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
final Button send = (Button) this.findViewById(R.id.send);
send.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
try {
GMailSender sender = new GMailSender("[email protected]", "password");
sender.sendMail("This is Subject",
"This is Body",
"[email protected]",
"[email protected]");
} catch (Exception e) {
Log.e("SendMail", e.getMessage(), e);
}
}
});
}
}
GMailSender.Java:
public class GMailSender extends javax.mail.Authenticator {
private String mailhost = "smtp.gmail.com";
private String user;
private String password;
private Session session;
static {
Security.addProvider(new com.provider.JSSEProvider());
}
public GMailSender(String user, String password) {
this.user = user;
this.password = password;
Properties props = new Properties();
props.setProperty("mail.transport.protocol", "smtp");
props.setProperty("mail.Host", mailhost);
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.port", "465");
props.put("mail.smtp.socketFactory.port", "465");
props.put("mail.smtp.socketFactory.class",
"javax.net.ssl.SSLSocketFactory");
props.put("mail.smtp.socketFactory.fallback", "false");
props.setProperty("mail.smtp.quitwait", "false");
session = Session.getDefaultInstance(props, this);
}
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(user, password);
}
public synchronized void sendMail(String subject, String body, String sender, String recipients) throws Exception {
try{
MimeMessage message = new MimeMessage(session);
DataHandler handler = new DataHandler(new ByteArrayDataSource(body.getBytes(), "text/plain"));
message.setSender(new InternetAddress(sender));
message.setSubject(subject);
message.setDataHandler(handler);
if (recipients.indexOf(',') > 0)
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(recipients));
else
message.setRecipient(Message.RecipientType.TO, new InternetAddress(recipients));
Transport.send(message);
}catch(Exception e){
}
}
public class ByteArrayDataSource implements DataSource {
private byte[] data;
private String type;
public ByteArrayDataSource(byte[] data, String type) {
super();
this.data = data;
this.type = type;
}
public ByteArrayDataSource(byte[] data) {
super();
this.data = data;
}
public void setType(String type) {
this.type = type;
}
public String getContentType() {
if (type == null)
return "application/octet-stream";
else
return type;
}
public InputStream getInputStream() throws IOException {
return new ByteArrayInputStream(data);
}
public String getName() {
return "ByteArrayDataSource";
}
public OutputStream getOutputStream() throws IOException {
throw new IOException("Not Supported");
}
}
}
JSSEProvider.Java:
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.Apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Alexander Y. Kleymenov
* @version $Revision$
*/
import Java.security.AccessController;
import Java.security.Provider;
public final class JSSEProvider extends Provider {
public JSSEProvider() {
super("HarmonyJSSE", 1.0, "Harmony JSSE Provider");
AccessController.doPrivileged(new Java.security.PrivilegedAction<Void>() {
public Void run() {
put("SSLContext.TLS",
"org.Apache.harmony.xnet.provider.jsse.SSLContextImpl");
put("Alg.Alias.SSLContext.TLSv1", "TLS");
put("KeyManagerFactory.X509",
"org.Apache.harmony.xnet.provider.jsse.KeyManagerFactoryImpl");
put("TrustManagerFactory.X509",
"org.Apache.harmony.xnet.provider.jsse.TrustManagerFactoryImpl");
return null;
}
});
}
}
AJOUTEZ 3 pots trouvés dans le lien suivant à votre projet Android
Cliquez ici - Comment ajouter des fichiers JAR externes
Et n'oubliez pas d'ajouter cette ligne dans votre manifeste:
<uses-permission Android:name="Android.permission.INTERNET" />
Cliquez sur le lien ci-dessous pour modifier l'accès au compte d'applications moins sécuriséeshttps://www.google.com/settings/security/lesssecureapps
Exécutez le projet et vérifiez votre compte de messagerie du destinataire. À votre santé!
P.S. Et n'oubliez pas que vous ne pouvez pas utiliser le réseau depuis n'importe quelle activité sur Android. Par conséquent, il est recommandé d'utiliser AsyncTask ou IntentService pour éviter une exception réseau sur le thread principal.
Fichiers Jar: https://code.google.com/archive/p/javamail-Android/
Merci pour vos précieuses informations. Le code fonctionne bien. Je suis en mesure d'ajouter une pièce jointe également en ajoutant le code suivant.
private Multipart _multipart;
_multipart = new MimeMultipart();
public void addAttachment(String filename,String subject) throws Exception {
BodyPart messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
_multipart.addBodyPart(messageBodyPart);
BodyPart messageBodyPart2 = new MimeBodyPart();
messageBodyPart2.setText(subject);
_multipart.addBodyPart(messageBodyPart2);
}
message.setContent(_multipart);
Impossible de se connecter à l'hôte SMTP: smtp.gmail.com, port: 465
Ajoutez cette ligne dans votre manifeste:
<uses-permission Android:name="Android.permission.INTERNET" />
Vous pouvez utiliser l'API JavaMail pour gérer vos tâches de messagerie. L'API JavaMail est disponible dans le package JavaEE et son fichier jar est disponible au téléchargement. Malheureusement, il ne peut pas être utilisé directement dans une application Android, car il utilise des composants AWT totalement incompatibles avec Android.
Vous pouvez trouver le port Android de JavaMail à l'emplacement suivant: http://code.google.com/p/javamail-Android/
Ajoutez les pots à votre application et utilisez la méthode SMTP
Afin d'aider ceux qui ont une exception réseau sur un thread principal avec une cible SDK> 9. Ceci utilise le code de droopie ci-dessus mais fonctionnera de la même manière pour tout.
StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(policy);
Android.os.NetworkOnMainThreadException
Vous pouvez utiliser AsyncTask comme ci-dessous
public void onClickMail(View view) {
new SendEmailAsyncTask().execute();
}
class SendEmailAsyncTask extends AsyncTask <Void, Void, Boolean> {
Mail m = new Mail("[email protected]", "my password");
public SendEmailAsyncTask() {
if (BuildConfig.DEBUG) Log.v(SendEmailAsyncTask.class.getName(), "SendEmailAsyncTask()");
String[] toArr = { "to [email protected]"};
m.setTo(toArr);
m.setFrom("from [email protected]");
m.setSubject("Email from Android");
m.setBody("body.");
}
@Override
protected Boolean doInBackground(Void... params) {
if (BuildConfig.DEBUG) Log.v(SendEmailAsyncTask.class.getName(), "doInBackground()");
try {
m.send();
return true;
} catch (AuthenticationFailedException e) {
Log.e(SendEmailAsyncTask.class.getName(), "Bad account details");
e.printStackTrace();
return false;
} catch (MessagingException e) {
Log.e(SendEmailAsyncTask.class.getName(), m.getTo(null) + "failed");
e.printStackTrace();
return false;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
Code de travail à 100% avec démo Vous pouvez également envoyer plusieurs courriels en utilisant cette réponse.
Télécharger le projet ICI
Étape 1: Téléchargez les fichiers de courrier électronique, d'activation, supplémentaires et ajoutez-les dans votre dossier de bibliothèques de projet dans Android studio. J'ai ajouté une capture d'écran voir ci-dessous lien de téléchargement
Connectez-vous avec gmail ( en utilisant vos boutons de courrier électronique ) et ACTIVER le bouton bascule LINK
La plupart des gens oublient cette étape et j'espère que vous ne le ferez pas.
Étape 2: Après avoir terminé ce processus. Copiez et collez ces classes dans votre projet.
GMail.Java
_import Android.util.Log;
import Java.io.UnsupportedEncodingException;
import Java.util.List;
import Java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class GMail {
final String emailPort = "587";// gmail's smtp port
final String smtpAuth = "true";
final String starttls = "true";
final String emailHost = "smtp.gmail.com";
String fromEmail;
String fromPassword;
List<String> toEmailList;
String emailSubject;
String emailBody;
Properties emailProperties;
Session mailSession;
MimeMessage emailMessage;
public GMail() {
}
public GMail(String fromEmail, String fromPassword,
List<String> toEmailList, String emailSubject, String emailBody) {
this.fromEmail = fromEmail;
this.fromPassword = fromPassword;
this.toEmailList = toEmailList;
this.emailSubject = emailSubject;
this.emailBody = emailBody;
emailProperties = System.getProperties();
emailProperties.put("mail.smtp.port", emailPort);
emailProperties.put("mail.smtp.auth", smtpAuth);
emailProperties.put("mail.smtp.starttls.enable", starttls);
Log.i("GMail", "Mail server properties set.");
}
public MimeMessage createEmailMessage() throws AddressException,
MessagingException, UnsupportedEncodingException {
mailSession = Session.getDefaultInstance(emailProperties, null);
emailMessage = new MimeMessage(mailSession);
emailMessage.setFrom(new InternetAddress(fromEmail, fromEmail));
for (String toEmail : toEmailList) {
Log.i("GMail", "toEmail: " + toEmail);
emailMessage.addRecipient(Message.RecipientType.TO,
new InternetAddress(toEmail));
}
emailMessage.setSubject(emailSubject);
emailMessage.setContent(emailBody, "text/html");// for a html email
// emailMessage.setText(emailBody);// for a text email
Log.i("GMail", "Email Message created.");
return emailMessage;
}
public void sendEmail() throws AddressException, MessagingException {
Transport transport = mailSession.getTransport("smtp");
transport.connect(emailHost, fromEmail, fromPassword);
Log.i("GMail", "allrecipients: " + emailMessage.getAllRecipients());
transport.sendMessage(emailMessage, emailMessage.getAllRecipients());
transport.close();
Log.i("GMail", "Email sent successfully.");
}
}
_SendMailTask.Java
_import Android.app.Activity;
import Android.app.ProgressDialog;
import Android.os.AsyncTask;
import Android.util.Log;
import Java.util.List;
public class SendMailTask extends AsyncTask {
private ProgressDialog statusDialog;
private Activity sendMailActivity;
public SendMailTask(Activity activity) {
sendMailActivity = activity;
}
protected void onPreExecute() {
statusDialog = new ProgressDialog(sendMailActivity);
statusDialog.setMessage("Getting ready...");
statusDialog.setIndeterminate(false);
statusDialog.setCancelable(false);
statusDialog.show();
}
@Override
protected Object doInBackground(Object... args) {
try {
Log.i("SendMailTask", "About to instantiate GMail...");
publishProgress("Processing input....");
GMail androidEmail = new GMail(args[0].toString(),
args[1].toString(), (List) args[2], args[3].toString(),
args[4].toString());
publishProgress("Preparing mail message....");
androidEmail.createEmailMessage();
publishProgress("Sending email....");
androidEmail.sendEmail();
publishProgress("Email Sent.");
Log.i("SendMailTask", "Mail Sent.");
} catch (Exception e) {
publishProgress(e.getMessage());
Log.e("SendMailTask", e.getMessage(), e);
}
return null;
}
@Override
public void onProgressUpdate(Object... values) {
statusDialog.setMessage(values[0].toString());
}
@Override
public void onPostExecute(Object result) {
statusDialog.dismiss();
}
}
_Étape 3: Vous pouvez maintenant modifier cette classe en fonction de vos besoins. Vous pouvez également envoyer plusieurs courriers à l'aide de cette classe. Je fournis xml et Java fichier à la fois.
activity_mail.xml
_<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:tools="http://schemas.Android.com/tools"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:orientation="vertical"
Android:paddingLeft="20dp"
Android:paddingRight="20dp"
Android:paddingTop="30dp">
<TextView
Android:id="@+id/textView1"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:paddingTop="10dp"
Android:text="From Email" />
<EditText
Android:id="@+id/editText1"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:background="#FFFFFF"
Android:cursorVisible="true"
Android:editable="true"
Android:ems="10"
Android:enabled="true"
Android:inputType="textEmailAddress"
Android:padding="5dp"
Android:textColor="#000000">
<requestFocus />
</EditText>
<TextView
Android:id="@+id/textView2"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:paddingTop="10dp"
Android:text="Password (For from email)" />
<EditText
Android:id="@+id/editText2"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:background="#FFFFFF"
Android:ems="10"
Android:inputType="textPassword"
Android:padding="5dp"
Android:textColor="#000000" />
<TextView
Android:id="@+id/textView3"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:paddingTop="10dp"
Android:text="To Email" />
<EditText
Android:id="@+id/editText3"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:background="#ffffff"
Android:ems="10"
Android:inputType="textEmailAddress"
Android:padding="5dp"
Android:textColor="#000000" />
<TextView
Android:id="@+id/textView4"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:paddingTop="10dp"
Android:text="Subject" />
<EditText
Android:id="@+id/editText4"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:background="#ffffff"
Android:ems="10"
Android:padding="5dp"
Android:textColor="#000000" />
<TextView
Android:id="@+id/textView5"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:paddingTop="10dp"
Android:text="Body" />
<EditText
Android:id="@+id/editText5"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:background="#ffffff"
Android:ems="10"
Android:inputType="textMultiLine"
Android:padding="35dp"
Android:textColor="#000000" />
<Button
Android:id="@+id/button1"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="Send Email" />
</LinearLayout>
_SendMailActivity.Java
_import Android.app.Activity;
import Android.os.Bundle;
import Android.util.Log;
import Android.view.View;
import Android.widget.Button;
import Android.widget.TextView;
import Java.util.Arrays;
import Java.util.List;
public class SendMailActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final Button send = (Button) this.findViewById(R.id.button1);
send.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Log.i("SendMailActivity", "Send Button Clicked.");
String fromEmail = ((TextView) findViewById(R.id.editText1))
.getText().toString();
String fromPassword = ((TextView) findViewById(R.id.editText2))
.getText().toString();
String toEmails = ((TextView) findViewById(R.id.editText3))
.getText().toString();
List<String> toEmailList = Arrays.asList(toEmails
.split("\\s*,\\s*"));
Log.i("SendMailActivity", "To List: " + toEmailList);
String emailSubject = ((TextView) findViewById(R.id.editText4))
.getText().toString();
String emailBody = ((TextView) findViewById(R.id.editText5))
.getText().toString();
new SendMailTask(SendMailActivity.this).execute(fromEmail,
fromPassword, toEmailList, emailSubject, emailBody);
}
});
}
}
_Remarque N'oubliez pas d'ajouter une autorisation Internet dans votre fichier AndroidManifest.xml.
<uses-permission Android:name="Android.permission.INTERNET"/>
J'espère que cela fonctionnera si ce n'est pas le cas, puis commentez en bas.
SMTP
Utiliser SMTP est une solution, et les autres ont déjà indiqué comment procéder. Notez simplement qu'en procédant ainsi, vous contournez complètement l'application de messagerie intégrée et vous devrez fournir l'adresse du serveur SMTP, le nom d'utilisateur et le mot de passe de ce serveur, soit de manière statique dans votre code, soit l'interroger auprès de l'utilisateur. .
HTTP
Une autre méthode impliquerait un simple script côté serveur, comme php, qui prend certains paramètres d’URL et les utilise pour envoyer un courrier. De cette façon, il vous suffit de faire une requête HTTP à partir du périphérique (cela est facilement possible avec les bibliothèques intégrées) et vous n'avez pas besoin de stocker les données de connexion SMTP sur le périphérique. Il s’agit là d’une indirection de plus par rapport à l’utilisation directe du protocole SMTP, mais comme il est très facile de faire une requête HTTP et d’envoyer des mails à partir de PHP, il est peut-être même plus simple que la méthode directe.
Application de courrier
Si le courrier doit être envoyé à partir du compte de messagerie par défaut de l'utilisateur déjà enregistré sur le téléphone, vous devrez adopter une autre approche. Si vous avez suffisamment de temps et d'expérience, vous pouvez vérifier le code source de l'application de messagerie Android pour voir si elle offre un point d'entrée pour l'envoi d'un courrier sans interaction de l'utilisateur (je ne sais pas, mais peut-être il y en a un).
Peut-être avez-vous même trouvé un moyen d’interroger les détails du compte des utilisateurs (pour pouvoir les utiliser pour SMTP), même si je doute fort que cela soit possible, car ce serait un énorme risque pour la sécurité et que Android est construit plutôt en toute sécurité.
voici une version alt qui fonctionne aussi pour moi et qui a des pièces jointes (déjà postée mais version complète contrairement au lien source, que les personnes postées ne peuvent pas faire fonctionner depuis leurs données manquantes)
import Java.util.Date;
import Java.util.Properties;
import javax.activation.CommandMap;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.activation.MailcapCommandMap;
import javax.mail.BodyPart;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class Mail extends javax.mail.Authenticator {
private String _user;
private String _pass;
private String[] _to;
private String _from;
private String _port;
private String _sport;
private String _Host;
private String _subject;
private String _body;
private boolean _auth;
private boolean _debuggable;
private Multipart _multipart;
public Mail() {
_Host = "smtp.gmail.com"; // default smtp server
_port = "465"; // default smtp port
_sport = "465"; // default socketfactory port
_user = ""; // username
_pass = ""; // password
_from = ""; // email sent from
_subject = ""; // email subject
_body = ""; // email body
_debuggable = false; // debug mode on or off - default off
_auth = true; // smtp authentication - default on
_multipart = new MimeMultipart();
// There is something wrong with MailCap, javamail can not find a handler for the multipart/mixed part, so this bit needs to be added.
MailcapCommandMap mc = (MailcapCommandMap) CommandMap.getDefaultCommandMap();
mc.addMailcap("text/html;; x-Java-content-handler=com.Sun.mail.handlers.text_html");
mc.addMailcap("text/xml;; x-Java-content-handler=com.Sun.mail.handlers.text_xml");
mc.addMailcap("text/plain;; x-Java-content-handler=com.Sun.mail.handlers.text_plain");
mc.addMailcap("multipart/*;; x-Java-content-handler=com.Sun.mail.handlers.multipart_mixed");
mc.addMailcap("message/rfc822;; x-Java-content-handler=com.Sun.mail.handlers.message_rfc822");
CommandMap.setDefaultCommandMap(mc);
}
public Mail(String user, String pass) {
this();
_user = user;
_pass = pass;
}
public boolean send() throws Exception {
Properties props = _setProperties();
if(!_user.equals("") && !_pass.equals("") && _to.length > 0 && !_from.equals("") && !_subject.equals("") && !_body.equals("")) {
Session session = Session.getInstance(props, this);
MimeMessage msg = new MimeMessage(session);
msg.setFrom(new InternetAddress(_from));
InternetAddress[] addressTo = new InternetAddress[_to.length];
for (int i = 0; i < _to.length; i++) {
addressTo[i] = new InternetAddress(_to[i]);
}
msg.setRecipients(MimeMessage.RecipientType.TO, addressTo);
msg.setSubject(_subject);
msg.setSentDate(new Date());
// setup message body
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(_body);
_multipart.addBodyPart(messageBodyPart);
// Put parts in message
msg.setContent(_multipart);
// send email
Transport.send(msg);
return true;
} else {
return false;
}
}
public void addAttachment(String filename) throws Exception {
BodyPart messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
_multipart.addBodyPart(messageBodyPart);
}
@Override
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(_user, _pass);
}
private Properties _setProperties() {
Properties props = new Properties();
props.put("mail.smtp.Host", _Host);
if(_debuggable) {
props.put("mail.debug", "true");
}
if(_auth) {
props.put("mail.smtp.auth", "true");
}
props.put("mail.smtp.port", _port);
props.put("mail.smtp.socketFactory.port", _sport);
props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
props.put("mail.smtp.socketFactory.fallback", "false");
return props;
}
// the getters and setters
public String getBody() {
return _body;
}
public void setBody(String _body) {
this._body = _body;
}
public void setTo(String[] toArr) {
// TODO Auto-generated method stub
this._to=toArr;
}
public void setFrom(String string) {
// TODO Auto-generated method stub
this._from=string;
}
public void setSubject(String string) {
// TODO Auto-generated method stub
this._subject=string;
}
// more of the getters and setters …..
}
et l'appeler dans une activité ...
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);
Button addImage = (Button) findViewById(R.id.send_email);
addImage.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
Mail m = new Mail("[email protected]", "password");
String[] toArr = {"[email protected]", "[email protected]"};
m.setTo(toArr);
m.setFrom("[email protected]");
m.setSubject("This is an email sent using my Mail JavaMail wrapper from an Android device.");
m.setBody("Email body.");
try {
m.addAttachment("/sdcard/filelocation");
if(m.send()) {
Toast.makeText(MailApp.this, "Email was sent successfully.", Toast.LENGTH_LONG).show();
} else {
Toast.makeText(MailApp.this, "Email was not sent.", Toast.LENGTH_LONG).show();
}
} catch(Exception e) {
//Toast.makeText(MailApp.this, "There was a problem sending the email.", Toast.LENGTH_LONG).show();
Log.e("MailApp", "Could not send email", e);
}
}
});
}
Mot d'avertissement si vous utilisez "smtp.gmail.com" comme serveur smtp par défaut.
Google vous obligera à modifier fréquemment le mot de passe de votre compte de messagerie lié, en raison de leur politique de "activité suspecte" trop zélée. Il traite essentiellement les demandes répétées de smtp de différents pays dans un court laps de temps comme "une activité suspecte". Comme ils le supposent, vous (le titulaire du compte de messagerie) ne pouvez être que dans un pays à la fois.
Lorsque les systèmes Google détectent une "activité suspecte", cela empêchera d'autres courriels jusqu'à ce que vous changiez le mot de passe. Comme vous aurez codé en dur le mot de passe dans l'application, vous devez le relancer à chaque fois que cela se produit, ce qui n'est pas idéal. Cela m'est arrivé 3 fois par semaine, j'ai même stocké le mot de passe sur un autre serveur et récupéré dynamiquement le mot de passe chaque fois que Google me forçait à le changer.
Je vous recommande donc d'utiliser l'un des nombreux fournisseurs smtp gratuits au lieu de "smtp.gmail.com" pour éviter ce problème de sécurité. Utilisez le même code, mais remplacez "smtp.gmail.com" par votre nouvel hôte de transfert smtp.
GmailBackground est une petite bibliothèque pour envoyer un email en arrière-plan sans interaction de l'utilisateur:
Usage:
BackgroundMail.newBuilder(this)
.withUsername("[email protected]")
.withPassword("password12345")
.withMailto("[email protected]")
.withType(BackgroundMail.TYPE_PLAIN)
.withSubject("this is the subject")
.withBody("this is the body")
.withOnSuccessCallback(new BackgroundMail.OnSuccessCallback() {
@Override
public void onSuccess() {
//do some magic
}
})
.withOnFailCallback(new BackgroundMail.OnFailCallback() {
@Override
public void onFail() {
//do some magic
}
})
.send();
Configuration:
repositories {
// ...
maven { url "https://jitpack.io" }
}
dependencies {
compile 'com.github.yesidlazaro:GmailBackground:1.2.0'
}
Permissions:
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission Android:name="Android.permission.INTERNET"/>
Pour les pièces jointes également, vous devez définir le droit READ_EXTERNAL_STORAGE:
<uses-permission Android:name="Android.permission.READ_EXTERNAL_STORAGE"/>
(je l'ai testé moi-même)
Edit: JavaMail 1.5.5 prétend prendre en charge Android , vous ne devriez donc avoir besoin de rien d'autre.
J'ai porté le dernier JavaMail (1.5.4) sur Android. Il est disponible dans Maven Central, ajoutez simplement ce qui suit à build.gradle ~~
compile 'eu.ocathain.com.Sun.mail:javax.mail:1.5.4'
Vous pouvez ensuite suivre le fonctionnaire tutoriel .
Le code source est disponible ici: https://bitbucket.org/artbristol/javamail-forked-Android
J'ai trouvé une alternative plus courte pour ceux qui ont besoin d'aide. Le code est:
package com.example.mail;
import Java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendMailTLS {
public static void main(String[] args) {
final String username = "[email protected]";
final String password = "password";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.Host", "smtp.gmail.com");
props.put("mail.smtp.port", "587");
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("username", "password");
}
});
try {
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress("[email protected]"));
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse("[email protected]"));
message.setSubject("Testing Subject");
message.setText("Dear Mail Crawler,"
+ "\n\n No spam to my email, please!");
Transport.send(message);
System.out.println("Done");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}
Source: Envoi d'e-mail via l'API JavaMail
J'espère que cela t'aides! Bonne chance!
Ceux qui obtiennent ClassDefNotFoundError essaient de déplacer les trois fichiers jar dans le dossier lib de votre projet, cela a fonctionné pour moi!
Je ne parviens pas à exécuter le code de Vinayak B. Enfin, j'ai résolu ce problème en suivant:
1.Utiliser ceci
2.Application AsyncTask.
3.Changing problème de sécurité du compte gmail de l'expéditeur. (Passez à "ACTIVÉ") dans this
Pour envoyer un mail avec pièce jointe ..
public class SendAttachment{
public static void main(String [] args){
//to address
String to="[email protected]";//change accordingly
//from address
final String user="[email protected]";//change accordingly
final String password="password";//change accordingly
MailcapCommandMap mc = (MailcapCommandMap) CommandMap.getDefaultCommandMap();
mc.addMailcap("text/html;; x-Java-content-handler=com.Sun.mail.handlers.text_html");
mc.addMailcap("text/xml;; x-Java-content-handler=com.Sun.mail.handlers.text_xml");
mc.addMailcap("text/plain;; x-Java-content-handler=com.Sun.mail.handlers.text_plain");
mc.addMailcap("multipart/*;; x-Java-content-handler=com.Sun.mail.handlers.multipart_mixed");
mc.addMailcap("message/rfc822;; x-Java-content-handler=com.Sun.mail.handlers.message_rfc822");
CommandMap.setDefaultCommandMap(mc);
//1) get the session object
Properties properties = System.getProperties();
properties.put("mail.smtp.port", "465");
properties.put("mail.smtp.Host", "smtp.gmail.com");
properties.put("mail.smtp.socketFactory.port", "465");
properties.put("mail.smtp.socketFactory.class",
"javax.net.ssl.SSLSocketFactory");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.port", "465");
Session session = Session.getDefaultInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(user,password);
}
});
//2) compose message
try{
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(user));
message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));
message.setSubject("Hii");
//3) create MimeBodyPart object and set your message content
BodyPart messageBodyPart1 = new MimeBodyPart();
messageBodyPart1.setText("How is This");
//4) create new MimeBodyPart object and set DataHandler object to this object
MimeBodyPart messageBodyPart2 = new MimeBodyPart();
//Location of file to be attached
String filename = Environment.getExternalStorageDirectory().getPath()+"/R2832.Zip";//change accordingly
DataSource source = new FileDataSource(filename);
messageBodyPart2.setDataHandler(new DataHandler(source));
messageBodyPart2.setFileName("Hello");
//5) create Multipart object and add MimeBodyPart objects to this object
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart1);
multipart.addBodyPart(messageBodyPart2);
//6) set the multiplart object to the message object
message.setContent(multipart );
//7) send message
Transport.send(message);
System.out.println("MESSAGE SENT....");
}catch (MessagingException ex) {ex.printStackTrace();}
}
}
Avez-vous envisagé d'utiliser Apache Commons Net? Depuis la version 3.3, un seul pot (et vous pouvez en dépendre avec gradle ou maven) et vous avez terminé: http://blog.dahanne.net/2013/06/17/sending-a-mail- in-Java-and-Android-with-Apache-commons-net /
Sans intervention de l'utilisateur, vous pouvez envoyer comme suit:
Envoyer un email du client apk. Ici, mail.jar, activation.jar est requis pour envoyer Java email. Si ces pots sont ajoutés, la taille de l'APK peut être augmentée.
Vous pouvez également utiliser un service Web sur le code côté serveur, qui utilisera les mêmes mail.jar et activation.jar pour envoyer un courrier électronique. Vous pouvez appeler le service Web via asynctask et envoyer un courrier électronique. Reportez le même lien.
(Mais, vous aurez besoin de connaître les informations d'identification du compte de messagerie)
Tout le code fourni dans les autres réponses est correct et fonctionne bien, mais un peu brouillon. J'ai donc décidé de publier une bibliothèque (toujours en développement cependant) pour l'utiliser plus facilement: AndroidMail.
Il vous suffit de créer un MailSender, de créer un mail et de l'envoyer (déjà traité en tâche de fond avec une AsyncTask).
MailSender mailSender = new MailSender(email, password);
Mail.MailBuilder builder = new Mail.MailBuilder();
Mail mail = builder
.setSender(senderMail)
.addRecipient(new Recipient(recipient))
.setText("Hello")
.build();
mailSender.sendMail(mail);
Vous pouvez recevoir une notification pour le courrier électronique envoyé et il prend également en charge différents types de destinataires (TO, CC et BCC), pièces jointes et html:
MailSender mailSender = new MailSender(email, password);
Mail.MailBuilder builder = new Mail.MailBuilder();
Mail mail = builder
.setSender(senderMail)
.addRecipient(new Recipient(recipient))
.addRecipient(new Recipient(Recipient.TYPE.CC, recipientCC))
.setText("Hello")
.setHtml("<h1 style=\"color:red;\">Hello</h1>")
.addAttachment(new Attachment(filePath, fileName))
.build();
mailSender.sendMail(mail, new MailSender.OnMailSentListener() {
@Override
public void onSuccess() {
// mail sent!
}
@Override
public void onError(Exception error) {
// something bad happened :(
}
});
Vous pouvez l'obtenir via Gradle ou Maven:
compile 'it.enricocandino:androidmail:1.0.0-SNAPSHOT'
S'il vous plaît laissez-moi savoir si vous avez un problème avec elle! :)
J'ai essayé d'utiliser le code que @ Vinayak B a soumis. Cependant, je reçois une erreur en disant: Pas de fournisseur pour smtp
J'ai créé une nouvelle question pour cela avec plus d'informations ICI
J'ai pu le réparer moi-même après tout. Je devais utiliser un autre mail.jar et je devais m'assurer que mon " accès pour les applications moins sécurisées " était activé.
J'espère que cela aide tous ceux qui ont le même problème. Ceci fait, ce morceau de code fonctionne également sur le verre de Google.
Si vous devez conserver la bibliothèque de fichiers JAR aussi petite que possible, vous pouvez inclure la fonction SMTP/POP3/IMAP séparément pour éviter le problème "trop de méthodes dans le dex".
Vous pouvez choisir les bibliothèques de fichiers JAR souhaitées parmi la page Web javanet . Par exemple, mailapi.jar + imap.jar peut vous permettre d’accéder à icloud, serveur de messagerie hotmail en protocole IMAP. (avec l’aide de additional.jar et d’activation.jar)
Add jar files mail.jar,activation.jar,additionnal.jar
String sub="Thank you for your online registration" ;
Mail m = new Mail("emailid", "password");
String[] toArr = {"[email protected]",sEmailId};
m.setFrom("[email protected]");
m.setTo(toArr);
m.setSubject(sub);
m.setBody(msg);
try{
if(m.send()) {
} else {
}
} catch(Exception e) {
Log.e("MailApp", "Could not send email", e);
}
package com.example.ekktra;
import Java.util.Date;
import Java.util.Properties;
import javax.activation.CommandMap;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.activation.MailcapCommandMap;
import javax.mail.BodyPart;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class Mail extends javax.mail.Authenticator {
private String _user;
private String _pass;
private String[] _to;
private String _from;
private String _port;
private String _sport;
private String _Host;
private String _subject;
private String _body;
private boolean _auth;
private boolean _debuggable;
private Multipart _multipart;
public Mail() {
_Host = "smtp.gmail.com"; // default smtp server
_port = "465"; // default smtp port
_sport = "465"; // default socketfactory port
_user = ""; // username
_pass = ""; // password
_from = ""; // email sent from
_subject = ""; // email subject
_body = ""; // email body
_debuggable = false; // debug mode on or off - default off
_auth = true; // smtp authentication - default on
_multipart = new MimeMultipart();
// There is something wrong with MailCap, javamail can not find a handler for the multipart/mixed part, so this bit needs to be added.
MailcapCommandMap mc = (MailcapCommandMap) CommandMap.getDefaultCommandMap();
mc.addMailcap("text/html;; x-Java-content-handler=com.Sun.mail.handlers.text_html");
mc.addMailcap("text/xml;; x-Java-content-handler=com.Sun.mail.handlers.text_xml");
mc.addMailcap("text/plain;; x-Java-content- handler=com.Sun.mail.handlers.text_plain");
mc.addMailcap("multipart/*;; x-Java-content-handler=com.Sun.mail.handlers.multipart_mixed");
mc.addMailcap("message/rfc822;; x-Java-content- handler=com.Sun.mail.handlers.message_rfc822");
CommandMap.setDefaultCommandMap(mc);
}
public Mail(String user, String pass) {
this();
_user = user;
_pass = pass;
}
public boolean send() throws Exception {
Properties props = _setProperties();
if(!_user.equals("") && !_pass.equals("") && _to.length > 0 && !_from.equals("") && !_subject.equals("") /*&& !_body.equals("")*/) {
Session session = Session.getInstance(props, this);
MimeMessage msg = new MimeMessage(session);
msg.setFrom(new InternetAddress(_from));
InternetAddress[] addressTo = new InternetAddress[_to.length];
for (int i = 0; i < _to.length; i++) {
addressTo[i] = new InternetAddress(_to[i]);
}
msg.setRecipients(MimeMessage.RecipientType.TO, addressTo);
msg.setSubject(_subject);
msg.setSentDate(new Date());
// setup message body
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(_body);
_multipart.addBodyPart(messageBodyPart);
// Put parts in message
msg.setContent(_multipart);
// send email
Transport.send(msg);
return true;
} else {
return false;
}
}
public void addAttachment(String filename) throws Exception {
BodyPart messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
_multipart.addBodyPart(messageBodyPart);
}
@Override
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(_user, _pass);
}
private Properties _setProperties() {
Properties props = new Properties();
props.put("mail.smtp.Host", _Host);
if(_debuggable) {
props.put("mail.debug", "true");
}
if(_auth) {
props.put("mail.smtp.auth", "true");
}
props.put("mail.smtp.port", _port);
props.put("mail.smtp.socketFactory.port", _sport);
props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
props.put("mail.smtp.socketFactory.fallback", "false");
return props;
}
// the getters and setters
public String getBody() {
return _body;
}
public void setBody(String _body) {
this._body = _body;
}
public void setTo(String[] toArr) {
// TODO Auto-generated method stub
this._to=toArr;
}
public void setFrom(String string) {
// TODO Auto-generated method stub
this._from=string;
}
public void setSubject(String string) {
// TODO Auto-generated method stub
this._subject=string;
}
}