@capawesome/capacitor-mail-composer 0.0.1

package/CapawesomeCapacitorMailComposer.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapawesomeCapacitorMailComposer'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robin Genz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapawesomeCapacitorMailComposer",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CapawesomeCapacitorMailComposer",
+            targets: ["MailComposerPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
+    ],
+    targets: [
+        .target(
+            name: "MailComposerPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Plugin"),
+        .testTarget(
+            name: "MailComposerPluginTests",
+            dependencies: ["MailComposerPlugin"],
+            path: "ios/PluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,208 @@
+# @capawesome/capacitor-mail-composer
+
+Capacitor plugin to open the native email composer.
+
+<div class="capawesome-z29o10a">
+  <a href="https://cloud.capawesome.io/" target="_blank">
+    <img alt="Deliver Live Updates to your Capacitor app with Capawesome Cloud" src="https://cloud.capawesome.io/assets/banners/cloud-build-and-deploy-capacitor-apps.png?t=1" />
+  </a>
+</div>
+
+## Features
+
+- ✉️ **Compose**: Open the native email composer prefilled with recipients, subject and body.
+- 📎 **Attachments**: Attach one or more files to the email.
+- ✅ **Availability**: Check whether the device is able to compose and send emails.
+- 🌐 **Cross-platform**: Supports Android, iOS and the web (via `mailto:`).
+- 📦 **CocoaPods & SPM**: Supports CocoaPods and Swift Package Manager for iOS.
+- 🔁 **Up-to-date**: Always supports the latest Capacitor version.
+
+Missing a feature? Just [open an issue](https://github.com/capawesome-team/capacitor-plugins/issues) and we'll take a look!
+
+## Newsletter
+
+Stay up to date with the latest news and updates about the Capawesome, Capacitor, and Ionic ecosystem by subscribing to our [Capawesome Newsletter](https://cloud.capawesome.io/newsletter/).
+
+## Compatibility
+
+| Plugin Version | Capacitor Version | Status         |
+| -------------- | ----------------- | -------------- |
+| 0.x.x          | >=8.x.x           | Active support |
+
+## Installation
+
+You can use our **AI-Assisted Setup** to install the plugin.
+Add the [Capawesome Skills](https://github.com/capawesome-team/skills) to your AI tool using the following command:
+
+```bash
+npx skills add capawesome-team/skills --skill capacitor-plugins
+```
+
+Then use the following prompt:
+
+```
+ Use the `capacitor-plugins` skill from `capawesome-team/skills` to install the `@capawesome/capacitor-mail-composer` plugin in my project.
+```
+
+If you prefer **Manual Setup**, install the plugin by running the following commands and follow the platform-specific instructions below:
+
+```bash
+npm install @capawesome/capacitor-mail-composer
+npx cap sync
+```
+
+### Android
+
+#### Attachments
+
+To attach files, the plugin uses the [`FileProvider`](https://developer.android.com/reference/androidx/core/content/FileProvider) that Capacitor already registers for your app (authority `${applicationId}.fileprovider`). Make sure that the directories your attachments are stored in are covered by the `res/xml/file_paths.xml` resource of your app. Otherwise, the `composeMail(...)` method will reject with an error.
+
+### Web
+
+On the web, the plugin builds a `mailto:` URL and opens it. This has the following limitations:
+
+- Attachments are **not** supported and cause the `composeMail(...)` method to reject.
+- HTML bodies are **not** supported. The body is always sent as plain text.
+- The overall URL length is limited, so long bodies may be truncated.
+
+## Configuration
+
+No configuration required for this plugin.
+
+## Usage
+
+```typescript
+import { MailComposer } from '@capawesome/capacitor-mail-composer';
+
+const canComposeMail = async () => {
+  const { canCompose } = await MailComposer.canComposeMail();
+  return canCompose;
+};
+
+const composeMail = async () => {
+  const { status } = await MailComposer.composeMail({
+    to: ['jane@example.com'],
+    cc: ['john@example.com'],
+    subject: 'Hello World',
+    body: 'This is the body of the email.',
+  });
+  return status;
+};
+```
+
+## API
+
+<docgen-index>
+
+* [`canComposeMail()`](#cancomposemail)
+* [`composeMail(...)`](#composemail)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### canComposeMail()
+
+```typescript
+canComposeMail() => Promise<CanComposeMailResult>
+```
+
+Check whether the device is able to compose and send emails.
+
+On iOS, this returns `true` only if a mail account is configured. On
+Android, this returns `true` if a mail app is installed. On the web, this
+always returns `true` (best effort, not verifiable).
+
+**Returns:** <code>Promise&lt;<a href="#cancomposemailresult">CanComposeMailResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### composeMail(...)
+
+```typescript
+composeMail(options: ComposeMailOptions) => Promise<ComposeMailResult>
+```
+
+Open the native email composer prefilled with the provided data.
+
+The user reviews the email and decides whether to send it. The plugin
+never sends the email itself.
+
+| Param         | Type                                                              |
+| ------------- | ----------------------------------------------------------------- |
+| **`options`** | <code><a href="#composemailoptions">ComposeMailOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#composemailresult">ComposeMailResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### CanComposeMailResult
+
+| Prop             | Type                 | Description                                            | Since |
+| ---------------- | -------------------- | ------------------------------------------------------ | ----- |
+| **`canCompose`** | <code>boolean</code> | Whether the device is able to compose and send emails. | 0.1.0 |
+
+
+#### ComposeMailResult
+
+| Prop         | Type                                                            | Description                                                                                                                                                | Since |
+| ------------ | --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`status`** | <code><a href="#mailcomposestatus">MailComposeStatus</a></code> | The status of the email compose operation. **Note**: On Android, the status is always `unknown` because the mail intent does not return a reliable result. | 0.1.0 |
+
+
+#### ComposeMailOptions
+
+| Prop              | Type                  | Description                                                                                                                                                                                         | Default            | Since |
+| ----------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- |
+| **`attachments`** | <code>string[]</code> | The absolute file paths or `file://` URIs of the files to attach. Attachments are not supported on the web.                                                                                         |                    | 0.1.0 |
+| **`bcc`**         | <code>string[]</code> | The email addresses of the blind carbon copy (BCC) recipients.                                                                                                                                      |                    | 0.1.0 |
+| **`body`**        | <code>string</code>   | The body of the email.                                                                                                                                                                              |                    | 0.1.0 |
+| **`cc`**          | <code>string[]</code> | The email addresses of the carbon copy (CC) recipients.                                                                                                                                             |                    | 0.1.0 |
+| **`isHtml`**      | <code>boolean</code>  | Whether the body should be interpreted as HTML. **Note**: On Android, HTML is best-effort as many mail apps ignore it. On the web, HTML is not supported and the body is always sent as plain text. | <code>false</code> | 0.1.0 |
+| **`subject`**     | <code>string</code>   | The subject of the email.                                                                                                                                                                           |                    | 0.1.0 |
+| **`to`**          | <code>string[]</code> | The email addresses of the primary recipients.                                                                                                                                                      |                    | 0.1.0 |
+
+
+### Type Aliases
+
+
+#### MailComposeStatus
+
+The status of an email compose operation.
+
+- `sent`: The email was sent.
+- `saved`: The email was saved as a draft.
+- `canceled`: The user canceled the operation.
+- `unknown`: The status is unknown.
+
+<code>'sent' | 'saved' | 'canceled' | 'unknown'</code>
+
+</docgen-api>
+
+## Platform Support
+
+Keep the following platform-specific behavior in mind:
+
+- **Status**: On Android, the `status` returned by `composeMail(...)` is always `unknown` because the mail intent does not return a reliable result. On iOS, the real status is returned via the delegate. On the web, the status is always `unknown`.
+- **HTML body**: On Android, the `isHtml` option is best-effort because many mail apps ignore HTML content. On the web, HTML is not supported at all.
+- **No mail account**: On iOS, `composeMail(...)` rejects as unavailable if no mail account is configured. Use `canComposeMail(...)` to check upfront.
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/mail-composer/CHANGELOG.md).
+
+## License
+
+See [LICENSE](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/mail-composer/LICENSE).

package/android/build.gradle

@@ -0,0 +1,58 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "io.capawesome.capacitorjs.plugins.mailcomposer"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.SENDTO" />
+            <data android:scheme="mailto" />
+        </intent>
+    </queries>
+</manifest>

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mailcomposer/MailComposer.java

@@ -0,0 +1,120 @@
+package io.capawesome.capacitorjs.plugins.mailcomposer;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.text.Html;
+import androidx.annotation.NonNull;
+import androidx.core.content.FileProvider;
+import io.capawesome.capacitorjs.plugins.mailcomposer.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.mailcomposer.classes.options.ComposeMailOptions;
+import io.capawesome.capacitorjs.plugins.mailcomposer.classes.results.CanComposeMailResult;
+import io.capawesome.capacitorjs.plugins.mailcomposer.interfaces.NonEmptyResultCallback;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MailComposer {
+
+    @NonNull
+    private final MailComposerPlugin plugin;
+
+    public MailComposer(@NonNull MailComposerPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void canComposeMail(@NonNull NonEmptyResultCallback<CanComposeMailResult> callback) {
+        boolean canCompose = canResolveIntent(createMailtoIntent());
+        callback.success(new CanComposeMailResult(canCompose));
+    }
+
+    public boolean canResolveIntent(@NonNull Intent intent) {
+        return intent.resolveActivity(getContext().getPackageManager()) != null;
+    }
+
+    @NonNull
+    public Intent createComposeIntent(@NonNull ComposeMailOptions options) throws Exception {
+        List<Uri> attachmentUris = createAttachmentUris(options.getAttachments());
+        Intent intent;
+        if (attachmentUris.isEmpty()) {
+            intent = createMailtoIntent();
+        } else if (attachmentUris.size() == 1) {
+            intent = new Intent(Intent.ACTION_SEND);
+            intent.setType("message/rfc822");
+            intent.putExtra(Intent.EXTRA_STREAM, attachmentUris.get(0));
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        } else {
+            intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
+            intent.setType("message/rfc822");
+            intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, new ArrayList<>(attachmentUris));
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        }
+        applyRecipients(intent, options);
+        applyContent(intent, options);
+        return intent;
+    }
+
+    private void applyContent(@NonNull Intent intent, @NonNull ComposeMailOptions options) {
+        if (options.getSubject() != null) {
+            intent.putExtra(Intent.EXTRA_SUBJECT, options.getSubject());
+        }
+        String body = options.getBody();
+        if (body != null) {
+            if (options.isHtml()) {
+                intent.putExtra(Intent.EXTRA_TEXT, Html.fromHtml(body, Html.FROM_HTML_MODE_LEGACY).toString());
+                intent.putExtra(Intent.EXTRA_HTML_TEXT, body);
+            } else {
+                intent.putExtra(Intent.EXTRA_TEXT, body);
+            }
+        }
+    }
+
+    private void applyRecipients(@NonNull Intent intent, @NonNull ComposeMailOptions options) {
+        if (!options.getTo().isEmpty()) {
+            intent.putExtra(Intent.EXTRA_EMAIL, options.getTo().toArray(new String[0]));
+        }
+        if (!options.getCc().isEmpty()) {
+            intent.putExtra(Intent.EXTRA_CC, options.getCc().toArray(new String[0]));
+        }
+        if (!options.getBcc().isEmpty()) {
+            intent.putExtra(Intent.EXTRA_BCC, options.getBcc().toArray(new String[0]));
+        }
+    }
+
+    @NonNull
+    private List<Uri> createAttachmentUris(@NonNull List<String> attachments) throws Exception {
+        List<Uri> uris = new ArrayList<>();
+        for (String attachment : attachments) {
+            File file = createFile(attachment);
+            if (!file.exists()) {
+                throw CustomExceptions.ATTACHMENT_NOT_FOUND;
+            }
+            try {
+                String authority = getContext().getPackageName() + ".fileprovider";
+                uris.add(FileProvider.getUriForFile(getContext(), authority, file));
+            } catch (IllegalArgumentException exception) {
+                throw CustomExceptions.ATTACHMENT_NOT_FOUND;
+            }
+        }
+        return uris;
+    }
+
+    @NonNull
+    private File createFile(@NonNull String path) {
+        if (path.startsWith("file://")) {
+            String filePath = Uri.parse(path).getPath();
+            return new File(filePath == null ? path : filePath);
+        }
+        return new File(path);
+    }
+
+    @NonNull
+    private Intent createMailtoIntent() {
+        return new Intent(Intent.ACTION_SENDTO, Uri.parse("mailto:"));
+    }
+
+    @NonNull
+    private Context getContext() {
+        return plugin.getContext();
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mailcomposer/MailComposerPlugin.java

@@ -0,0 +1,101 @@
+package io.capawesome.capacitorjs.plugins.mailcomposer;
+
+import android.content.Intent;
+import androidx.activity.result.ActivityResult;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.Logger;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.ActivityCallback;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import io.capawesome.capacitorjs.plugins.mailcomposer.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.mailcomposer.classes.options.ComposeMailOptions;
+import io.capawesome.capacitorjs.plugins.mailcomposer.classes.results.CanComposeMailResult;
+import io.capawesome.capacitorjs.plugins.mailcomposer.classes.results.ComposeMailResult;
+import io.capawesome.capacitorjs.plugins.mailcomposer.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.mailcomposer.interfaces.Result;
+
+@CapacitorPlugin(name = "MailComposer")
+public class MailComposerPlugin extends Plugin {
+
+    public static final String ERROR_UNKNOWN_ERROR = "An unknown error has occurred.";
+    public static final String TAG = "MailComposerPlugin";
+
+    private MailComposer implementation;
+
+    @Override
+    public void load() {
+        super.load();
+        this.implementation = new MailComposer(this);
+    }
+
+    @PluginMethod
+    public void canComposeMail(PluginCall call) {
+        try {
+            NonEmptyResultCallback<CanComposeMailResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull CanComposeMailResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+            implementation.canComposeMail(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void composeMail(PluginCall call) {
+        try {
+            ComposeMailOptions options = new ComposeMailOptions(call);
+            Intent intent = implementation.createComposeIntent(options);
+            if (implementation.canResolveIntent(intent)) {
+                startActivityForResult(call, intent, "handleComposeMailResult");
+            } else {
+                rejectCallAsUnavailable(call);
+            }
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @ActivityCallback
+    private void handleComposeMailResult(PluginCall call, ActivityResult result) {
+        if (call == null) {
+            return;
+        }
+        resolveCall(call, new ComposeMailResult("unknown"));
+    }
+
+    private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
+        String message = exception.getMessage();
+        if (message == null) {
+            message = ERROR_UNKNOWN_ERROR;
+        }
+        String code = null;
+        if (exception instanceof CustomException) {
+            code = ((CustomException) exception).getCode();
+        }
+        Logger.error(TAG, message, exception);
+        call.reject(message, code);
+    }
+
+    private void rejectCallAsUnavailable(@NonNull PluginCall call) {
+        call.unavailable("This method is not available on this platform.");
+    }
+
+    private void resolveCall(@NonNull PluginCall call, @Nullable Result result) {
+        if (result == null) {
+            call.resolve();
+        } else {
+            call.resolve(result.toJSObject());
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mailcomposer/classes/CustomException.java

@@ -0,0 +1,20 @@
+package io.capawesome.capacitorjs.plugins.mailcomposer.classes;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class CustomException extends Exception {
+
+    @Nullable
+    private final String code;
+
+    public CustomException(@Nullable String code, @NonNull String message) {
+        super(message);
+        this.code = code;
+    }
+
+    @Nullable
+    public String getCode() {
+        return code;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mailcomposer/classes/CustomExceptions.java

@@ -0,0 +1,9 @@
+package io.capawesome.capacitorjs.plugins.mailcomposer.classes;
+
+public class CustomExceptions {
+
+    public static final CustomException ATTACHMENT_NOT_FOUND = new CustomException(
+        "ATTACHMENT_NOT_FOUND",
+        "An attachment could not be found at the provided path."
+    );
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mailcomposer/classes/options/ComposeMailOptions.java

@@ -0,0 +1,86 @@
+package io.capawesome.capacitorjs.plugins.mailcomposer.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.PluginCall;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONException;
+
+public class ComposeMailOptions {
+
+    @NonNull
+    private final List<String> attachments;
+
+    @NonNull
+    private final List<String> bcc;
+
+    @Nullable
+    private final String body;
+
+    @NonNull
+    private final List<String> cc;
+
+    private final boolean isHtml;
+
+    @Nullable
+    private final String subject;
+
+    @NonNull
+    private final List<String> to;
+
+    public ComposeMailOptions(@NonNull PluginCall call) throws JSONException {
+        this.to = getStringListFromCall(call, "to");
+        this.cc = getStringListFromCall(call, "cc");
+        this.bcc = getStringListFromCall(call, "bcc");
+        this.subject = call.getString("subject");
+        this.body = call.getString("body");
+        this.isHtml = call.getBoolean("isHtml", false);
+        this.attachments = getStringListFromCall(call, "attachments");
+    }
+
+    @NonNull
+    public List<String> getAttachments() {
+        return attachments;
+    }
+
+    @NonNull
+    public List<String> getBcc() {
+        return bcc;
+    }
+
+    @Nullable
+    public String getBody() {
+        return body;
+    }
+
+    @NonNull
+    public List<String> getCc() {
+        return cc;
+    }
+
+    @Nullable
+    public String getSubject() {
+        return subject;
+    }
+
+    @NonNull
+    public List<String> getTo() {
+        return to;
+    }
+
+    public boolean isHtml() {
+        return isHtml;
+    }
+
+    @NonNull
+    private static List<String> getStringListFromCall(@NonNull PluginCall call, @NonNull String key) throws JSONException {
+        List<String> values = new ArrayList<>();
+        JSArray array = call.getArray(key);
+        if (array != null) {
+            values.addAll(array.toList());
+        }
+        return values;
+    }
+}