webentwicklung-frage-antwort-db.com.de

Wie programmiere ich eine einfache E-Mail? (existiert eine einfache Möglichkeit, dies zu tun?)

Ich habe ein Textfeld in meiner App und eine Schaltfläche. Ich möchte nur, dass der Benutzer beim Klicken auf die Schaltfläche eine E-Mail mit dem Text "Hallo" an die Richtung im Textfeld sendet.

Gibt es eine einfache Möglichkeit, dies zu tun?

15

Erster Weg . Wenn Sie nicht mit dem nativen E-Mail-Programm oder dem Google Mail-Programm (über Absicht) verbunden sein möchten, um die E-Mail zu senden, sondern die E-Mail im Hintergrund senden lassen, lesen Sie den nachstehenden Code.

Sie können diese Hilfsklasse verwenden und an Ihre Bedürfnisse anpassen.

package com.myapp.Android.model.service;

import Android.util.Log;
import com.myapp.Android.MyApp;

import Java.util.ArrayList;
import Java.util.Calendar;
import Java.util.Properties;

import javax.activation.DataHandler;
import javax.mail.Authenticator;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMultipart;

public class MailService {
    // public static final String MAIL_SERVER = "localhost";

    private String toList;
    private String ccList;
    private String bccList;
    private String subject;
    final private static String SMTP_SERVER = DataService
            .getSetting(DataService.SETTING_SMTP_SERVER);
    private String from;
    private String txtBody;
    private String htmlBody;
    private String replyToList;
    private ArrayList<Attachment> attachments;
    private boolean authenticationRequired = false;

    public MailService(String from, String toList, String subject, String txtBody, String htmlBody,
            Attachment attachment) {
        this.txtBody = txtBody;
        this.htmlBody = htmlBody;
        this.subject = subject;
        this.from = from;
        this.toList = toList;
        this.ccList = null;
        this.bccList = null;
        this.replyToList = null;
        this.authenticationRequired = true;

        this.attachments = new ArrayList<Attachment>();
        if (attachment != null) {
            this.attachments.add(attachment);
        }
    }

    public MailService(String from, String toList, String subject, String txtBody, String htmlBody,
            ArrayList<Attachment> attachments) {
        this.txtBody = txtBody;
        this.htmlBody = htmlBody;
        this.subject = subject;
        this.from = from;
        this.toList = toList;
        this.ccList = null;
        this.bccList = null;
        this.replyToList = null;
        this.authenticationRequired = true;
        this.attachments = attachments == null ? new ArrayList<Attachment>()
                : attachments;
    }

    public void sendAuthenticated() throws AddressException, MessagingException {
        authenticationRequired = true;
        send();
    }

    /**
     * Send an e-mail
     * 
     * @throws MessagingException
     * @throws AddressException
     */
    public void send() throws AddressException, MessagingException {
        Properties props = new Properties();

        // set the Host smtp address
        props.put("mail.smtp.Host", SMTP_SERVER);
        props.put("mail.user", from);

        props.put("mail.smtp.starttls.enable", "true");  // needed for gmail
        props.put("mail.smtp.auth", "true"); // needed for gmail
        props.put("mail.smtp.port", "587");  // gmail smtp port

        /*Authenticator auth = new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("[email protected]", "mypassword");
            }
        };*/


        Session session;

        if (authenticationRequired) {
            Authenticator auth = new SMTPAuthenticator();
            props.put("mail.smtp.auth", "true");
            session = Session.getDefaultInstance(props, auth);
        } else {
            session = Session.getDefaultInstance(props, null);          
        }

        // get the default session
        session.setDebug(true);

        // create message
        Message msg = new javax.mail.internet.MimeMessage(session);

        // set from and to address
        try {
            msg.setFrom(new InternetAddress(from, from));
            msg.setReplyTo(new InternetAddress[]{new InternetAddress(from,from)});
        } catch (Exception e) {
            msg.setFrom(new InternetAddress(from));
            msg.setReplyTo(new InternetAddress[]{new InternetAddress(from)});
        }

        // set send date
        msg.setSentDate(Calendar.getInstance().getTime());

        // parse the recipients TO address
        Java.util.StringTokenizer st = new Java.util.StringTokenizer(toList, ",");
        int numberOfRecipients = st.countTokens();

        javax.mail.internet.InternetAddress[] addressTo = new javax.mail.internet.InternetAddress[numberOfRecipients];

        int i = 0;
        while (st.hasMoreTokens()) {
            addressTo[i++] = new javax.mail.internet.InternetAddress(st
                    .nextToken());
        }
        msg.setRecipients(javax.mail.Message.RecipientType.TO, addressTo);

        // parse the replyTo addresses
        if (replyToList != null && !"".equals(replyToList)) {
            st = new Java.util.StringTokenizer(replyToList, ",");
            int numberOfReplyTos = st.countTokens();
            javax.mail.internet.InternetAddress[] addressReplyTo = new javax.mail.internet.InternetAddress[numberOfReplyTos];
            i = 0;
            while (st.hasMoreTokens()) {
                addressReplyTo[i++] = new javax.mail.internet.InternetAddress(
                        st.nextToken());
            }
            msg.setReplyTo(addressReplyTo);
        }

        // parse the recipients CC address
        if (ccList != null && !"".equals(ccList)) {
            st = new Java.util.StringTokenizer(ccList, ",");
            int numberOfCCRecipients = st.countTokens();

            javax.mail.internet.InternetAddress[] addressCC = new javax.mail.internet.InternetAddress[numberOfCCRecipients];

            i = 0;
            while (st.hasMoreTokens()) {
                addressCC[i++] = new javax.mail.internet.InternetAddress(st
                        .nextToken());
            }

            msg.setRecipients(javax.mail.Message.RecipientType.CC, addressCC);
        }

        // parse the recipients BCC address
        if (bccList != null && !"".equals(bccList)) {
            st = new Java.util.StringTokenizer(bccList, ",");
            int numberOfBCCRecipients = st.countTokens();

            javax.mail.internet.InternetAddress[] addressBCC = new javax.mail.internet.InternetAddress[numberOfBCCRecipients];

            i = 0;
            while (st.hasMoreTokens()) {
                addressBCC[i++] = new javax.mail.internet.InternetAddress(st
                        .nextToken());
            }

            msg.setRecipients(javax.mail.Message.RecipientType.BCC, addressBCC);
        }

        // set header
        msg.addHeader("X-Mailer", "MyAppMailer");
        msg.addHeader("Precedence", "bulk");
        // setting the subject and content type
        msg.setSubject(subject);

        Multipart mp = new MimeMultipart("related");

        // set body message
        MimeBodyPart bodyMsg = new MimeBodyPart();
        bodyMsg.setText(txtBody, "iso-8859-1");
        if (attachments.size()>0) htmlBody = htmlBody.replaceAll("#filename#",attachments.get(0).getFilename());
        if (htmlBody.indexOf("#header#")>=0) htmlBody = htmlBody.replaceAll("#header#",attachments.get(1).getFilename());
        if (htmlBody.indexOf("#footer#")>=0) htmlBody = htmlBody.replaceAll("#footer#",attachments.get(2).getFilename());

        bodyMsg.setContent(htmlBody, "text/html");
        mp.addBodyPart(bodyMsg);

        // set attachements if any
        if (attachments != null && attachments.size() > 0) {
            for (i = 0; i < attachments.size(); i++) {
                Attachment a = attachments.get(i);
                BodyPart att = new MimeBodyPart();
                att.setDataHandler(new DataHandler(a.getDataSource()));
                att.setFileName( a.getFilename() );
                att.setHeader("Content-ID", "<" + a.getFilename() + ">");
                mp.addBodyPart(att);
            }
        }
        msg.setContent(mp);

        // send it
        try {
            javax.mail.Transport.send(msg);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * SimpleAuthenticator is used to do simple authentication when the SMTP
     * server requires it.
     */
    private static class SMTPAuthenticator extends javax.mail.Authenticator {

        @Override
        protected PasswordAuthentication getPasswordAuthentication() {

            String username = DataService
                    .getSetting(DataService.SETTING_SMTP_USER);
            String password = DataService
                    .getSetting(DataService.SETTING_SMTP_PASSWORD);

            return new PasswordAuthentication(username, password);
        }
    }

    public String getToList() {
        return toList;
    }

    public void setToList(String toList) {
        this.toList = toList;
    }

    public String getCcList() {
        return ccList;
    }

    public void setCcList(String ccList) {
        this.ccList = ccList;
    }

    public String getBccList() {
        return bccList;
    }

    public void setBccList(String bccList) {
        this.bccList = bccList;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public void setFrom(String from) {
        this.from = from;
    }

    public void setTxtBody(String body) {
        this.txtBody = body;
    }

    public void setHtmlBody(String body) {
        this.htmlBody = body;
    }

    public String getReplyToList() {
        return replyToList;
    }

    public void setReplyToList(String replyToList) {
        this.replyToList = replyToList;
    }

    public boolean isAuthenticationRequired() {
        return authenticationRequired;
    }

    public void setAuthenticationRequired(boolean authenticationRequired) {
        this.authenticationRequired = authenticationRequired;
    }

}

Und benutze diese Klasse:

MailService mailer = new MailService("[email protected]","[email protected]","Subject","TextBody", "<b>HtmlBody</b>", (Attachment) null);
try {
    mailer.sendAuthenticated();
} catch (Exception e) {
    Log.e(AskTingTing.APP, "Failed sending email.", e);
}

Zweiter Weg . Wenn Sie nichts dagegen haben, den nativen E-Mail-Client oder Google Mail zum Senden der E-Mail unter Android zu verwenden (der Benutzer muss jedoch letztendlich im E-Mail-Client auf die Schaltfläche "Senden" klicken), können Sie Folgendes tun:

startActivity(new Intent(Intent.ACTION_SENDTO, Uri.parse("mailto:[email protected]")));
35
Mathias Conradt

Fügen Sie diese Codezeile in Ihre Submit-Schaltfläche ein

 final Intent emailIntent = new Intent(Android.content.Intent.ACTION_SEND);
                              emailIntent.setType("text/plain");
                              emailIntent.putExtra(Android.content.Intent.EXTRA_EMAIL, new String\[\]{  "[email protected]"});
                              emailIntent.putExtra(Android.content.Intent.EXTRA_SUBJECT, "Hello There");
                              emailIntent.putExtra(Android.content.Intent.EXTRA_TEXT, "Add Message here");


                                emailIntent.setType("message/rfc822");

                            try {
                                startActivity(Intent.createChooser(emailIntent,
                                        "Send email using..."));
                            } catch (Android.content.ActivityNotFoundException ex) {
                                Toast.makeText(getActivity(),
                                        "No email clients installed.",
                                        Toast.LENGTH_SHORT).show();
                            }

                        }
                    });

Android wählt automatisch Clients aus, die auf Ihrem Gerät verfügbar sind, und der Benutzer kann den gewünschten E-Mail-Client frei wählen

 Intent app chooser

Angenommen, der Benutzer wählt gmail als Mailing-Client aus, der so aussehen würde: -

 Send mail simply

Pluspunkt für diese Methode ist, dass Sie in App keine zusätzlichen Dosen hinzufügen und dem Benutzer die Wahl der Aktion geben.

11
Hitesh Sahu
        public class MainActivity extends Activity 
        {
            private static final String username = "emailaddress";
            private static final String password = "password";
            private EditText emailEdit;
            private EditText subjectEdit;
            private EditText messageEdit;
            private Multipart _multipart;

            @SuppressLint("SdCardPath")
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);

                emailEdit = (EditText) findViewById(R.id.email);
                subjectEdit = (EditText) findViewById(R.id.subject);
                messageEdit = (EditText) findViewById(R.id.message);
                Button sendButton = (Button) findViewById(R.id.send);

                sendButton.setOnClickListener(new View.OnClickListener() 
                {
                    @Override
                    public void onClick(View view) 
                    {
                        String email = emailEdit.getText().toString();
                        String subject = subjectEdit.getText().toString();
                        String message = messageEdit.getText().toString();

                        sendMail(email, subject, message);
                    }
                });
            }

            private void sendMail(String email, String subject, String messageBody) 
            {
                Session session = createSessionObject();

                try {
                    Message message = createMessage(email, subject, messageBody, session);
                    new SendMailTask().execute(message);
                } catch (AddressException e) {
                    e.printStackTrace();
                } catch (MessagingException e) {
                    e.printStackTrace();
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }

            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); 
                } 
            private Message createMessage(String email, String subject, String messageBody, Session session) throws MessagingException, UnsupportedEncodingException {
                Message message = new MimeMessage(session);
                message.setFrom(new InternetAddress("[email protected]", "Tiemen Schut"));
                message.addRecipient(Message.RecipientType.TO, new InternetAddress(email, email));
                message.setSubject(subject);
                message.setText(messageBody);
                return message;
            }

            private Session createSessionObject() {
                Properties properties = new Properties();
                properties.put("mail.smtp.auth", "true");
                properties.put("mail.smtp.starttls.enable", "true");
                properties.put("mail.smtp.Host", "smtp.gmail.com");
                properties.put("mail.smtp.port", "587");

                return Session.getInstance(properties, new javax.mail.Authenticator() {
                    protected PasswordAuthentication getPasswordAuthentication() {
                        return new PasswordAuthentication(username, password);
                    }
                });
            }

            private class SendMailTask extends AsyncTask<Message, Void, Void> {
                private ProgressDialog progressDialog;

                @Override
                protected void onPreExecute() {
                    super.onPreExecute();
                    progressDialog = ProgressDialog.show(MainActivity.this, "Please wait", "Sending mail", true, false);
                }

                @Override
                protected void onPostExecute(Void aVoid) {
                    super.onPostExecute(aVoid);
                    progressDialog.dismiss();
                }

                @Override
                protected Void doInBackground(Message... messages) {
                    try {
                        Transport.send(messages[0]);
                    } catch (MessagingException e) {
                        e.printStackTrace();
                    }
                    return null;
                }
            }
        }

fügen Sie drei JAR-Dateien in Ihren libs-Ordner ein und probieren Sie diese Mail.jar!

aktivierung.jar!

zusätzliche.jar!

Schreiben Sie den Betreff oder den Nachrichtentext direkt und entfernen Sie edittext. Sie werden direkt eine E-Mail aus Ihrer App senden.

Und vergessen Sie nicht, INTERNET PERMISSION in Ihrem Manifest zu geben

2
Dharmesh

Eine weitere Sache, ich habe die Ansätze in verschiedenen Antworten dieser Seite verwendet, aber es würde einfach nicht funktionieren. Das erste Problem war die Firewall: Transport.send(message) hat die folgende Ausnahme ausgelöst:

 javax.mail.MessagingException: Could not connect to SMTP Host: smtp.gmail.com, port: 465;
  nested exception is:
    Java.net.SocketTimeoutException: failed to connect to smtp.gmail.com/64.233.184.108 (port 465) after 90000ms

In diesem Fall blockiert Ihre Firewall Sie. Versuchen Sie ein anderes Netzwerk.

Nachdem ich das Netzwerk gewechselt habe, habe ich eine E-Mail von Google erhalten, dass eine weniger sichere Anwendung versucht hat, mein Konto zu verwenden.

Die Lösung bestand darin, den GMail-Zugriff für weniger sichere Anwendungen zu ermöglichen. Dies kann über diesen Link erfolgen:

https://support.google.com/accounts/answer/6010255?hl=de

1
lpapez