Invio di e-mail in Android utilizzando l'API JavaMail senza utilizzare l'app predefinita / integrata


653

Sto cercando di creare un'applicazione di invio della posta in Android.

Se uso:

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

Questo avvierà l'applicazione Android integrata; Sto provando a inviare la posta sul pulsante facendo clic direttamente senza utilizzare questa applicazione.


3
javax.mail.AuthenticationFailedException durante l'invio di e-mail nonostante l'utente / password siano corretti. Qualche soluzione?
TD Nguyen,

1
Da 1.5.5, JavaMail afferma di supportare Android
artbristol il

1
SendGrid non è un'opzione? Per quanto ne so, hai anche la possibilità di ottenere statistiche sull'emai che invii
Stamatis Stiliats,

Risposte:


756

Invia e-mail in Android utilizzando l'API JavaMail utilizzando l'autenticazione Gmail.

I passaggi per creare un progetto di esempio:

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

AGGIUNGI 3 vasetti trovati nel seguente link al tuo progetto Android

Fai clic qui - Come aggiungere vasetti esterni

E non dimenticare di aggiungere questa riga nel tuo manifest:

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

Fai clic sul link di seguito per modificare l'accesso all'account per app meno sicure https://www.google.com/settings/security/lesssecureapps

Esegui il progetto e controlla la posta del tuo account di posta del destinatario. Saluti!

PS E non dimenticare che non puoi eseguire operazioni di rete da qualsiasi attività in Android. Pertanto si consiglia di utilizzare AsyncTasko IntentServicedi evitare la rete sull'eccezione del thread principale.

File Jar: https://code.google.com/archive/p/javamail-android/


52
Il tuo codice sembra utilizzare nome utente e password codificati. Attualmente si tratta di un rischio per la sicurezza (ovvero, gli apk caricati sul mercato sono stati decompilati)?
Ricco

11
Lavora per me !!! non dimenticare di aggiungere alla tua app manifest il permesso d'uso INTERNET
Avi Shukron,

15
esiste comunque un messaggio di posta elettronica inviato senza inserire la password nel codice? Penso che gli utenti sarebbero sorpresi se chiedessi loro la loro e-mail pw ...
pumpkee,

7
Ciao, grazie per il codice. ma ho java.lang.NoClassDefFoundError sul mittente GMailSender = new GMailSender (...) su mailsenderactivity. ho incluso tutti i vasetti e ho aggiunto il percorso di costruzione. ho impiegato un po 'di tempo per risolverlo, ma non ottengo la soluzione. mi aiuti per favore.
MAMurali

53
Per coloro che si lamentano / chiedono come ottenere la password dell'utente - questa non è l'idea qui. Questo è pensato per essere utilizzato con il tuo account di posta elettronica (per sviluppatori). Se si desidera fare affidamento sull'account e-mail dell'utente, è necessario utilizzare l'intento e-mail, che è ampiamente discusso in altri post.
Tom,

70

Grazie per le tue preziose informazioni. Il codice funziona correttamente. Sono in grado di aggiungere un allegato anche aggiungendo il seguente codice.

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

6
Aggiungi questo a GmailSender.java
Garbage

quando ho chiamato setcontent ha sovrascritto il contenuto del mio corpo. sto facendo qualcosa di sbagliato. voglio aggiungere un allegato con altri contenuti testuali
Calvin,

1
per la filenamevariabile qui, devi specificare il percorso del file. Ad esempio:String path = Environment.getExternalStorageDirectory().getPath() + "/temp_share.jpg";

Questo codice ti aiuta ad aggiungere più file stackoverflow.com/a/3177640/2811343 ;) :)
AndroidManifester

54

Impossibile connettersi all'host SMTP: smtp.gmail.com, porta: 465

Aggiungi questa riga nel tuo manifest:

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

39

È possibile utilizzare l'API JavaMail per gestire le attività di posta elettronica. L'API JavaMail è disponibile nel pacchetto JavaEE e il suo jar è disponibile per il download. Purtroppo non può essere utilizzato direttamente in un'applicazione Android poiché utilizza componenti AWT che sono completamente incompatibili in Android.

È possibile trovare la porta Android per JavaMail nel seguente percorso: http://code.google.com/p/javamail-android/

Aggiungi i vasetti alla tua applicazione e usa il metodo SMTP


1
Qualche repository maven per questo?
user1050755

Mi dispiace ma non ne sono consapevole
Kshitij Aggarwal l'

6
Ho porting l'ultima JavaMail ed è accessibile Maven centrale sottoeu.ocathain.com.sun.mail:javax.mail:1.5.2
artbristol

29

Per aiutare coloro che ottengono un'eccezione della rete sulla discussione principale con una destinazione SDK> 9. Questo sta usando il codice di droopie sopra ma funzionerà in modo simile per qualsiasi.

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

StrictMode.setThreadPolicy(policy); 

android.os.NetworkOnMainThreadException

Puoi usare AsyncTask come di seguito

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

Dove aggiungere questa classe
Gunaseelan l'

25

Codice funzionante al 100% con demo Puoi anche inviare più e-mail usando questa risposta.

Scarica il progetto QUI

Passaggio 1: scarica la posta, l'attivazione, i file jar aggiuntivi e aggiungi la cartella libs del tuo progetto in Android Studio. Ho aggiunto una schermata, vedi sotto Link per il download

aggiungere libs

Accedi con Gmail ( usando il tuo indirizzo e-mail ) e ACCENDI il pulsante di attivazione / disattivazione LINK

Molte persone dimenticano questo passaggio, spero che non lo facciate.

Passaggio 2: dopo aver completato questo processo. Copia e incolla queste lezioni nel tuo progetto.

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

}

Passo 3: Ora puoi cambiare questa classe in base alle tue esigenze e puoi anche inviare più mail usando questa classe. Fornisco entrambi i file XML e Java.

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 Non dimenticare di aggiungere l' autorizzazione Internet nel file AndroidManifest.xml

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

Spero che funzioni se non poi basta commentare in basso.


2
È sicuro? Se sostituisco "fromEmail" e "fromPassword" con un utente e una password hardcoded, devo preoccuparmi dei problemi di sicurezza?
Yonah Karp,

È possibile ricevere e-mail usando il tuo metodo? Voglio ricevere un'e
user3051460,

1
@ArpitPatel funziona abbastanza bene. Ma sono anche preoccupato per la sicurezza. Se usi Gmail, Google potrebbe bloccare alcune app che provano a fare proprio questo.
Totumus Maximus,

@TotumusMaximus Se sei preoccupato per la sicurezza di quanto puoi usare la tua e-mail e la password usando api
Arpit Patel,

23

SMTP

L'uso di SMTP è un modo per procedere e gli altri hanno già indicato i modi per farlo. Tieni presente che mentre fai ciò, elimini completamente l'app di posta integrata e dovrai fornire l'indirizzo del server SMTP, il nome utente e la password per quel server, staticamente nel tuo codice, o interrogarlo dall'utente .

HTTP

Un altro modo prevede un semplice script lato server, come php, che accetta alcuni parametri URL e li utilizza per inviare una mail. In questo modo, è sufficiente effettuare una richiesta HTTP dal dispositivo (facilmente possibile con le librerie integrate) e non è necessario archiviare i dati di accesso SMTP sul dispositivo. Questo è un ulteriore riferimento indiretto rispetto all'utilizzo diretto di SMTP, ma poiché è così molto semplice fare richieste HTTP e inviare e-mail da PHP, potrebbe anche essere più semplice del modo diretto.

Applicazione di posta

Se la posta deve essere inviata dall'account di posta predefinito dell'utente che ha già registrato con il telefono, dovresti adottare un altro approccio. Se hai abbastanza tempo ed esperienza, potresti voler controllare il codice sorgente dell'applicazione di posta elettronica Android per vedere se offre un punto di accesso per inviare una posta senza interazione dell'utente (non lo so, ma forse ce n'è uno).

Forse troverai anche un modo per interrogare i dettagli dell'account degli utenti (quindi puoi usarli per SMTP), anche se dubito fortemente che ciò sia possibile, perché sarebbe un enorme rischio per la sicurezza e Android è costruito in modo piuttosto sicuro.


22

ecco una versione alt che funziona anche per me e ha degli allegati (pubblicato già sopra ma versione completa a differenza del link di origine, che le persone hanno pubblicato non riescono a farlo funzionare poiché i suoi dati mancanti)

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

e chiamarlo in un'attività ...

@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 Aggiungi l'autorizzazione Internet al tuo manifest
noob

come usare questo codice se voglio usare qualsiasi altro client di posta elettronica come quello della mia organizzazione? Cambiare solo il nome host e la porta sarebbe sufficiente?
roger_that il

javax.mail.AuthenticationFailedException qualsiasi soluzione per Android 4.4.4?
TD Nguyen,

2
per javax.mail.AuthenticationFailedException, devi attivare questa impostazione google.com/settings/security/lesssecureapps
Razel Soco

1
Per risolvere Could not send email android.os.NetworkOnMainThreadException at android.os.StrictMode$AndroidBlockGuardPolicy.onNetworkè necessario vedere questa soluzione stackoverflow.com/questions/25093546/...
jgrocha

14

GmailBackground è una piccola libreria per inviare un'e-mail in background senza l'interazione dell'utente:

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

Configurazione:

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

permessi:

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

Anche per gli allegati, devi impostare l'autorizzazione READ_EXTERNAL_STORAGE:

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

fonte

(L'ho provato io stesso)


Lo sto usando e funziona perfettamente. Ma ho apportato alcune modifiche per usarlo con diversi provider di posta elettronica e quando invia e-mail a Gmail mi restituisce l'intestazione "Da" mancante ... Come risolverlo?
Erich García,

Ciao, sto usando questa API nella mia app ma non funziona e chiama sempre onfailcallback
Jawad Malik

13

Avvertenza se si utilizza "smtp.gmail.com" come server smtp predefinito.

Google ti costringerà a cambiare frequentemente la password del tuo account di posta elettronica collegato a causa delle loro politiche di "attività sospette" troppo zelanti. In sostanza tratta le richieste smtp ripetute da diversi paesi in breve tempo come "attività sospette". Dal momento che presumono che tu (il titolare dell'account e-mail) possa trovarsi in un solo Paese alla volta.

Quando i sistemi google rilevano "attività sospette", impediranno ulteriori e-mail fino a quando non si modifica la password. Dato che avrai codificato la password nell'app, dovrai rilasciare nuovamente l'app ogni volta che ciò accade, non l'ideale. Questo è successo 3 volte in una settimana per me, ho persino memorizzato la password su un altro server e ho recuperato la password in modo dinamico ogni volta che Google mi ha costretto a cambiarla.

Quindi consiglio di utilizzare uno dei tanti provider smtp gratuiti invece di "smtp.gmail.com" per evitare questo problema di sicurezza. Usa lo stesso codice ma cambia "smtp.gmail.com" nel tuo nuovo host di inoltro smtp.


2
Questo è un buon punto. Ma puoi fornire un esempio di provider di posta elettronica alternativo che ha funzionato con il codice (sostituendo solo i dettagli smtp e login). L'ho provato con hushmail ed e-mail.com ma senza successo. Continueremo a provare con gli altri.
Paulo Matuki,

@PauloMatuki, @Mark, ciao ragazzi avete risolto il suspicioud activityproblema?
Wesley,

7

Modifica: JavaMail 1.5.5 afferma di supportare Android , quindi non dovresti aver bisogno di nient'altro.

Ho trasferito l'ultima versione di JavaMail (1.5.4) su Android. È disponibile in Maven Central, basta aggiungere quanto segue a build.gradle~~

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

È quindi possibile seguire il tutorial ufficiale .

Il codice sorgente è disponibile qui: https://bitbucket.org/artbristol/javamail-forked-android


quella linea di maven / gradle non ha funzionato per me. anche il download 1.5.4 dal tuo bitbucket non ha funzionato per me. è fallito sulla stessa linea del normale javamail non Android, che è MimeMessage.setText (testo).
Wrapperapps,

@wrapperapps mi dispiace sentirlo. "per me funziona!". Sentiti libero di aprire un numero sul repo
bitbucket

7

Ho trovato un'alternativa più breve per gli altri che hanno bisogno di aiuto. Il codice è:

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

Fonte: invio di e-mail tramite l'API JavaMail

Spero che sia di aiuto! In bocca al lupo!


5

Coloro che stanno ClassDefNotFoundErrorprovando a spostare quei tre file jar nella cartella lib del tuo progetto, ha funzionato per me !!


4

Per inviare una mail con allegato.

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

Aggiungi i file jar attivazione.jar, additionnal.jar, javax.mail.jar
Rashid

1
Ottengo il seguente errore quando provo il tuo metodo: 05-13 11: 51: 50.454: E / AndroidRuntime (4273): android.os.NetworkOnMainThreadException 05-13 11: 51: 50.454: E / AndroidRuntime (4273): su Android. os.StrictMode $ AndroidBlockGuardPolicy.onNetwork (StrictMode.java:1156). Ho i permessi per internet. Qualche consiglio?
Kodartcha,

1
Prova a chiamare il metodo all'interno di un thread ... È un processo che richiede tempo ... non può essere eseguito sul thread principale ...
Rashid,

Sto usando esattamente questo codice nel mio progetto Android. La posta funziona bene per me. Ma la parte dell'attaccamento non funziona. Sto cercando di allegare un file .txt, ma la posta che sto ricevendo è costituita da un tipo sconosciuto di file che non riesco ad aprire. Per favore aiuto.
Syamantak Basu,

@Rashid ofcourse L'ho fatto. Quando stavo usando Intent in precedenza, il mio file allegato stava arrivando giusto.
Syamantak Basu,

4

Non riesco a eseguire il codice di Vinayak B. Alla fine ho risolto questo problema seguendo:

1.Utilizzando questo

2.Applicazione di AsyncTask.

3. Modifica del problema di sicurezza dell'account gmail del mittente. (Passare a "ACCENDI") in questo



3

Senza l'intervento dell'utente, è possibile inviare come segue:

  1. Invia email dal client apk. Qui mail.jar, activ.jar è necessario per inviare e-mail java. Se si aggiungono questi vasi, è possibile che aumentino le dimensioni dell'APK.

  2. In alternativa, è possibile utilizzare un servizio Web sul codice lato server, che utilizzerà lo stesso mail.jar e activ.jar per inviare e-mail. È possibile chiamare il servizio Web tramite asynctask e inviare e-mail. Riferisci lo stesso link.

(Ma dovrai conoscere le credenziali dell'account di posta)


2

Nel caso in cui venga richiesto di mantenere la libreria jar il più piccola possibile, è possibile includere separatamente la funzione SMTP / POP3 / IMAP per evitare il problema "troppi metodi nel dex".

È possibile scegliere le librerie jar desiderate dalla pagina Web javanet , ad esempio mailapi.jar + imap.jar può consentire di accedere a icloud, server di posta hotmail nel protocollo IMAP. (con l'aiuto di additional.jar e Activation.jar)


2

Ho provato a utilizzare il codice inviato da @Vinayak B. Tuttavia sto ricevendo un errore che dice: nessun provider per smtp

Ho creato una nuova domanda per questo con ulteriori informazioni QUI

Dopo tutto sono stato in grado di risolverlo da solo. Ho dovuto usare un altro mail.jar e mi sono assicurato che il mio " accesso per app meno sicure " fosse attivato.

Spero che questo aiuti chiunque abbia lo stesso problema. Fatto ciò, questo pezzo di codice funziona anche su Google Glass.


2

Tutto il codice fornito nelle altre risposte è corretto e funziona bene, ma un po 'disordinato, quindi ho deciso di pubblicare una libreria (ancora in fase di sviluppo) per usarla in modo più semplice: AndroidMail .

Devi solo creare un MailSender, creare un messaggio e inviarlo (già gestito in background con un 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);

Puoi ricevere una notifica per l'email inviata e ha anche il supporto per diversi tipi di Destinatari (TO, CC e BCC), allegati e 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 :(
    }
});

Puoi ottenerlo tramite Gradle o Maven:

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

Per favore fatemi sapere se avete qualche problema con esso! :)



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

Invio di e-mail a livello di codice con Kotlin.

  • semplice invio di e-mail, non tutte le altre funzionalità (come gli allegati).
  • TLS è sempre attivo
  • È necessaria anche solo una dipendenza e-mail di livello elementare.

Ho anche trovato utile questo elenco di servizi POP e-mail:

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

Come usare:

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

Il codice:

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

AndroidManifest:

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

-3

Per aggiungere un allegato, non dimenticare di aggiungere.

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);
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.