How to send emails from my Android application?

Question

I am developing an application in Android. I don't know how to send an email from the application?

Toffic

Simple ShareBuilder gist.github.com/gelldur/9c199654c91b13478979 – Balanchine

Does this answer your question? Android Studio mailto Intent doesn't show subject and mail body – Ambrosius

The suggested duplicate seems worse, the accepted answer has a bizarre, unnecessary intent-filter. – Sandfly

Answer 1

The best (and easiest) way is to use an Intent:

Intent i = new Intent(Intent.ACTION_SEND);
i.setType("message/rfc822");
i.putExtra(Intent.EXTRA_EMAIL  , new String[]{"[email protected]"});
i.putExtra(Intent.EXTRA_SUBJECT, "subject of email");
i.putExtra(Intent.EXTRA_TEXT   , "body of email");
try {
    startActivity(Intent.createChooser(i, "Send mail..."));
} catch (android.content.ActivityNotFoundException ex) {
    Toast.makeText(MyActivity.this, "There are no email clients installed.", Toast.LENGTH_SHORT).show();
}

Otherwise you'll have to write your own client.

RFC822 is the standard for ARPA Internet Text Messages. See https://w3.org/Protocols/rfc822.

Wretch

In the above code,there is no sender email id.Then how the message send? – Nonillion

KIRAN: You'll need to look into how Intents work to understand this. It'll basically open an email application with the recipient, subject, and body already filled out. It's up to the email app to do the sending. – Wretch

The email is not appearing in "TO" field by starting the activity. anyone knows? – Septima

Its also showing bluetooth to complete the action.How this can be done only by mail? I don't need bluetooth option. – Envoi

Yeah... this worked perfect, until Skype also decided to "support" message/rfc822 - now Skype pops-up in list also. That company is truly becoming evil... – Bollinger

You can't "force" it to be an email app unless you know exactly which app the user would want to use. – Wretch

Although forcing it to be a specific email app is not possible in general, you can limit the chooser to only display email apps. See this alternative answer. Worked beautifully for me. – Oney

I just have a question on this one of how to listen back if email sending fails do we have to use intent filters for that ? – Blub

One phone I tested this on suggested sending the email using "Bluetooth" and "Android Beam". The ACTION_SENDTO approach doesn't seem to have this problem. – Traci

add these to be sure that chooser displays only email apps: Intent i = new Intent(Intent.ACTION_SENDTO); i.setType("message/rfc822"); i.setData(Uri.parse("mailto:")); – Judaist

From the official Android docs: "An example of when not to use it [Intent.createChooser] is when the user clicks on a "mailto:" link. They would naturally expect to go directly to their mail app, so startActivity() should be called directly: it will either launch the current preferred app, or put up a dialog allowing the user to pick an app to use and optionally marking that as preferred." – Leora

How do I listen to successfully or failed email? – Zounds

@Ozuf You can't unless the desire email app suports some kind of callbacks (via intents for example). AFAIK Gmail has no such tools. – Aristocrat

@JeremyLogan using this but stil getting image in junk folder. how to get in inbox ? – Treponema

Is it possible to also put sender email as extra? I cannot find it anywhere – Incipit

Hello all can i send mail on backend without passing intent? – Tramway

It is also showing whatsapp like apps for sending email – Fred

this is the best solution if you want to see only mail apps (not whatsapp etc) https://mcmap.net/q/52867/-send-email-intent/… – Kristikristian

Answer 2

Use .setType("message/rfc822") or the chooser will show you all of the (many) applications that support the send intent.

Luting

Nice, this should have more up votes tbh. You won't notice testing on the emulator, but when you go to send "text/plain" on a real device it will give you a list of 15+ apps!! so "message/rfc822" is definitely recommended (the email standard). – Phonotypy

@Phonotypy hi, but I didn't see any difference after changing to message/rfc822 – Wideangle

Can you remove bluetooth from the list? This also shows up with this type. +1 though, neat trick! – Pattipattie

Saved our bacon. Can't imagine explaining to client that the user might tweet support requests instead of emailing them. – Spellbinder

Is there a constant for this type somewhere? – Thermotensile

+1111111 This deserves endless +1's so others can see this. I missed this portion and had to deal with this problem for a while! – Reciprocal

Is this still relevant for the latest Android APIs? – Overline

Answer 3

I've been using this since long time ago and it seems good, no non-email apps showing up. Just another way to send a send email intent:

Intent intent = new Intent(Intent.ACTION_SENDTO); // it's not ACTION_SEND
intent.putExtra(Intent.EXTRA_SUBJECT, "Subject of email");
intent.putExtra(Intent.EXTRA_TEXT, "Body of email");
intent.setData(Uri.parse("mailto:[email protected]")); // or just "mailto:" for blank
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); // this will make such that when user returns to your app, your app is displayed, instead of the email app.
startActivity(intent);

Emeraldemerge

Unsopported action: This action is not currently supported – Oreopithecus

I get an error: ActivityNotFoundException: No Activity found to handle Intent { act=android.intent.action.SENDTO typ=plain/text flg=0x10000000 } – Abdul

lgor G->plz change from setType"(plain/text") to setType("text/plain") – Physique

.setType("message/rfc822") not text/plain – Rattlebrain

this code willl open email intent ? how can i send email without showing intent to user @yuku i want to send password to email – Treponema

@erdomester, I've seen this happen on an Android 4.1.1 emulator when the default email client isn't configured with an email account. Maybe this just means no matching activities were found. – Traci

@erdomester, interestingly, this doesn't happen if you use the setType approach instead of this one. – Traci

@erdomester, further testing suggests this is just a problem with the official Android emulators. – Traci

Wrong. I never test on emulators, cause I use real phones. Also, emulators make my notebook extremely slow (but eclipse or studio both make it very slow) even if I have 8GB RAM, 4 processors and the notebook is in perfect condition. – Oreopithecus

@erdomester, on what device did the problem happen for you? I haven't been able to produce it on any real devices. – Traci

The reason you are getting the "No app can perform this action" is because you did not add setData to your intent. Add that, and leave the "mailto:" without an email address to resolve. Text/Play type is better because it filters out unnecessary email clients. – Zeba

Thank you! This is the only solution worked for me. All others didn't work on devices without sd card – Precast

This answer is quite influential. :) – Ballarat

You call setData() after setType() here. It has no sense as calling setData() will erase any type set before. So, just remove setType() and it will work the same. – Cooker

@Cooker wow, thanks for this updated information! I will remove the setType from the answer. Ref from Android docs: > Set the data this intent is operating on. This method automatically clears any type that was previously set by setType(String) – Whitted

this should be the accepted answer – Pavel

Answer 4

I was using something along the lines of the currently accepted answer in order to send emails with an attached binary error log file. GMail and K-9 send it just fine and it also arrives fine on my mail server. The only problem was my mail client of choice Thunderbird which had troubles with opening / saving the attached log file. In fact it simply didn't save the file at all without complaining.

I took a look at one of these mail's source codes and noticed that the log file attachment had (understandably) the mime type message/rfc822. Of course that attachment is not an attached email. But Thunderbird cannot cope with that tiny error gracefully. So that was kind of a bummer.

After a bit of research and experimenting I came up with the following solution:

public Intent createEmailOnlyChooserIntent(Intent source,
    CharSequence chooserTitle) {
    Stack<Intent> intents = new Stack<Intent>();
    Intent i = new Intent(Intent.ACTION_SENDTO, Uri.fromParts("mailto",
            "[email protected]", null));
    List<ResolveInfo> activities = getPackageManager()
            .queryIntentActivities(i, 0);

    for(ResolveInfo ri : activities) {
        Intent target = new Intent(source);
        target.setPackage(ri.activityInfo.packageName);
        intents.add(target);
    }

    if(!intents.isEmpty()) {
        Intent chooserIntent = Intent.createChooser(intents.remove(0),
                chooserTitle);
        chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS,
                intents.toArray(new Parcelable[intents.size()]));

        return chooserIntent;
    } else {
        return Intent.createChooser(source, chooserTitle);
    }
}

It can be used as follows:

Intent i = new Intent(Intent.ACTION_SEND);
i.setType("*/*");
i.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(crashLogFile));
i.putExtra(Intent.EXTRA_EMAIL, new String[] {
    ANDROID_SUPPORT_EMAIL
});
i.putExtra(Intent.EXTRA_SUBJECT, "Crash report");
i.putExtra(Intent.EXTRA_TEXT, "Some crash report details");

startActivity(createEmailOnlyChooserIntent(i, "Send via email"));

As you can see, the createEmailOnlyChooserIntent method can be easily fed with the correct intent and the correct mime type.

It then goes through the list of available activities that respond to an ACTION_SENDTO mailto protocol intent (which are email apps only) and constructs a chooser based on that list of activities and the original ACTION_SEND intent with the correct mime type.

Another advantage is that Skype is not listed anymore (which happens to respond to the rfc822 mime type).

Food

i just inserted you code snippet and it works fine. Before there have been listed apps like Google Drive, Skype etc. But isn't there a way to send a mail out of the application without calling another application? i just read the article about the email client that @Rene postet above but seems to be too complicated for just sending a simple email – Gem

Excellent answer. I had Skype and Google Drive coming up with ACTION_SEND as well and this sorts it out beautifully. – Oney

The most popular solution above returns Skype and Vkontakte as well. This solution is better. – Woodcut

what is crashLogFile ?where did it initialise?pease sepecify – Kingbolt

@Kingbolt This is just some remainder from my own code base. It's a File instance pointing to a crash log file my Android apps create in the background in case there was an uncaught exception. That example should just illustrate how to add an email attachment. You could also attach any other file from the external storage (an image for example). You can also remove that line with crashLogFile in order to get a working example. – Food

Works for me as well. The accepted answer was including options like Skype and Google Drive which carry some problems: the problem with the Skype option was that you'd get a 'You can only send files stored on your device.' message when trying to send the file; with Google Drive it would use the EXTRA_SUBJECT as the default file name instead of the actual file's name. – Oconnell

Creative and works well to filter out undesirable apps. Needs more upvotes! – Agreeable

Answer 5

To JUST LET EMAIL APPS to resolve your intent you need to specify ACTION_SENDTO as Action and mailto as Data.

private void sendEmail(){

    Intent emailIntent = new Intent(Intent.ACTION_SENDTO);
    emailIntent.setData(Uri.parse("mailto:" + "[email protected]")); // You can use "mailto:" if you don't know the address beforehand.
    emailIntent.putExtra(Intent.EXTRA_SUBJECT, "My email's subject");
    emailIntent.putExtra(Intent.EXTRA_TEXT, "My email's body");
    
    try {
        startActivity(Intent.createChooser(emailIntent, "Send email using..."));
    } catch (android.content.ActivityNotFoundException ex) {
        Toast.makeText(Activity.this, "No email clients installed.", Toast.LENGTH_SHORT).show();
    }

}

Indite

Answer 6

The solution to this is simple: the android documentation explains it.

(https://developer.android.com/guide/components/intents-common.html#Email)

The most important is the flag: it is ACTION_SENDTO, and not ACTION_SEND

The other important line is

intent.setData(Uri.parse("mailto:")); ***// only email apps should handle this***

By the way, if you send an empty Extra, the if() at the end won't work and the app won't launch the email client.

According to Android documentation. If you want to ensure that your intent is handled only by an email app (and not other text messaging or social apps), then use the ACTION_SENDTO action and include the "mailto:" data scheme. For example:

public void composeEmail(String[] addresses, String subject) {
    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setData(Uri.parse("mailto:")); // only email apps should handle this
    intent.putExtra(Intent.EXTRA_EMAIL, addresses);
    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Averell

Answer 7

The strategy of using .setType("message/rfc822") or ACTION_SEND seems to also match apps that aren't email clients, such as Android Beam and Bluetooth.

Using ACTION_SENDTO and a mailto: URI seems to work perfectly, and is recommended in the developer documentation. However, if you do this on the official emulators and there aren't any email accounts set up (or there aren't any mail clients), you get the following error:

Unsupported action

That action is not currently supported.

As shown below:

It turns out that the emulators resolve the intent to an activity called com.android.fallback.Fallback, which displays the above message. Apparently this is by design.

If you want your app to circumvent this so it also works correctly on the official emulators, you can check for it before trying to send the email:

private void sendEmail() {
    Intent intent = new Intent(Intent.ACTION_SENDTO)
        .setData(new Uri.Builder().scheme("mailto").build())
        .putExtra(Intent.EXTRA_EMAIL, new String[]{ "John Smith <[email protected]>" })
        .putExtra(Intent.EXTRA_SUBJECT, "Email subject")
        .putExtra(Intent.EXTRA_TEXT, "Email body")
    ;

    ComponentName emailApp = intent.resolveActivity(getPackageManager());
    ComponentName unsupportedAction = ComponentName.unflattenFromString("com.android.fallback/.Fallback");
    if (emailApp != null && !emailApp.equals(unsupportedAction))
        try {
            // Needed to customise the chooser dialog title since it might default to "Share with"
            // Note that the chooser will still be skipped if only one app is matched
            Intent chooser = Intent.createChooser(intent, "Send email with");
            startActivity(chooser);
            return;
        }
        catch (ActivityNotFoundException ignored) {
        }

    Toast
        .makeText(this, "Couldn't find an email app and account", Toast.LENGTH_LONG)
        .show();
}

Find more info in the developer documentation.

Traci

Answer 8

Sending email can be done with Intents which will require no configuration. But then it will require user interaction and the layout will be a bit restricted.

Build and sending a more complex email without user interaction entails building your own client. The first thing is that the Sun Java API for email are unavailable. I have had success leveraging the Apache Mime4j library to build email. All based on the docs at nilvec.

Deloisedelong

Answer 9

Here is the sample working code which opens mail application in android device and auto-filled with To address and Subject in the composing mail.

protected void sendEmail() {
    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setData(Uri.parse("mailto:[email protected]"));
    intent.putExtra(Intent.EXTRA_SUBJECT, "Feedback");
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Everara

Thanks. Comparing with a solution of @Avi Parshan, you set an email in setData(), and Avi sets in putExtra(). Both variants a working. But if remove setData and use only intent.putExtra(Intent.EXTRA_EMAIL, new String[]{"[email protected]"});, there would be a ActivityNotFoundException. – Hirudin

Answer 10

I use the below code in my apps. This shows exactly email client apps, such as Gmail.

    Intent contactIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts("mailto", getString(R.string.email_to), null));
    contactIntent.putExtra(Intent.EXTRA_SUBJECT, getString(R.string.email_subject));
    startActivity(Intent.createChooser(contactIntent, getString(R.string.email_chooser)));

Platyhelminth

Answer 11

This will show you only the email clients (as well as PayPal for some unknown reason)

 public void composeEmail() {

    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setData(Uri.parse("mailto:"));
    intent.putExtra(Intent.EXTRA_EMAIL, new String[]{"[email protected]"});
    intent.putExtra(Intent.EXTRA_SUBJECT, "Subject");
    intent.putExtra(Intent.EXTRA_TEXT, "Body");
    try {
        startActivity(Intent.createChooser(intent, "Send mail..."));
    } catch (android.content.ActivityNotFoundException ex) {
        Toast.makeText(MainActivity.this, "There are no email clients installed.", Toast.LENGTH_SHORT).show();
    }
}

Hepler

Nice solution! It avoids many unsuitable applications (mostly used as "Share"). Don't add intent.type = "message/rfc822"; intent.type = "text/html"; here as it will lead to exception. – Hirudin

Answer 12

This is how I did it. Nice and simple.

String emailUrl = "mailto:[email protected]?subject=Subject Text&body=Body Text";
        Intent request = new Intent(Intent.ACTION_VIEW);
        request.setData(Uri.parse(emailUrl));
        startActivity(request);

Respiration

Answer 13

I used this code to send mail by launching default mail app compose section directly.

    Intent i = new Intent(Intent.ACTION_SENDTO);
    i.setType("message/rfc822"); 
    i.setData(Uri.parse("mailto:"));
    i.putExtra(Intent.EXTRA_EMAIL  , new String[]{"[email protected]"});
    i.putExtra(Intent.EXTRA_SUBJECT, "Subject");
    i.putExtra(Intent.EXTRA_TEXT   , "body of email");
    try {
        startActivity(Intent.createChooser(i, "Send mail..."));
    } catch (android.content.ActivityNotFoundException ex) {
        Toast.makeText(this, "There are no email clients installed.", Toast.LENGTH_SHORT).show();
    }

Seafood

Answer 14

This function first direct intent gmail for sending email, if gmail is not found then promote intent chooser. I used this function in many commercial app and it's working fine. Hope it will help you:

public static void sentEmail(Context mContext, String[] addresses, String subject, String body) {

    try {
        Intent sendIntentGmail = new Intent(Intent.ACTION_VIEW);
        sendIntentGmail.setType("plain/text");
        sendIntentGmail.setData(Uri.parse(TextUtils.join(",", addresses)));
        sendIntentGmail.setClassName("com.google.android.gm", "com.google.android.gm.ComposeActivityGmail");
        sendIntentGmail.putExtra(Intent.EXTRA_EMAIL, addresses);
        if (subject != null) sendIntentGmail.putExtra(Intent.EXTRA_SUBJECT, subject);
        if (body != null) sendIntentGmail.putExtra(Intent.EXTRA_TEXT, body);
        mContext.startActivity(sendIntentGmail);
    } catch (Exception e) {
        //When Gmail App is not installed or disable
        Intent sendIntentIfGmailFail = new Intent(Intent.ACTION_SEND);
        sendIntentIfGmailFail.setType("*/*");
        sendIntentIfGmailFail.putExtra(Intent.EXTRA_EMAIL, addresses);
        if (subject != null) sendIntentIfGmailFail.putExtra(Intent.EXTRA_SUBJECT, subject);
        if (body != null) sendIntentIfGmailFail.putExtra(Intent.EXTRA_TEXT, body);
        if (sendIntentIfGmailFail.resolveActivity(mContext.getPackageManager()) != null) {
            mContext.startActivity(sendIntentIfGmailFail);
        }
    }
}

Astatine

Thanks a lot. Save my life – Trend

Answer 15

This is the most clean way of sending email on Android.

 val intent = Intent(Intent.ACTION_SENDTO).apply {
    data = Uri.parse("mailto:")
    putExtra(Intent.EXTRA_EMAIL, arrayOf("[email protected]"))
    putExtra(Intent.EXTRA_SUBJECT, "Subject")
    putExtra(Intent.EXTRA_TEXT, "Email body")
}
if (intent.resolveActivity(packageManager) != null) {
    startActivity(intent)
}

You also need to specify in your manifest (outside your application tag) the query for applications that handle email (mailto)

<queries>
    <intent>
        <action android:name="android.intent.action.SENDTO" />
        <data android:scheme="mailto" />
    </intent>
</queries>

If you need to send HTML text in the email body, please replace the "Email body" with your email string, something like this (please beware that Html.fromHtml maybe deprecated this was only for show you how to do it)

Html.fromHtml(
    StringBuilder().append("<b>Hello world</b>").toString()
)

Hindsight

Answer 16

simple try this one

 public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    buttonSend = (Button) findViewById(R.id.buttonSend);
    textTo = (EditText) findViewById(R.id.editTextTo);
    textSubject = (EditText) findViewById(R.id.editTextSubject);
    textMessage = (EditText) findViewById(R.id.editTextMessage);

    buttonSend.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {

            String to = textTo.getText().toString();
            String subject = textSubject.getText().toString();
            String message = textMessage.getText().toString();

            Intent email = new Intent(Intent.ACTION_SEND);
            email.putExtra(Intent.EXTRA_EMAIL, new String[] { to });
            // email.putExtra(Intent.EXTRA_CC, new String[]{ to});
            // email.putExtra(Intent.EXTRA_BCC, new String[]{to});
            email.putExtra(Intent.EXTRA_SUBJECT, subject);
            email.putExtra(Intent.EXTRA_TEXT, message);

            // need this to prompts email client only
            email.setType("message/rfc822");

            startActivity(Intent.createChooser(email, "Choose an Email client :"));

        }
    });
}

Racketeer

How is this any better than the answers that already existed when you posted this? It just looks like a copy of the accepted answer wrapped in an activity. – Traci

Answer 17

Other solution can be

Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
emailIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
emailIntent.setType("plain/text");
emailIntent.setClassName("com.google.android.gm", "com.google.android.gm.ComposeActivityGmail");
emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL, new String[]{"[email protected]"});
emailIntent.putExtra(android.content.Intent.EXTRA_SUBJECT, "Yo");
emailIntent.putExtra(android.content.Intent.EXTRA_TEXT, "Hi");
startActivity(emailIntent);

Assuming most of the android device has GMail app already installed.

Deanedeaner

@PedroVarela we can always check activity not found exception. – Deanedeaner

Yes we can. But your solution is no the right one. The Android documentation states clearly what you have to do in order to show only mail apps in the intent chooser. You wrote "Assuming most of the android device has Gmail app already installed"; What if it is a rooted device and the user delete Gmail client?. Suppose you are creating your own email app?, if a user is going to send a e-mail your app won't be in that list. What happen if gmail change the package name? Are you going to update your app? – Averell

Answer 18

Use this for send email...

boolean success = EmailIntentBuilder.from(activity)
    .to("[email protected]")
    .cc("[email protected]")
    .subject("Error report")
    .body(buildErrorReport())
    .start();

use build gradle :

compile 'de.cketti.mailto:email-intent-builder:1.0.0'

Neutralization

Answer 19

 Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts(
            "mailto","[email protected]", null));
    emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Forgot Password");
    emailIntent.putExtra(Intent.EXTRA_TEXT, "this is a text ");
    startActivity(Intent.createChooser(emailIntent, "Send email..."));

Procarp

Answer 20

This method work for me. It open Gmail app (if installed) and set mailto.

public void openGmail(Activity activity) {
    Intent emailIntent = new Intent(Intent.ACTION_VIEW);
    emailIntent.setType("text/plain");
    emailIntent.setType("message/rfc822");
    emailIntent.setData(Uri.parse("mailto:"+activity.getString(R.string.mail_to)));
    emailIntent.putExtra(Intent.EXTRA_SUBJECT, activity.getString(R.string.app_name) + " - info ");
    final PackageManager pm = activity.getPackageManager();
    final List<ResolveInfo> matches = pm.queryIntentActivities(emailIntent, 0);
    ResolveInfo best = null;
    for (final ResolveInfo info : matches)
        if (info.activityInfo.packageName.endsWith(".gm") || info.activityInfo.name.toLowerCase().contains("gmail"))
            best = info;
    if (best != null)
        emailIntent.setClassName(best.activityInfo.packageName, best.activityInfo.name);
    activity.startActivity(emailIntent);
}

Hawsehole

Answer 21

/**
 * Will start the chosen Email app
 *
 * @param context    current component context.
 * @param emails     Emails you would like to send to.
 * @param subject    The subject that will be used in the Email app.
 * @param forceGmail True - if you want to open Gmail app, False otherwise. If the Gmail
 *                   app is not installed on this device a chooser will be shown.
 */
public static void sendEmail(Context context, String[] emails, String subject, boolean forceGmail) {

    Intent i = new Intent(Intent.ACTION_SENDTO);
    i.setData(Uri.parse("mailto:"));
    i.putExtra(Intent.EXTRA_EMAIL, emails);
    i.putExtra(Intent.EXTRA_SUBJECT, subject);
    if (forceGmail && isPackageInstalled(context, "com.google.android.gm")) {
        i.setPackage("com.google.android.gm");
        i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(i);
    } else {
        try {
            context.startActivity(Intent.createChooser(i, "Send mail..."));
        } catch (ActivityNotFoundException e) {
            Toast.makeText(context, "No email app is installed on your device...", Toast.LENGTH_SHORT).show();
        }
    }
}

/**
 * Check if the given app is installed on this devuice.
 *
 * @param context     current component context.
 * @param packageName The package name you would like to check.
 * @return True if this package exist, otherwise False.
 */
public static boolean isPackageInstalled(@NonNull Context context, @NonNull String packageName) {
    PackageManager pm = context.getPackageManager();
    if (pm != null) {
        try {
            pm.getPackageInfo(packageName, 0);
            return true;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
    return false;
}

Kerstin

Answer 22

Try this:

String mailto = "mailto:[email protected]" +
    "?cc=" + "[email protected]" +
    "&subject=" + Uri.encode(subject) +
    "&body=" + Uri.encode(bodyText);

Intent emailIntent = new Intent(Intent.ACTION_SENDTO);
emailIntent.setData(Uri.parse(mailto));

try {
    startActivity(emailIntent);
} catch (ActivityNotFoundException e) {
    //TODO: Handle case where no email app is available
}

The above code will open the users favourite email client prefilled with the email ready to send.

Source

Flowery

Answer 23

Kotlin version which only shows Email clients (no contacts etc.):

    with(Intent(Intent.ACTION_SEND)) {
        type = "message/rfc822"
        data = Uri.parse("mailto:")
        putExtra(Intent.EXTRA_EMAIL, arrayOf("[email protected]"))
        putExtra(Intent.EXTRA_SUBJECT,"YOUR SUBJECT")
        putExtra(Intent.EXTRA_TEXT, "YOUR BODY")
        try {
            startActivity(Intent.createChooser(this, "Send Email with"))
        } catch (ex: ActivityNotFoundException) {
            // No email clients found, might show Toast here
        }
    }

Salisbury

Answer 24

The code below works on Android 10 devices and higher. It also sets the subject, body and recipient(To).

val uri = Uri.parse("mailto:$EMAIL")
                .buildUpon()
                .appendQueryParameter("subject", "App Feedback")
                .appendQueryParameter("body", "Body Text")
                .appendQueryParameter("to", EMAIL)
                .build()

            val emailIntent = Intent(Intent.ACTION_SENDTO, uri)

            startActivity(Intent.createChooser(emailIntent, "Select app"))

Lewd

Answer 25

Filtering for 'real' E-Mail Apps is still an issue today. As many people mentioned above, other apps nowadays also report to support the mime-type "message/rfc822". Therefore, this mime-type is not suitable any more to filter for a real E-Mail App.

If you want to send a simple text mail, it is enough to use the the ACTION_SENDTO intent action with the appropriate data type like so:

Intent intent = new Intent(Intent.ACTION_SENDTO);
intent.setData(Uri.parse("mailto:"));
intent.putExtra(Intent.EXTRA_EMAIL, recipients);
intent.putExtra(Intent.EXTRA_SUBJECT, subject);
intent.putExtra(Intent.EXTRA_TEXT, text);
Intent chooser = Intent.createChooser(intent, "Send Mail");
context.startActivity(chooser);

This will filter all available apps for those that support the 'mailto' protocol, which is much more suitable for the purpose of sending an E-mail.

But sadly things become complicated, if you want to send a mail with (multiple) attachments. The ACTION_SENDTO action does not support the EXTRA_STREAM extra on the intent. If you want to use that, you must use the ACTION_SEND_MULTIPLE action, which does not work together with the the data type Uri.parse("mailto:").

For now I found a solution, which consists of the following steps:

• Declare that your App wants to query Apps on the device, that support the mailto protocol (important for all Apps since Android 11)
• Actually query all Apps, that support the mailto protocol
• For each supporting App: Build the intent that you actually want to launch, aiming for that single App
• Build the App chooser and launch it

And this is how it looks in code:

Add this to the AndroidManifest:

<queries>
    <intent>
        <action android:name="android.intent.action.SENDTO" />
        <data android:scheme="mailto" />
    </intent>
</queries>

This is the Java code:

/* Query all Apps that support the 'mailto' protocol */
PackageManager pm = context.getPackageManager();
Intent emailCheckerIntent = new Intent(Intent.ACTION_SENDTO, Uri.parse("mailto:"));
List<ResolveInfo> emailApps = pm.queryIntentActivities(emailCheckerIntent, PackageManager.MATCH_DEFAULT_ONLY);

/* For each supporting App: Build an intent with the desired values */
List<Intent> intentList = new ArrayList<>();
for (ResolveInfo resolveInfo : emailApps) {
    String packageName = resolveInfo.activityInfo.packageName;
    Intent intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
    intent.setPackage(packageName);
    intent.setComponent(new ComponentName(packageName, resolveInfo.activityInfo.name));
    intent.putExtra(Intent.EXTRA_EMAIL, recipients);
    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
    intent.putExtra(Intent.EXTRA_TEXT, text);
    intent.putExtra(Intent.EXTRA_STREAM, attachmentUris);
    intent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); //IMPORTANT to give the E-Mail App access to your attached files
                
    intentList.add(intent);
}

/* Create a chooser consisting of the queried apps only */
Intent chooser = Intent.createChooser(intentList.remove(intentList.size() - 1), "Send Mail");
Intent[] extraIntents = intentList.toArray(new Intent[0]);
chooser.putExtra(Intent.EXTRA_INITIAL_INTENTS, extraIntents);
context.startActivity(chooser);

Note: If the itentList only has one item, Android will automatically skip the chooser and run the only App automatically.

Boob

Answer 26

import androidx.core.app.ShareCompat
import androidx.core.content.IntentCompat

ShareCompat.IntentBuilder(this)
                .setType("message/rfc822")
                .setEmailTo(arrayOf(email))
                .setStream(uri)
                .setSubject(subject)
                .setText(message + emailMessage)
                .startChooser()

Truman