Envío de correo electrónico en Android usando la API JavaMail sin usar la aplicación predeterminada / incorporada


653

Estoy tratando de crear una aplicación de envío de correo en Android.

Si yo uso:

Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);

Esto lanzará la aplicación de Android incorporada; Estoy tratando de enviar el correo al hacer clic en el botón directamente sin usar esta aplicación.


3
javax.mail.AuthenticationFailedException al enviar correos electrónicos aunque el usuario / contraseña sean correctos. ¿Alguna solución?
TD Nguyen

1
Tenga en cuenta que a partir de 1.5.5, JavaMail afirma que es compatible con Android
artbristol

1
¿No es SendGrid una opción? Por lo que yo sé que también tiene la posibilidad de obtener estadísticas sobre el emai que envíe
Stamatis Stiliats

Respuestas:


756

Envíe correos electrónicos en Android usando la API JavaMail usando la autenticación de Gmail.

Pasos para crear un proyecto de muestra:

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("username@gmail.com", "password");
                    sender.sendMail("This is Subject",   
                            "This is Body",   
                            "user@gmail.com",   
                            "user@yahoo.com");   
                } 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;
            }
        });
    }
}

AGREGAR 3 frascos encontrados en el siguiente enlace a su proyecto de Android

Haga clic aquí - Cómo agregar frascos externos

Y no olvide agregar esta línea en su manifiesto:

<uses-permission android:name="android.permission.INTERNET" />

Simplemente haga clic debajo del enlace para cambiar el acceso a la cuenta para aplicaciones menos seguras https://www.google.com/settings/security/lesssecureapps

Ejecute el proyecto y verifique el correo en su cuenta de correo destinatario. ¡Salud!

PD Y no olvides que no puedes hacer operaciones de red desde ninguna Actividad en Android. Por lo tanto, se recomienda usar AsyncTasko IntentServiceevitar la red en la excepción del subproceso principal.

Archivos jar: https://code.google.com/archive/p/javamail-android/


52
Parece que su código usa un nombre de usuario y contraseña codificados. ¿Es esto actualmente un riesgo de seguridad (es decir, se han descompilado las aplicaciones que se suben al mercado)?
Rico

11
Trabajando para mi !!! no te olvides de agregar a tu aplicación el permiso de uso de INTERNET
Avi Shukron

15
¿hay alguna forma de recibir un correo electrónico sin ingresar la contraseña en el código? Creo que los usuarios se sorprenderían si les pidiera su correo electrónico pw ...
pumpkee

77
Hola gracias por el código pero obtuve java.lang.NoClassDefFoundError en GMailSender sender = new GMailSender (...) en mailsenderactivity. Incluí todos los tarros y los agregué a la ruta de compilación. Pasé un tiempo para resolverlo, pero no obtengo la solución. por favor, ayúdame.
MAMurali

53
Para aquellos que se quejan / preguntan sobre cómo obtener la contraseña del usuario, esa no es la idea aquí. Esto está destinado a ser utilizado con su cuenta de correo electrónico (del desarrollador). Si desea confiar en la cuenta de correo electrónico del usuario, debe utilizar la intención de correo electrónico, que se discute ampliamente en otras publicaciones.
Tom

70

Gracias por tu valiosa información. El código funciona bien. Puedo agregar archivos adjuntos también agregando el siguiente código.

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

66
Agregue esto a GmailSender.java
Basura

cuando llamé a setcontent sobrescribió el contenido de mi cuerpo. estoy haciendo algo mal. Quiero agregar datos adjuntos con otro contenido corporal textual
Calvin

1
para la filenamevariable aquí, debe especificar la ruta del archivo. Por ejemplo:String path = Environment.getExternalStorageDirectory().getPath() + "/temp_share.jpg";

Este código le ayuda a agregar varios archivos stackoverflow.com/a/3177640/2811343 ;) :)
AndroidManifester

54

No se pudo conectar con el host SMTP: smtp.gmail.com, puerto: 465

Agregue esta línea en su manifiesto:

<uses-permission android:name="android.permission.INTERNET" />

39

Puede usar la API JavaMail para manejar sus tareas de correo electrónico. JavaMail API está disponible en el paquete JavaEE y su jar está disponible para descargar. Lamentablemente, no se puede usar directamente en una aplicación de Android, ya que utiliza componentes AWT que son completamente incompatibles en Android.

Puede encontrar el puerto de Android para JavaMail en la siguiente ubicación: http://code.google.com/p/javamail-android/

Agregue los frascos a su aplicación y use el método SMTP


1
¿Algún repositorio maven para eso?
user1050755

Lo siento pero no estoy al tanto de eso
Kshitij Aggarwal

66
He portado el último JavaMail y está disponible en Maven Central bajoeu.ocathain.com.sun.mail:javax.mail:1.5.2
artbristol el

29

Para ayudar a aquellos que obtienen una Red en la Excepción del subproceso principal con un SDK Target> 9. Esto está usando el código de droopie anterior pero funcionará de manera similar para cualquiera.

StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();

StrictMode.setThreadPolicy(policy); 

android.os.NetworkOnMainThreadException

Puede usar AsyncTask como se muestra a continuación

public void onClickMail(View view) {
    new SendEmailAsyncTask().execute();
}

class SendEmailAsyncTask extends AsyncTask <Void, Void, Boolean> {
    Mail m = new Mail("from@gmail.com", "my password");

    public SendEmailAsyncTask() {
        if (BuildConfig.DEBUG) Log.v(SendEmailAsyncTask.class.getName(), "SendEmailAsyncTask()");
        String[] toArr = { "to mail@gmail.com"};
        m.setTo(toArr);
        m.setFrom("from mail@gmail.com");
        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;
        }
    }

Dónde agregar esta clase
Gunaseelan

25

Código 100% funcional con demo También puede enviar múltiples correos electrónicos con esta respuesta.

Descargar proyecto AQUÍ

Paso 1: descargue el correo, la activación, los archivos jar adicionales y agregue la carpeta libs de su proyecto en Android Studio. Agregué una captura de pantalla, ver abajo Enlace de descarga

agregar libs

Inicie sesión con gmail ( usando su correo electrónico ) y ENCIENDA el botón de alternar ENLACE

La mayoría de la gente se olvida de este paso, espero que no lo hagas.

Paso 2: después de completar este proceso. Copie y pegue estas clases en su proyecto.

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

}

Paso 3: Ahora puede cambiar esta clase de acuerdo a sus necesidades y también puede enviar múltiples correos usando esta clase. Proporciono xml y java ambos.

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

Nota No olvide agregar permiso de Internet en su archivo AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET"/>

Espero que funcione si no es así, solo comenta abajo.


2
¿Es esto seguro? Si reemplazo "fromEmail" y "fromPassword" con un usuario y contraseña codificados, ¿debo preocuparme por los problemas de seguridad?
Yonah Karp

¿Es posible recibir correos electrónicos utilizando su método? Quiero recibir un correo electrónico
user3051460

1
@ArpitPatel esto funciona bastante bien. Pero también me preocupa la seguridad. Si usa gmail, Google podría bloquear ciertas aplicaciones que intentan hacer exactamente esto.
Totumus Maximus

@TotumusMaximus Si le preocupa la seguridad, puede usar su correo electrónico y contraseña con api
Arpit Patel

23

SMTP

Usar SMTP es un camino a seguir, y los otros ya han señalado formas de hacerlo. Solo tenga en cuenta que al hacer esto, elude por completo la aplicación de correo incorporada, y tendrá que proporcionar la dirección del servidor SMTP, el nombre de usuario y la contraseña de ese servidor, ya sea estáticamente en su código o consultarlo al usuario .

HTTP

Otra forma implicaría un script simple del lado del servidor, como php, que toma algunos parámetros de URL y los usa para enviar un correo. De esta manera, solo necesita hacer una solicitud HTTP desde el dispositivo (fácilmente posible con las bibliotecas integradas) y no necesita almacenar los datos de inicio de sesión SMTP en el dispositivo. Esta es una indirección más en comparación con el uso directo de SMTP, pero debido a que es muy fácil hacer una solicitud HTTP y enviar correos desde PHP, incluso podría ser más simple que la forma directa.

Solicitud de correo

Si el correo se enviará desde la cuenta de correo predeterminada del usuario que él ya registró con el teléfono, deberá adoptar otro enfoque. Si tiene suficiente tiempo y experiencia, puede consultar el código fuente de la aplicación de correo electrónico de Android para ver si ofrece algún punto de entrada para enviar un correo sin interacción del usuario (no lo sé, pero tal vez haya uno).

Tal vez incluso encuentre una manera de consultar los detalles de la cuenta de los usuarios (para que pueda usarlos para SMTP), aunque dudo mucho que esto sea posible, ya que sería un gran riesgo de seguridad y Android está construido de manera bastante segura.


22

aquí hay una versión alternativa que también funciona para mí y tiene archivos adjuntos (publicados anteriormente pero versión completa a diferencia del enlace de origen, que las personas publicaron que no pueden hacer que funcione porque faltan datos)

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

y llamarlo en una actividad ...

@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("gmailusername@gmail.com", "password"); 

      String[] toArr = {"bla@bla.com", "lala@lala.com"}; 
      m.setTo(toArr); 
      m.setFrom("wooo@wooo.com"); 
      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); 
      } 
    } 
  }); 
} 

@KeyLimePiePhotonAndroid Agregue permiso de Internet a su manifiesto
noob

¿Cómo usar este código si quiero usar cualquier otro cliente de correo electrónico como el de mi organización? ¿Sería suficiente cambiar solo el nombre de host y el puerto?
roger_que

javax.mail.AuthenticationFailedException ¿alguna solución para Android 4.4.4?
TD Nguyen

2
para javax.mail.AuthenticationFailedException, debe activar esta configuración google.com/settings/security/lesssecureapps
Razel Soco

1
Para resolverlo Could not send email android.os.NetworkOnMainThreadException at android.os.StrictMode$AndroidBlockGuardPolicy.onNetworkes necesario ver esta solución stackoverflow.com/questions/25093546/…
jgrocha

14

GmailBackground es una pequeña biblioteca para enviar un correo electrónico en segundo plano sin interacción del usuario:

Uso:

    BackgroundMail.newBuilder(this)
            .withUsername("username@gmail.com")
            .withPassword("password12345")
            .withMailto("toemail@gmail.com")
            .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();

Configuración:

repositories {
    // ...
    maven { url "https://jitpack.io" }
 }
 dependencies {
            compile 'com.github.yesidlazaro:GmailBackground:1.2.0'
    }

Permisos:

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.INTERNET"/>

También para los archivos adjuntos, debe establecer el permiso READ_EXTERNAL_STORAGE:

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

Fuente

(Lo he probado yo mismo)


Lo uso y funciona perfecto. Pero hice algunas modificaciones para usarlo con un proveedor de correo electrónico diferente y cuando envío un correo electrónico a Gmail, me devuelve el encabezado "De" ... ¿Cómo solucionarlo?
Erich García

Hola, estoy usando esta api en mi aplicación, pero no funciona y siempre estoy llamando al rellamada
Jawad Malik, el

13

Palabra de advertencia si usa "smtp.gmail.com" como el servidor smtp predeterminado.

Google lo obligará a cambiar la contraseña de su cuenta de correo electrónico vinculada con frecuencia debido a sus excesivas políticas de "actividad sospechosa". En esencia, trata las solicitudes smtp repetidas de diferentes países en un corto período de tiempo como "actividad sospechosa". Como suponen que usted (el titular de la cuenta de correo electrónico) solo puede estar en un país a la vez.

Cuando los sistemas de Google detectan "actividad sospechosa", evitará más correos electrónicos hasta que cambie la contraseña. Como habrá codificado la contraseña en la aplicación, debe volver a lanzar la aplicación cada vez que esto suceda, lo que no es ideal. Esto me sucedió 3 veces en una semana, incluso almacené la contraseña en otro servidor y busqué dinámicamente la contraseña cada vez que Google me obligó a cambiarla.

Por lo tanto, recomiendo usar uno de los muchos proveedores de smtp gratuitos en lugar de "smtp.gmail.com" para evitar este problema de seguridad. Use el mismo código pero cambie "smtp.gmail.com" a su nuevo host de reenvío smtp.


2
Ese es un buen punto. Pero, ¿puede dar un ejemplo de proveedor de correo electrónico alternativo que trabaje con código (solo reemplazando smtp y detalles de inicio de sesión). Lo he intentado con hushmail y email.com pero sin éxito. Seguirá intentándolo con los demás.
Paulo Matuki el

@PauloMatuki, @Mark, Hola, ¿resolvieron el suspicioud activityproblema?
Wesley

7

Editar: JavaMail 1.5.5 afirma que es compatible con Android , por lo que no debería necesitar nada más.

He portado el último JavaMail (1.5.4) a Android. Está disponible en Maven Central, solo agregue lo siguiente a build.gradle~~

compile 'eu.ocathain.com.sun.mail:javax.mail:1.5.4'

Luego puedes seguir el tutorial oficial .

El código fuente está disponible aquí: https://bitbucket.org/artbristol/javamail-forked-android


esa línea maven / gradle no funcionó para mí. la descarga 1.5.4 de tu bitbucket tampoco funcionó para mí. falló en la misma línea que el javamail normal que no es Android, que es MimeMessage.setText (texto).
wrapperapps

@wrapperapps lamento escuchar eso. "¡esto funciona para mi!". Siéntase libre de abrir un problema en el repositorio
bitbucket

7

Encontré una alternativa más corta para otros que necesitan ayuda. El codigo es:

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 = "username@gmail.com";
        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("from-email@gmail.com"));
            message.setRecipients(Message.RecipientType.TO,
                InternetAddress.parse("to-email@gmail.com"));
            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);
        }
    }
}

Fuente: Envío de correo electrónico a través de la API JavaMail

¡Espero que esto ayude! ¡Buena suerte!


5

Aquellos que ClassDefNotFoundErrorintentan mover esos tres archivos jar a la carpeta lib de su proyecto, ¡funcionó para mí!


4

Para enviar un correo con archivo adjunto ...

public class SendAttachment{
                    public static void main(String [] args){ 
             //to address
                    String to="abc@abc.com";//change accordingly
                    //from address
                    final String user="efg@efg.com";//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();}
                  }
                }

Añadir el frasco archivos activation.jar, additionnal.jar, javax.mail.jar
Rashid

1
Recibo el siguiente error al probar su método: 05-13 11: 51: 50.454: E / AndroidRuntime (4273): android.os.NetworkOnMainThreadException 05-13 11: 51: 50.454: E / AndroidRuntime (4273): en Android. os.StrictMode $ AndroidBlockGuardPolicy.onNetwork (StrictMode.java:1156). Tengo permisos de internet. ¿Algún consejo?
kodartcha

1
Intente llamar al método dentro de un hilo ... Es un proceso lento ... no puede ejecutarse en el hilo principal ...
Rashid

Estoy usando exactamente este código en mi proyecto de Android. El correo funciona bien para mí. Pero la parte del archivo adjunto no funciona. Estoy tratando de adjuntar un archivo .txt. Pero el correo que estoy recibiendo consiste en un tipo desconocido de archivo que no puedo abrir. Por favor ayuda.
Syamantak Basu

@Rashid, por supuesto, lo hice. Cuando estaba usando Intent anteriormente, mi archivo adjunto venía bien.
Syamantak Basu

4

No puedo ejecutar el código de Vinayak B. Finalmente resolví este problema siguiendo:

1.Utilizando esto

2.Aplicando AsyncTask.

3.Cambio del problema de seguridad de la cuenta de remitente de gmail. (Cambie a "ENCENDIDO") en este



3

Sin intervención del usuario, puede enviar lo siguiente:

  1. Enviar correo electrónico desde el apk del cliente. Aquí se requiere mail.jar, activación.jar para enviar correo electrónico java. Si se agregan estos frascos, podría aumentar el tamaño del APK.

  2. Alternativamente, puede usar un servicio web en el código del lado del servidor, que usará el mismo mail.jar y activación.jar para enviar correos electrónicos. Puede llamar al servicio web a través de asynctask y enviar un correo electrónico. Consulte el mismo enlace.

(Pero, deberá conocer las credenciales de la cuenta de correo)


2

En caso de que deba mantener la biblioteca jar lo más pequeña posible, puede incluir la función SMTP / POP3 / IMAP por separado para evitar el problema de "demasiados métodos en la desviación".

Puede elegir las bibliotecas jar deseadas de la página web de Java , por ejemplo, mailapi.jar + imap.jar puede permitirle acceder a icloud, servidor de correo hotmail en el protocolo IMAP. (con la ayuda de Adicional.jar y Activación.jar)


2

Intenté usar el código que envió @Vinayak B. Sin embargo, recibo un error que dice: No hay proveedor para smtp

Creé una nueva pregunta para esto con más información AQUÍ

Pude arreglarlo yo mismo después de todo. Tuve que usar otro mail.jar y me aseguré de que mi " acceso para aplicaciones menos seguras " estuviera activado.

Espero que esto ayude a cualquiera que tenga el mismo problema. Una vez hecho esto, este código también funciona en Google Glass.


2

Todo el código proporcionado en las otras respuestas es correcto y funciona bien, pero un poco desordenado, así que decidí publicar una biblioteca (aunque aún en desarrollo) para usarla de una manera más fácil: AndroidMail .

Solo tiene que crear un MailSender, construir un correo y enviarlo (ya manejado en segundo plano con una 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);

Puede recibir una notificación por el correo electrónico enviado y también tiene soporte para diferentes tipos de Destinatarios (TO, CC y BCC), archivos adjuntos y 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 :(
    }
});

Puede obtenerlo a través de Gradle o Maven:

compile 'it.enricocandino:androidmail:1.0.0-SNAPSHOT'

¡Avísame si tienes algún problema! :)



0
 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 = {"ekkatrainfo@gmail.com",sEmailId};
 m.setFrom("ekkatrainfo@gmail.com"); 

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


   }

0

Envío de correo electrónico mediante programación con Kotlin.

  • envío simple de correo electrónico, no todas las demás funciones (como archivos adjuntos).
  • TLS siempre está encendido
  • Solo se necesita 1 dependencia de correo electrónico de Gradle.

También encontré esta lista de servicios POP de correo electrónico realmente útil:

https://support.office.com/en-gb/article/pop-and-imap-email-settings-for-outlook-8361e398-8af4-4e97-b147-6c6c4ac95353

Cómo utilizar:

    val auth = EmailService.UserPassAuthenticator("you@gmail.com", "yourPassword")
    val to = listOf(InternetAddress("to@email.com"))
    val from = InternetAddress("you@gmail.com")
    val email = EmailService.Email(auth, to, from, "Test Subject", "Hello Body World")
    val emailService = EmailService("smtp.gmail.com", 465)

    GlobalScope.launch { // or however you do background threads
        emailService.send(email)
    }

El código:

import java.util.*
import javax.mail.*
import javax.mail.internet.InternetAddress
import javax.mail.internet.MimeBodyPart
import javax.mail.internet.MimeMessage
import javax.mail.internet.MimeMultipart

class EmailService(private val server: String, private val port: Int) {

    data class Email(
        val auth: Authenticator,
        val toList: List<InternetAddress>,
        val from: Address,
        val subject: String,
        val body: String
    )

    class UserPassAuthenticator(private val username: String, private val password: String) : Authenticator() {
        override fun getPasswordAuthentication(): PasswordAuthentication {
            return PasswordAuthentication(username, password)
        }
    }

    fun send(email: Email) {
        val props = Properties()
        props["mail.smtp.auth"] = "true"
        props["mail.user"] = email.from
        props["mail.smtp.host"] = server
        props["mail.smtp.port"] = port
        props["mail.smtp.starttls.enable"] = "true"
        props["mail.smtp.ssl.trust"] = server
        props["mail.mime.charset"] = "UTF-8"
        val msg: Message = MimeMessage(Session.getDefaultInstance(props, email.auth))
        msg.setFrom(email.from)
        msg.sentDate = Calendar.getInstance().time
        msg.setRecipients(Message.RecipientType.TO, email.toList.toTypedArray())
//      msg.setRecipients(Message.RecipientType.CC, email.ccList.toTypedArray())
//      msg.setRecipients(Message.RecipientType.BCC, email.bccList.toTypedArray())
        msg.replyTo = arrayOf(email.from)

        msg.addHeader("X-Mailer", CLIENT_NAME)
        msg.addHeader("Precedence", "bulk")
        msg.subject = email.subject

        msg.setContent(MimeMultipart().apply {
            addBodyPart(MimeBodyPart().apply {
                setText(email.body, "iso-8859-1")
                //setContent(email.htmlBody, "text/html; charset=UTF-8")
            })
        })
        Transport.send(msg)
    }

    companion object {
        const val CLIENT_NAME = "Android StackOverflow programmatic email"
    }
}

Gradle:

dependencies {
    implementation 'com.sun.mail:android-mail:1.6.4'
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.3"
}

Manifiesto de Android:

<uses-permission name="android.permission.INTERNET" />

-3

Para agregar archivos adjuntos, no olvide agregar.

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);
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.