Direct Email Sending in Android Using JavaMail API: A Comprehensive Study

Introduction and Background

In Android application development, email sending functionality is a common requirement. Traditional implementation approaches involve using Intent.ACTION_SEND to invoke the system's default email application, but this method suffers from discontinuous user experience and dependency on external applications. This paper explores how to implement direct email sending within applications using JavaMail API, providing users with a more seamless interaction experience.

Core Architecture Design

JavaMail API provides comprehensive email processing capabilities for the Java platform, requiring special configuration to function properly in Android environments. The core architecture comprises three key components: the email sending activity, Gmail sender (GMailSender), and JSSE security provider.

Activity Layer Implementation

At the activity layer, we need to create a simple user interface containing a send button and trigger the email sending logic upon button click. It's crucial to note that network operations must be executed in background threads to avoid blocking the main thread.

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) {
                new AsyncTask<Void, Void, Void>() {
                    @Override
                    protected Void doInBackground(Void... params) {
                        try {   
                            GMailSender sender = new GMailSender("username@gmail.com", "password");
                            sender.sendMail("Email Subject",   
                                    "Email Body Content",   
                                    "sender@gmail.com",   
                                    "recipient@example.com");   
                        } catch (Exception e) {   
                            Log.e("SendMail", e.getMessage(), e);   
                        }
                        return null;
                    }
                }.execute();
            }
        });
    }
}

Email Sender Implementation

The GMailSender class serves as the core of the entire email sending functionality, extending javax.mail.Authenticator and handling SMTP server authentication and email sending processes.

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 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) {
            throw 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");   
        }   
    }   
}

Security Provider Configuration

The JSSEProvider is a critical component ensuring proper SSL/TLS connection functionality, providing necessary cryptographic service implementations for Java's security architecture.

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

Dependencies and Permission Configuration

Implementing this functionality requires adding the following JAR files to the Android project: mail.jar, activation.jar, and additional.jar. Additionally, network permission must be declared in AndroidManifest.xml: <uses-permission android:name="android.permission.INTERNET" />.

Modern Security Requirements

With updates to Gmail's security policies, traditional "Less Secure Apps" access has been deprecated. Two-factor authentication and app-specific passwords are now required. Users need to enable two-factor verification in their Google account settings and generate app-specific passwords for authentication.

Performance Optimization Recommendations

In production environments, it's recommended to encapsulate email sending logic within IntentService or WorkManager to ensure network operations execute in the background and avoid ANR (Application Not Responding) errors. Appropriate error handling and retry mechanisms should also be implemented.

Conclusion

Direct email sending in Android applications using JavaMail API represents an effective technical solution that provides superior user experience and application integration. While configuration is relatively complex, proper implementation enables powerful email functionality within applications. Developers must pay particular attention to modern security requirements and best practices for network operations.