How to attach a file to an email on android (using intent and C#)?

Ok, finally got it working. It took me this whole week (and a lot of research in Unity Answers and Stack Overflow), mainly because I had never programmed anything for android devices. There are a couple steps to do, and it can be a bit messy if you know nothing about android (as I did) but it is not as hard as it seems. The steps I followed are:

1. Copy the file in the StreamingAssets folder.

2. Get the reference to the android activity and call the method.

3. Copy the file to external storage.

4. Create the intent and start the activity.

I'll explain those steps right now and try to tell why they should be done. Just note that my unity player is integrated in the android app (thus all these steps, except the first one, are required).

Step 1: Copy the file in the StreamingAssets folder (skippable).

In my case, I had to attach a png file to the email, and although the docs doesn't give a long explanation of how it works, If you need to pass any file without converting it to an asset or a bundle, the StreamingAssets folder is the way to do it. Why? Because it creates a copy of the file in the assets folder of the android app once you export the unity player (just open Eclipse and your file will be there).

Note: I did this because I needed to pass an already created file. If you are generating the file by code you can skip this step.

Step 2: Get the reference to the activity and call the method.

When you build your unity player and check the Google Android Project option, Unity creates an activity called UnityPlayerNativeActivity, which will be the main activity of the app. To communicate with that activity, you need a reference to the AndroidJavaClass and AndroidJavaObject to call its methods (as you can check in many places, just google it). The code to do that goes inside the unity player (in any object) and is very easy (I use it in a function that gets called when I click on a "send mail" button created with NGUI):

 AndroidJavaClass jc = new AndroidJavaClass("com.exampleCompany.exampleApp.UnityPlayerNativeActivity");
 AndroidJavaObject jo = jc.GetStatic<AndroidJavaObject>("context");
 jo.Call("sendMail", new object[] { mailTo, mailSubject, mailBody, mailAttachmentPath });

That's all the code you need inside unity (the rest goes inside the UnityPlayerNativeActivity activity code). context is a variable that will hold a reference to the context of the activity. sendMail is the name of the function that will create the intent and mailTo, mailSubject, mailBody and mailAttachment are strings that hold the parameters of the function (mailAttachment is the name of the object "image.png").

Now we jump to Eclipse. Inside your UnityPlayerNativeActivity.java you will need all those things, so te class should include the context:

 public class UnityPlayerNativeActivity extends Activity {
    protected UnityPlayer mUnityPlayer;        // don't change the name of this variable; referenced from native code
    // Other variables

    // You need the static reference to this object:
    public static Context context;
 
    // UnityPlayer.init() should be called before attaching the view to a layout - it will load the native code.
    // UnityPlayer.quit() should be the last thing called - it will unload the native code.
    protected void onCreate (Bundle savedInstanceState)
    {        
       // Other stuff previous to onCreate

       super.onCreate(savedInstanceState);
       context = this;   // Needs to go after super.OnCreate
 
       // Rest of stuff
       ...         
   }

       // Other functions
 }

This way you have the context ready to be accesed by the androidJavaObject inside Unity. The function sendMail also goes inside this UnityPlayerNativeActivity class, and is explained in the following steps.

Steps 3 and 4. Copy the file to external storage, create the intent and start the activity:

Now we need to add the sendMail function. It will create the intent, copy the file to external storage and attach it to the intent. Finally, it will start the activity.

To attach everything to the email (address, subject and attachment) we need to use the intent.putExtra function. And it is important to use a MIME type that can handle the type of file we want to attach to the email (I used "image/*" since my file is a png).

Why do we have to copy the file to the external storage? Because android apps can't access files from other apps unless they are stored in external storage or shared by a content provider. Since my experiments with the content provider and file provider got me nowhere, I decided that external storage was the way to go.

To attach the file to the mail, you need the Uri that can be obtained from the external storage file through Uri.fromFile function.

The sendMail function (that goes inside UnityPlayerNativeActivity.java class) should look like this:

 public void sendMail(String address, String subject, String message, String filePath) {
 try {    
       // Create the intent
       final Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
         
         // add the address, subject and body of the mail
         emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL, new String[] { address });
         emailIntent.putExtra(android.content.Intent.EXTRA_SUBJECT, subject);
         emailIntent.putExtra(android.content.Intent.EXTRA_TEXT, message);

         // set the MIME type and grant access to the uri (for the attached file, although I'm not sure if the grant access is required)
         emailIntent.setType("image/*");
         emailIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
         
         // Copy file to external storage
         InputStream in = null;
         OutputStream out = null;
         try {
             in = getAssets().open(filePath);
             out = new FileOutputStream(new File(Environment.getExternalStorageDirectory(), filePath));
             byte buf[] = new byte[1024];
             int len;
             while ((len = in.read(buf)) > 0) {
                 out.write(buf, 0, len);
             }
             in.close();
             in = null;
             out.flush();
             out.close();
             out = null;
         } catch (Exception e) {
             Log.e("", e.getMessage());
         }
          // Get the Uri from the external file and add it to the intent
         Uri uri = Uri.fromFile(new File(Environment.getExternalStorageDirectory(), filePath));
         emailIntent.putExtra(Intent.EXTRA_STREAM, uri);

          // finally start the activity
         this.startActivity(Intent.createChooser(emailIntent, "Sending email..."));        
     } catch (Throwable t) {
         Toast.makeText(this, "Request failed try again: " + t.toString(), Toast.LENGTH_LONG).show();
   }
 }

What does it do? It gathers the parameters from the call function inside the unity player and uses them to attach all that is required to the email intent. Then it streams the file to external storage and gets an uri from it (to add it to the intent). When it starts the activity, an activity chooser launches, showing apps that can handle images and email. If the user chooses an email app, the email will show with all its fields completed and the image file attached.

And that's pretty much it.

 Environment.getExternalStorageDirectory()