Отправка почты в Android: интеграция JavaMail API без лишних кликов

dependencies {
// JavaMail API
implementation 'com.sun.mail:android-mail:1.6.5'
implementation 'com.sun.mail:android-activation:1.6.5'

// Дополнительно для асинхронной работы (опционально)
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.emailapp">

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

<!-- Остальное содержимое манифеста -->
</manifest>

<!-- Для Android 9 (API 28) и ниже -->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

<!-- Для Android 10 (API 29) и выше -->
<uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
<uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
<uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />

<!-- res/xml/network_security_config.xml -->
<network-security-config>
<base-config cleartextTrafficPermitted="true">
<trust-anchors>
<certificates src="system" />
<certificates src="user" />
</trust-anchors>
</base-config>
</network-security-config>

<application
android:networkSecurityConfig="@xml/network_security_config"
... >
</application>

import java.util.Properties;
import javax.mail.Authenticator;
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 JavaMailSender {
private String host;
private String port;
private String username;
private String password;
private boolean isAuthRequired;
private boolean isStartTLSEnabled;

public JavaMailSender(String host, String port, String username, 
String password, boolean isAuthRequired, 
boolean isStartTLSEnabled) {
this.host = host;
this.port = port;
this.username = username;
this.password = password;
this.isAuthRequired = isAuthRequired;
this.isStartTLSEnabled = isStartTLSEnabled;
}

// Метод для создания и настройки почтовой сессии
private Session createSession() {
Properties props = new Properties();
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", port);

if (isAuthRequired) {
props.put("mail.smtp.auth", "true");
}

if (isStartTLSEnabled) {
props.put("mail.smtp.starttls.enable", "true");
}

// Дополнительные настройки для отладки
props.put("mail.debug", "true");
props.put("mail.smtp.socketFactory.fallback", "false");

// Создание сессии с аутентификацией, если требуется
if (isAuthRequired) {
return Session.getInstance(props, new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
} else {
return Session.getInstance(props);
}
}

// Метод для отправки простого текстового сообщения
public void sendTextEmail(String toAddress, String fromAddress, 
String subject, String body) throws MessagingException {
Session session = createSession();

try {
MimeMessage message = new MimeMessage(session);

// Установка адресов отправителя и получателя
message.setFrom(new InternetAddress(fromAddress));
message.setRecipient(Message.RecipientType.TO, new InternetAddress(toAddress));

// Установка темы и текста письма
message.setSubject(subject);
message.setText(body);

// Отправка сообщения
Transport.send(message);

} catch (MessagingException e) {
throw new MessagingException("Ошибка при отправке email: " + e.getMessage(), e);
}
}
}

// Kotlin + Coroutines пример использования
class EmailViewModel : ViewModel() {

private val _emailStatus = MutableLiveData<String>()
val emailStatus: LiveData<String> = _emailStatus

fun sendEmail(recipient: String, subject: String, body: String) {
viewModelScope.launch(Dispatchers.IO) {
try {
val sender = JavaMailSender(
"smtp.gmail.com", 
"587", 
"your-email@gmail.com", 
"your-password-or-app-password", 
true, 
true
)

sender.sendTextEmail(
recipient,
"your-email@gmail.com",
subject,
body
)

withContext(Dispatchers.Main) {
_emailStatus.value = "Email успешно отправлен!"
}
} catch (e: MessagingException) {
withContext(Dispatchers.Main) {
_emailStatus.value = "Ошибка: ${e.message}"
}
}
}
}
}

// Java пример с ExecutorService
public class EmailSendTask {

private ExecutorService executor = Executors.newSingleThreadExecutor();
private Handler handler = new Handler(Looper.getMainLooper());

interface EmailCallback {
void onSuccess();
void onError(String error);
}

public void sendEmailAsync(String recipient, String subject, 
String body, EmailCallback callback) {
executor.execute(() -> {
try {
JavaMailSender sender = new JavaMailSender(
"smtp.gmail.com", 
"587", 
"your-email@gmail.com", 
"your-password-or-app-password", 
true, 
true
);

sender.sendTextEmail(
recipient,
"your-email@gmail.com",
subject,
body
);

handler.post(() -> {
callback.onSuccess();
});
} catch (MessagingException e) {
handler.post(() -> {
callback.onError("Ошибка: " + e.getMessage());
});
}
});
}

public void shutdown() {
executor.shutdown();
}
}

// Добавьте этот метод в класс JavaMailSender
public boolean testConnection() {
try {
Session session = createSession();
Transport transport = session.getTransport("smtp");
transport.connect(host, username, password);
transport.close();
return true;
} catch (MessagingException e) {
e.printStackTrace();
return false;
}
}

import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMultipart;
import javax.mail.Multipart;

// Добавьте этот метод в класс JavaMailSender
public void sendHtmlEmail(String toAddress, String fromAddress,
String subject, String htmlBody) throws MessagingException {
Session session = createSession();

try {
MimeMessage message = new MimeMessage(session);

// Установка адресов отправителя и получателя
message.setFrom(new InternetAddress(fromAddress));
message.setRecipient(Message.RecipientType.TO, new InternetAddress(toAddress));

// Установка темы
message.setSubject(subject);

// Создание части сообщения с HTML-содержимым
MimeBodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setContent(htmlBody, "text/html; charset=utf-8");

// Создание мультичастного сообщения
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Установка содержимого сообщения
message.setContent(multipart);

// Отправка сообщения
Transport.send(message);

} catch (MessagingException e) {
throw new MessagingException("Ошибка при отправке HTML-email: " + e.getMessage(), e);
}
}

import java.io.File;
import javax.activation.DataHandler;
import javax.activation.FileDataSource;

// Добавьте этот метод в класс JavaMailSender
public void sendEmailWithAttachments(String toAddress, String fromAddress,
String subject, String body, boolean isHtml,
List<File> attachments) throws MessagingException {
Session session = createSession();

try {
MimeMessage message = new MimeMessage(session);

// Установка адресов и темы
message.setFrom(new InternetAddress(fromAddress));
message.setRecipient(Message.RecipientType.TO, new InternetAddress(toAddress));
message.setSubject(subject);

// Создание части сообщения с текстом
MimeBodyPart messageBodyPart = new MimeBodyPart();
if (isHtml) {
messageBodyPart.setContent(body, "text/html; charset=utf-8");
} else {
messageBodyPart.setText(body);
}

// Создание мультичастного сообщения
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Добавление вложений
if (attachments != null && !attachments.isEmpty()) {
for (File file : attachments) {
MimeBodyPart attachmentPart = new MimeBodyPart();
FileDataSource source = new FileDataSource(file);
attachmentPart.setDataHandler(new DataHandler(source));
attachmentPart.setFileName(file.getName());
multipart.addBodyPart(attachmentPart);
}
}

// Установка содержимого сообщения
message.setContent(multipart);

// Отправка сообщения
Transport.send(message);

} catch (MessagingException e) {
throw new MessagingException("Ошибка при отправке email с вложениями: " + e.getMessage(), e);
}
}

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

// Вспомогательный метод для создания временного файла из ресурса
public File resourceToFile(Context context, int resourceId, String fileName) throws IOException {
Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(), resourceId);
File file = new File(context.getCacheDir(), fileName);

ByteArrayOutputStream bos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, bos);
byte[] bitmapData = bos.toByteArray();

FileOutputStream fos = new FileOutputStream(file);
fos.write(bitmapData);
fos.flush();
fos.close();

return file;
}

public class EmailBuilder {
private String toAddress;
private String fromAddress;
private String subject = "";
private String textBody = "";
private String htmlBody = null;
private List<File> attachments = new ArrayList<>();
private JavaMailSender mailSender;

public EmailBuilder(JavaMailSender mailSender) {
this.mailSender = mailSender;
}

public EmailBuilder to(String toAddress) {
this.toAddress = toAddress;
return this;
}

public EmailBuilder from(String fromAddress) {
this.fromAddress = fromAddress;
return this;
}

public EmailBuilder subject(String subject) {
this.subject = subject;
return this;
}

public EmailBuilder textBody(String textBody) {
this.textBody = textBody;
return this;
}

public EmailBuilder htmlBody(String htmlBody) {
this.htmlBody = htmlBody;
return this;
}

public EmailBuilder addAttachment(File file) {
this.attachments.add(file);
return this;
}

public void send() throws MessagingException {
if (toAddress == null || fromAddress == null) {
throw new IllegalStateException("Адреса отправителя и получателя должны быть указаны");
}

if (htmlBody != null) {
if (attachments.isEmpty()) {
mailSender.sendHtmlEmail(toAddress, fromAddress, subject, htmlBody);
} else {
mailSender.sendEmailWithAttachments(toAddress, fromAddress, subject, 
htmlBody, true, attachments);
}
} else {
if (attachments.isEmpty()) {
mailSender.sendTextEmail(toAddress, fromAddress, subject, textBody);
} else {
mailSender.sendEmailWithAttachments(toAddress, fromAddress, subject, 
textBody, false, attachments);
}
}
}
}

// Kotlin пример использования Builder-а
fun sendWelcomeEmail(context: Context, userEmail: String) {
viewModelScope.launch(Dispatchers.IO) {
try {
val sender = JavaMailSender(
"smtp.gmail.com", 
"587", 
"your-app-email@gmail.com", 
"your-app-password", 
true, 
true
)

// Создаем временный файл с логотипом
val logoFile = sender.resourceToFile(
context, 
R.drawable.logo, 
"company_logo.png"
)

// Формируем HTML-тело письма
val htmlBody = """
<!DOCTYPE html>
<html>
<head>
<style>
body { font-family: Arial, sans-serif; }
.header { color: #4285f4; }
.footer { font-size: 12px; color: #777; }
</style>
</head>
<body>
<h1 class="header">Добро пожаловать в наше приложение!</h1>
<p>Уважаемый пользователь,</p>
<p>Спасибо за регистрацию в нашем сервисе. Теперь вам доступны все функции приложения.</p>
<p>С уважением,<br>Команда поддержки</p>
<div class="footer">
© 2023 Наше Приложение. Все права защищены.
</div>
</body>
</html>
""".trimIndent()

// Используем Builder для конструирования и отправки письма
EmailBuilder(sender)
.to(userEmail)
.from("noreply@yourapp.com")
.subject("Добро пожаловать в приложение!")
.htmlBody(htmlBody)
.addAttachment(logoFile)
.send()

withContext(Dispatchers.Main) {
_emailStatus.value = "Приветственное письмо отправлено!"
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
_emailStatus.value = "Ошибка: ${e.message}"
}
}
}
}

import androidx.security.crypto.EncryptedSharedPreferences
import androidx.security.crypto.MasterKey

// Создание зашифрованных SharedPreferences
private fun createEncryptedPreferences(context: Context): SharedPreferences {
val masterKey = MasterKey.Builder(context)
.setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
.build()

return EncryptedSharedPreferences.create(
context,
"email_credentials",
masterKey,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
}

// Сохранение учетных данных
fun saveEmailCredentials(context: Context, username: String, password: String) {
val prefs = createEncryptedPreferences(context)
prefs.edit()
.putString("email_username", username)
.putString("email_password", password)
.apply()
}

// Получение учетных данных
fun getEmailCredentials(context: Context): Pair<String, String> {
val prefs = createEncryptedPreferences(context)
val username = prefs.getString("email_username", "") ?: ""
val password = prefs.getString("email_password", "") ?: ""
return Pair(username, password)
}

// Обновленный метод createSession() с усиленной безопасностью
private Session createSession() {
Properties props = new Properties();
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", port);

// Обязательные настройки для безопасности
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.ssl.trust", host);

// Дополнительные настройки для улучшения безопасности
props.put("mail.smtp.ssl.protocols", "TLSv1.2");
props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
props.put("mail.smtp.socketFactory.port", port);

return Session.getInstance(props, new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
}

// Определение Worker-а для отправки почты
public class EmailSendWorker extends Worker {

public EmailSendWorker(@NonNull Context context, @NonNull WorkerParameters params) {
super(context, params);
}

@NonNull
@Override
public Result doWork() {
String recipient = getInputData().getString("recipient");
String subject = getInputData().getString("subject");
String body = getInputData().getString("body");

try {
Context context = getApplicationContext();
Pair<String, String> credentials = getEmailCredentials(context);

JavaMailSender sender = new JavaMailSender(
"smtp.gmail.com", "587", 
credentials.first, credentials.second, 
true, true
);

sender.sendTextEmail(recipient, credentials.first, subject, body);
return Result.success();
} catch (Exception e) {
// Если это временная ошибка (проблемы с сетью), запрашиваем повторную попытку
if (isNetworkError(e)) {
return Result.retry();
}
return Result.failure();
}
}

private boolean isNetworkError(Exception e) {
return e instanceof ConnectException || e instanceof SocketTimeoutException;
}
}

// Пример использования WorkManager для отправки почты
void scheduleEmailSending(String recipient, String subject, String body) {
Data inputData = new Data.Builder()
.putString("recipient", recipient)
.putString("subject", subject)
.putString("body", body)
.build();

Constraints constraints = new Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.build();

OneTimeWorkRequest emailWork = new OneTimeWorkRequest.Builder(EmailSendWorker.class)
.setInputData(inputData)
.setConstraints(constraints)
.setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 10, TimeUnit.MINUTES)
.build();

WorkManager.getInstance(context).enqueue(emailWork);
}

// Метод для оптимизации изображения перед отправкой
private File optimizeImage(Context context, Uri imageUri, String fileName) throws IOException {
InputStream input = context.getContentResolver().openInputStream(imageUri);
Bitmap originalBitmap = BitmapFactory.decodeStream(input);
input.close();

// Определяем целевой размер (например, макс. ширина 1024px)
int maxWidth = 1024;
float scale = (float) maxWidth / originalBitmap.getWidth();
int targetWidth = maxWidth;
int targetHeight = (int) (originalBitmap.getHeight() * scale);

Bitmap resizedBitmap = Bitmap.createScaledBitmap(
originalBitmap, targetWidth, targetHeight, true);

// Качество JPEG (0-100), 85 обычно дает хороший баланс размер/качество
int quality = 85;

File outputFile = new File(context.getCacheDir(), fileName);
FileOutputStream fos = new FileOutputStream(outputFile);
resizedBitmap.compress(Bitmap.CompressFormat.JPEG, quality, fos);
fos.close();

return outputFile;
}