반응형
기본/빌트인 앱을 사용하지 않고 JavaMail API를 사용하여 Android에서 이메일 보내기
안드로이드에서 메일 보내기 앱을 만들려고 합니다.
사용하는 경우:
Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
내장 Android 어플리케이션이 기동합니다.이 어플리케이션을 사용하지 않고 버튼 클릭으로 메일을 직접 보내려고 합니다.
Gmail 인증을 사용하여 JavaMail API를 사용하여 Android로 이메일을 보냅니다.
샘플 프로젝트 작성 절차:
Mail Sender Activity.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");
}
}
}
JSEProvider.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;
}
});
}
}
다음 링크에 있는 3개의 항아리를 Android 프로젝트에 추가합니다.
그리고 매니페스트에 다음 행을 추가하는 것을 잊지 마세요.
<uses-permission android:name="android.permission.INTERNET" />
보안 수준이 낮은 앱에 대한 계정 액세스를 변경하려면 아래 링크를 클릭하십시오. https://www.google.com/settings/security/lesssecureapps
프로젝트를 실행하고 수신인 메일 계정에서 메일을 확인합니다.건배!
추신: Android에서는 어떤 액티비티에서도 네트워크 조작을 할 수 없다는 것을 잊지 마세요.따라서 이 기능을 사용하는 것이 좋습니다.AsyncTask ★★★★★★★★★★★★★★★★★」IntentService메인 스레드에서의 네트워크 예외를 회피합니다.
Jar 파일: https://code.google.com/archive/p/javamail-android/
귀중한 정보 감사합니다.코드는 정상적으로 동작하고 있다.아래 코드를 추가하여 첨부파일을 추가할 수 있습니다.
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);
SMTP 호스트에 연결할 수 없음: smtp.gmail.com, 포트: 465
매니페스트에 다음 행을 추가합니다.
<uses-permission android:name="android.permission.INTERNET" />
JavaMail API를 사용하여 이메일 작업을 처리할 수 있습니다.JavaMail API는 JavaEE 패키지로 제공되며 jar는 다운로드할 수 있습니다.안타깝게도 안드로이드와 완전히 호환되지 않는 AWT 컴포넌트를 사용하기 때문에 안드로이드 어플리케이션에서 직접 사용할 수 없습니다.
JavaMail용 Android 포트는 http://code.google.com/p/javamail-android/에서 찾을 수 있습니다.
응용 프로그램에 jars를 추가하고 SMTP 메서드를 사용합니다.
데모를 사용한 100% 작업 코드 이 답변을 사용하여 여러 개의 이메일을 보낼 수도 있습니다.
여기에서 프로젝트 다운로드
1단계: Android Studio에서 메일, 활성화, 추가 jar 파일을 다운로드하고 프로젝트 libs 폴더에 추가합니다.아래 다운로드 링크를 참고하여 스크린샷을 추가했습니다.
gmail로 로그인(메일에서 사용) 및 ON 토글 버튼 링크
대부분의 사람들은 이 단계를 잊는다. 나는 네가 하지 않기를 바란다.
스텝 2 : 이 프로세스를 완료한 후이 클래스를 프로젝트에 복사하여 붙여넣습니다.
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.");
}
}
Send Mail Task.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();
}
}
스텝 3 : 필요에 따라 이 클래스를 변경할 수도 있습니다.또, 이 클래스를 사용해 복수의 메일을 송신할 수도 있습니다.xml과 java 파일 둘 다 제공합니다.
activity_main.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"
기본/빌트인 앱을 사용하지 않고 JavaMail API를 사용하여 Android에서 이메일 보내기 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>
Send Mail Activity.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);
}
});
}
}
참고 AndroidManifest.xml 파일에 인터넷 권한을 추가하는 것을 잊지 마십시오.
<uses-permission android:name="android.permission.INTERNET"/>
만약 그것이 효과가 없다면 아래에 코멘트만 남겨주세요.
SDK Target >9를 사용하여 Network On Main Thread Exception을 얻는 사용자를 지원하기 위해.이것은 위의 droopie 코드를 사용하고 있지만, 어느 경우에도 동일하게 동작합니다.
StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(policy);
android.os.NetworkOnMainThreadException
아래와 같이 비동기 태스크를 사용할 수 있습니다.
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;
}
}
SMTP
SMTP 를 사용하는 것도 하나의 방법이며, 그 외의 방법에서는 이미 지적되고 있습니다.이 작업을 수행하는 동안 내장된 메일 앱을 완전히 우회하여 SMTP 서버의 주소, 해당 서버의 사용자 이름 및 암호를 코드로 정적으로 제공하거나 사용자에게 문의해야 합니다.
HTTP
또 다른 방법으로는 php와 같은 간단한 서버 사이드 스크립트를 사용할 수 있습니다.이 스크립트는 몇 가지 URL 파라미터를 사용하여 메일을 보냅니다.이 방법에서는, 디바이스로부터의 HTTP 요구(빌트인 라이브러리로 간단하게 가능)만 하면 됩니다.SMTP 로그인 데이터를 디바이스에 보존할 필요가 없습니다.이것은 직접적인 SMTP 사용에 비해 한 가지 더 간접적인 방법이지만, HTTP 요청과 PHP로부터의 메일 송신이 매우 쉽기 때문에 직접 방법보다 더 간단할 수 있습니다.
메일 응용 프로그램
만약 그가 이미 전화기에 등록된 사용자의 기본 메일 계정에서 메일이 전송되어야 한다면, 당신은 다른 방법을 취해야 할 것입니다.충분한 시간과 경험이 있다면 Android Email 응용 프로그램의 소스 코드를 확인하여 사용자 개입 없이 메일을 보낼 수 있는 진입점을 제공하는지 확인할 수 있습니다(모르겠습니다만, 있을 수도 있습니다).
사용자 계정에 대한 세부 정보(SMTP에 사용할 수 있도록)를 조회하는 방법을 찾을 수도 있지만, 보안 위험이 크고 Android가 상당히 안전하게 구축되어 있기 때문에 이것이 가능할지는 의문입니다.
여기에도 기능하는 alt 버전이 있고 첨부파일이 있습니다(이미 위에 있지만 소스 링크와 달리 완전한 버전이 있습니다.데이터가 없어 기능을 할 수 없다고 사람들이 게시했습니다).
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 …..
}
그걸 활동이라고 부르면...
@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);
}
}
});
}
GmailBackground는 사용자의 조작 없이 백그라운드에서 이메일을 보낼 수 있는 작은 라이브러리입니다.
사용방법:
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();
설정:
repositories {
// ...
maven { url "https://jitpack.io" }
}
dependencies {
compile 'com.github.yesidlazaro:GmailBackground:1.2.0'
}
권한:
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.INTERNET"/>
첨부 파일의 경우 READ_EXTERNAL_STORE 권한을 설정해야 합니다.
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
(제가 직접 테스트했습니다)
기본 smtp 서버로 "smtp.gmail.com"을 사용할 경우 경고 메시지입니다.
구글은 지나치게 열성적인 "수상한 활동" 정책 때문에 링크된 이메일 계정의 비밀번호를 자주 변경하도록 강요할 것입니다.기본적으로 짧은 시간 내에 여러 국가에서 반복된 smtp 요청을 "수상한 활동"으로 처리합니다.고객(이메일 계정 소유자)은 한 번에 한 국가에만 존재할 수 있습니다.
Google 시스템에서 "수상한 활동"을 탐지하면 암호를 변경할 때까지 더 이상의 전자 메일을 차단합니다.비밀번호는 앱에 하드코드로 입력되어 있기 때문에 매번 앱을 재출시해야 합니다. 이상적이지 않습니다.일주일에 3번 이런 일이 있었고, 심지어 비밀번호를 다른 서버에 저장했다가 구글이 비밀번호를 강제로 변경할 때마다 동적으로 비밀번호를 가져옵니다.
따라서 이 보안 문제를 피하기 위해 "smtp.gmail.com" 대신 많은 무료 smtp 공급자 중 하나를 사용할 것을 권장합니다.같은 코드를 사용하지만, 「smtp.gmail.com」를 새로운 smtp 전송 호스트로 변경합니다.
편집: Java Mail 1.5.5는 Android를 지원하므로 다른 것은 필요하지 않습니다.
Java Mail(1.5.4), Android, Java Mail(1.5.4), Java Mail(1.5.4)메이븐 센트럴음음 츠키 build.gradle~~
compile 'eu.ocathain.com.sun.mail:javax.mail:1.5.4'
그런 다음 공식 자습서를 따를 수 있습니다.
소스 코드는, https://bitbucket.org/artbristol/javamail-forked-android 에서 입수할 수 있습니다.
도움이 필요한 다른 사람들을 위한 더 짧은 대안을 찾았습니다.코드는 다음과 같습니다.
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);
}
}
}
도움이 되길 바랍니다!행운을 빕니다.
첨부파일이 첨부된 메일 발송용..
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();}
}
}
ClassDefNotFoundError그 3개의 jar files를 프로젝트의 lib 폴더로 옮겨봐, 나한테는 효과가 있었어!!
Vinayak B의 코드를 실행할 수 없습니다.마지막으로 이 문제를 다음과 같이 해결했습니다.
1. 이것을 사용하다
2. 비동기 태스크 적용
3. 발송자 gmail 계정의 보안 문제 변경.('ON'으로 변경)
Apache Commons Net 사용을 고려했습니까? 3.3 이후 단 하나의 jar(그래들 또는 maven을 사용하여 의존할 수 있음)만 있으면 됩니다.http://blog.dahanne.net/2013/06/17/sending-a-mail-in-java-and-android-with-apache-commons-net/
유저의 조작 없이, 다음과 같이 송신할 수 있습니다.
클라이언트 apk에서 이메일을 보냅니다.Java 이메일을 보내려면 mail.jar, activation.jar가 필요합니다.이러한 병을 추가하면 APK 크기가 커질 수 있습니다.
또는 서버측 코드에서 웹 서비스를 사용할 수도 있습니다.이 코드는 동일한 mail.jar와 activation.jar를 사용하여 이메일을 보낼 수 있습니다.비동기 태스크를 통해 웹 서비스를 호출하고 이메일을 보낼 수 있습니다.같은 링크를 참조해 주세요.
(단, 메일 계정의 credential을 알아야 합니다.)
jar 라이브러리를 가능한 한 작게 유지해야 하는 경우 SMTP/POP3/IMAP 기능을 별도로 포함하여 "dex에 너무 많은 메서드" 문제를 방지할 수 있습니다.
javanet 웹 페이지에서 원하는 jar 라이브러리를 선택할 수 있습니다. 예를 들어 mailapi.jar + imap.jar를 사용하면 IMAP 프로토콜의 icloud, hotmail 메일 서버에 액세스할 수 있습니다.(additional.jar 및 activation.jar를 사용하여)
저는 @Vinayak B가 제출한 코드를 사용해 보았습니다.그러나 다음과 같은 오류가 표시됩니다.smtp 제공자 없음
이에 대한 새로운 질문을 작성했습니다.자세한 내용은 이쪽입니다.
결국 내가 직접 고칠 수 있었다.다른 mail.jar를 사용해야 했고 "보안성이 낮은 앱을 위한 액세스"가 켜져 있는지 확인해야 했습니다.
나는 이것이 같은 문제를 가진 사람에게 도움이 되기를 바란다.이렇게 하면 이 코드 조각은 구글 글라스에서도 작동합니다.
다른 답변에 있는 코드는 모두 정확하고 정상적으로 동작하고 있습니다만, 조금 지저분하기 때문에, 사용하기 쉬운 라이브러리(아직도 개발중)를 공개하기로 했습니다: Android Mail.
Mail Sender를 만들고 메일을 작성하여 전송하기만 하면 됩니다(이미 백그라운드에서 Async Task로 처리되어 있습니다).
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);
전송된 이메일에 대한 알림을 받을 수 있으며 다양한 수신자 유형(TO, CC 및 BCC), 첨부 파일 및 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 :(
}
});
Gradle 또는 Maven을 통해 얻을 수 있습니다.
compile 'it.enricocandino:androidmail:1.0.0-SNAPSHOT'
문제가 있으면 알려주세요! :)
여기 많은 해결책이 있습니다.단, 보안이 낮은 디바이스에서 접근할 수 있도록 GMail 설정을 변경해야 합니다.다음 링크로 이동하여 활성화하십시오.난 괜찮아
https://myaccount.google.com/lesssecureapps?pli=1
Kotlin과 함께 프로그래밍 방식으로 이메일을 보냅니다.
- 다른 모든 기능(첨부 파일 등)은 아니지만 간단한 이메일 전송이 가능합니다.
- TLS는 항상 켜져 있습니다.
- gradle e-mail 의존관계도 1개만 있으면 됩니다.
이 이메일 POP 서비스 목록도 매우 도움이 되었습니다.
사용방법:
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)
}
코드:
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"
}
}
그라들:
dependencies {
implementation 'com.sun.mail:android-mail:1.6.4'
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.3"
}
Android Manifest:
<uses-permission android:name="android.permission.INTERNET" />
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;
}
}
2020년에 Kotlin에서 Java Mail을 사용하고 싶은 분:
첫 번째: 이러한 의존관계를 build.gradle 파일에 추가합니다(공식 Java Mail Maven 의존관계).
실장 'com.sun.mail:filename-mail:1.6.5'
실장 'com.sun.mail:syslog-activation:1.6.5'
구현 "bcmail.cycastle:bcmail-jdk15on:1.65"
구현 "displement.jetbrains" 입니다.kotlinx: scotlinx-coroutines-core: 1.3.7인치
구현 "displement.jetbrains" 입니다.kotlinx:glinx-coroutines-glines:1.3.7인치
BouncyCastle은 보안상의 이유로 사용됩니다.
두 번째: AndroidManifest.xml에 이러한 권한을 추가합니다.
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
세 번째: SMTP를 사용할 경우 구성 파일을 만듭니다.
object Config {
const val EMAIL_FROM = "You_Sender_Email@email.com"
const val PASS_FROM = "Your_Sender_Password"
const val EMAIL_TO = "Your_Destination_Email@email.com"
}
네 번째: 메일러 오브젝트 작성
object Mailer {
init {
Security.addProvider(BouncyCastleProvider())
}
private fun props(): Properties = Properties().also {
// Smtp server
it["mail.smtp.host"] = "smtp.gmail.com"
// Change when necessary
it["mail.smtp.auth"] = "true"
it["mail.smtp.port"] = "465"
// Easy and fast way to enable ssl in JavaMail
it["mail.smtp.ssl.enable"] = true
}
// Dont ever use "getDefaultInstance" like other examples do!
private fun session(emailFrom: String, emailPass: String): Session = Session.getInstance(props(), object : Authenticator() {
override fun getPasswordAuthentication(): PasswordAuthentication {
return PasswordAuthentication(emailFrom, emailPass)
}
})
private fun builtMessage(firstName: String, surName: String): String {
return """
<b>Name:</b> $firstName <br/>
<b>Surname:</b> $surName <br/>
""".trimIndent()
}
private fun builtSubject(issue: String, firstName: String, surName: String):String {
return """
$issue | $firstName, $surName
""".trimIndent()
}
private fun sendMessageTo(emailFrom: String, session: Session, message: String, subject: String) {
try {
MimeMessage(session).let { mime ->
mime.setFrom(InternetAddress(emailFrom))
// Adding receiver
mime.addRecipient(Message.RecipientType.TO, InternetAddress(Config.EMAIL_TO))
// Adding subject
mime.subject = subject
// Adding message
mime.setText(message)
// Set Content of Message to Html if needed
mime.setContent(message, "text/html")
// send mail
Transport.send(mime)
}
} catch (e: MessagingException) {
Log.e("","") // Or use timber, it really doesn't matter
}
}
fun sendMail(firstName: String, surName: String) {
// Open a session
val session = session(Config.EMAIL_FROM, Config.PASSWORD_FROM)
// Create a message
val message = builtMessage(firstName, surName)
// Create subject
val subject = builtSubject(firstName, surName)
// Send Email
CoroutineScope(Dispatchers.IO).launch { sendMessageTo(Config.EMAIL_FROM, session, message, subject) }
}
메모
- 보다 안전한 전자 메일 전송 방법을 원하는 경우(및 보다 안전한 방법을 원하는 경우) 앞서 설명한 솔루션과 같이 http를 사용하십시오(이 답변에서 나중에 추가할 수도 있습니다).
- 사용자의 전화기가 인터넷에 접속할 수 있는지 확인해야 합니다. 그렇지 않으면 앱이 충돌합니다.
- gmail을 사용할 경우 "보안성이 낮은 앱"을 활성화하십시오(gmail이 두 가지 요소를 활성화하면 작동하지 않습니다). https://myaccount.google.com/lesssecureapps?pli=1
- 일부 크레딧은 https://medium.com/@chetan.garg36/cred-send-mails-not-cred-642d2ee(솔루션에 RxJava를 사용)에 속합니다.
package io.formics.tourguide
import android.annotation.SuppressLint
import android.content.Intent
import android.net.Credentials
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import kotlinx.android.synthetic.main.activity_feedback.*
import org.jetbrains.annotations.Async
import java.lang.Exception
import java.util.Properties;
import javax.activation.DataHandler;
import javax.activation.FileDataSource
import javax.mail.*
import javax.mail.internet.*
class FeedbackActivity : AppCompatActivity() {
val props = Properties()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_feedback)
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");
btnSendEmail.setOnClickListener {
Thread {
try {
sendEmail()
// Your implementation
} catch (ex: Exception) {
ex.printStackTrace()
}
}.start()
}
}
private fun sendEmail() {
try {
val session = Session.getInstance(props,
object : javax.mail.Authenticator() {
//Authenticating the password
override fun getPasswordAuthentication(): javax.mail.PasswordAuthentication {
return PasswordAuthentication("abc@xyz.com", "password")
}
})
val message = MimeMessage(session);
message.setFrom(InternetAddress("abc@xyz.com"));
message.setRecipients(
Message.RecipientType.TO,
InternetAddress.parse(editCC.text.toString())
)
message.subject = editSubject.text.toString()
message.setText(
"Dear Mail Crawler,"
+ "\n\n No spam to my email, please!"
);
//val messageBodyPart = MimeBodyPart();
//val multipart = MimeMultipart();
//val file = "path of file to be attached";
// val fileName = "attachmentName"
// val source = FileDataSource(file);
//messageBodyPart.setDataHandler(DataHandler(source));
//messageBodyPart.setFileName(fileName);
//multipart.addBodyPart(messageBodyPart);
//message.setContent(multipart);
Transport.send(message);
System.out.println("Done");
} catch (e: MessagingException) {
throw RuntimeException(e);
}
}
}
첨부 파일을 추가하려면 추가하는 것을 잊지 마십시오.
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);
언급URL : https://stackoverflow.com/questions/2020088/sending-email-in-android-using-javamail-api-without-using-the-default-built-in-a
반응형
'programing' 카테고리의 다른 글
| Vuex 작업에 여러 매개 변수 전달 (0) | 2022.07.03 |
|---|---|
| nuxt.js 스토어에서 플러그인에 액세스하는 방법 (0) | 2022.07.03 |
| Linux 개발 프로젝트를 위한 Clang vs GCC (0) | 2022.07.03 |
| Java Result 결과가 있는지 확인하는 방법을 설정합니다. (0) | 2022.07.03 |
| Collections.emptyList()와 새 인스턴스 비교 (0) | 2022.07.03 |