@capawesome/capacitor-android-intent-launcher 0.0.1

package/CapawesomeCapacitorAndroidIntentLauncher.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapawesomeCapacitorAndroidIntentLauncher'
+  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: "CapawesomeCapacitorAndroidIntentLauncher",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CapawesomeCapacitorAndroidIntentLauncher",
+            targets: ["AndroidIntentLauncherPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
+    ],
+    targets: [
+        .target(
+            name: "AndroidIntentLauncherPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Plugin"),
+        .testTarget(
+            name: "AndroidIntentLauncherPluginTests",
+            dependencies: ["AndroidIntentLauncherPlugin"],
+            path: "ios/PluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,242 @@
+# Capacitor Android Intent Launcher Plugin
+
+Capacitor plugin to launch arbitrary Android intents.
+
+<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
+
+- 🚀 **Start activities**: Launch any Android activity via a custom intent and read its result.
+- 🔍 **Resolve activities**: Check whether an activity can handle an intent before launching it.
+- 🎯 **Explicit & implicit intents**: Target a specific component or let the system pick a handler.
+- 📦 **Extras & flags**: Attach primitive extras and intent flags.
+- 🔁 **Up-to-date**: Always supports the latest Capacitor version.
+- 🤝 **Compatibility**: Works alongside the [Settings Launcher](https://capawesome.io/docs/sdks/capacitor/settings-launcher/) and [App Launcher](https://capawesome.io/docs/sdks/capacitor/app-launcher/) plugins.
+
+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-android-intent-launcher` 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-android-intent-launcher
+npx cap sync
+```
+
+This plugin is only available on **Android**. On iOS and Web, all methods reject as unimplemented.
+
+### Android
+
+No additional configuration is required for this plugin.
+
+However, on Android 11 (API level 30) and higher, [package visibility](https://developer.android.com/training/package-visibility) restricts which apps and intents your app can see. To launch or resolve intents that target other apps, you may need to declare matching [`<queries>`](https://developer.android.com/guide/topics/manifest/queries-element) entries in your app's `AndroidManifest.xml`. See [Package visibility](#package-visibility) below.
+
+### iOS
+
+This plugin has **no iOS implementation**. Intents are an Android-only concept. All methods reject as unimplemented on iOS.
+
+## Configuration
+
+No configuration required for this plugin.
+
+## Usage
+
+```typescript
+import { AndroidIntentLauncher } from '@capawesome/capacitor-android-intent-launcher';
+
+const startActivity = async () => {
+  const { resultCode } = await AndroidIntentLauncher.startActivity({
+    action: 'android.intent.action.VIEW',
+    dataUri: 'https://capawesome.io',
+  });
+  return resultCode;
+};
+
+const canResolveActivity = async () => {
+  const { canResolve } = await AndroidIntentLauncher.canResolveActivity({
+    action: 'android.intent.action.VIEW',
+    dataUri: 'https://capawesome.io',
+  });
+  return canResolve;
+};
+```
+
+## API
+
+<docgen-index>
+
+* [`canResolveActivity(...)`](#canresolveactivity)
+* [`startActivity(...)`](#startactivity)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### canResolveActivity(...)
+
+```typescript
+canResolveActivity(options: CanResolveActivityOptions) => Promise<CanResolveActivityResult>
+```
+
+Check whether an activity exists that can handle the given intent.
+
+This is a wrapper around the `PackageManager.resolveActivity(...)` API.
+
+On Android 11 (API level 30) and higher, the result is affected by
+package visibility. Your app may need to declare matching `&lt;queries&gt;`
+entries in its `AndroidManifest.xml` for the intent to be resolved.
+
+Only available on Android.
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#startactivityoptions">StartActivityOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#canresolveactivityresult">CanResolveActivityResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### startActivity(...)
+
+```typescript
+startActivity(options: StartActivityOptions) => Promise<StartActivityResult>
+```
+
+Launch an activity for the given intent.
+
+The intent is started via the `startActivityForResult(...)` API so the
+result code and result data of the launched activity are returned once it
+finishes.
+
+This is the power-user escape hatch for system screens and app
+integrations that no dedicated plugin covers. Prefer a typed plugin (such
+as [Settings Launcher](https://capawesome.io/docs/sdks/capacitor/settings-launcher/)
+or [App Launcher](https://capawesome.io/docs/sdks/capacitor/app-launcher/))
+where one exists.
+
+Only available on Android.
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#startactivityoptions">StartActivityOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#startactivityresult">StartActivityResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### CanResolveActivityResult
+
+| Prop             | Type                 | Description                                                   | Since |
+| ---------------- | -------------------- | ------------------------------------------------------------- | ----- |
+| **`canResolve`** | <code>boolean</code> | Whether or not an activity exists that can handle the intent. | 0.1.0 |
+
+
+#### StartActivityOptions
+
+| Prop              | Type                                                         | Description                                                                                                                                                                                                                                            | Since |
+| ----------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----- |
+| **`action`**      | <code>string</code>                                          | The action of the intent.                                                                                                                                                                                                                              | 0.1.0 |
+| **`categories`**  | <code>string[]</code>                                        | The categories to add to the intent.                                                                                                                                                                                                                   | 0.1.0 |
+| **`className`**   | <code>string</code>                                          | The fully qualified class name of the component to launch. Must be used together with the `packageName` property to create an explicit intent that targets a specific component.                                                                       | 0.1.0 |
+| **`dataUri`**     | <code>string</code>                                          | The data URI of the intent.                                                                                                                                                                                                                            | 0.1.0 |
+| **`extras`**      | <code>{ [key: string]: string \| number \| boolean; }</code> | The extras to add to the intent. Only primitive values (string, number and boolean) are supported.                                                                                                                                                     | 0.1.0 |
+| **`flags`**       | <code>number</code>                                          | The flags to add to the intent. Multiple flags can be combined using the bitwise OR operator.                                                                                                                                                          | 0.1.0 |
+| **`packageName`** | <code>string</code>                                          | The package name of the component to launch. If used without the `className` property, the intent is restricted to the given package. If used together with the `className` property, an explicit intent that targets a specific component is created. | 0.1.0 |
+| **`type`**        | <code>string</code>                                          | The MIME type of the intent data.                                                                                                                                                                                                                      | 0.1.0 |
+
+
+#### StartActivityResult
+
+| Prop             | Type                        | Description                                                                                                                                                                                                                        | Since |
+| ---------------- | --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`dataUri`**    | <code>string \| null</code> | The data URI returned by the launched activity.                                                                                                                                                                                    | 0.1.0 |
+| **`resultCode`** | <code>number</code>         | The result code returned by the launched activity. The value is `-1` if the activity finished successfully (`RESULT_OK`), `0` if it was canceled (`RESULT_CANCELED`) or any other custom result code set by the launched activity. | 0.1.0 |
+
+
+### Type Aliases
+
+
+#### CanResolveActivityOptions
+
+<code><a href="#startactivityoptions">StartActivityOptions</a></code>
+
+</docgen-api>
+
+## Common Intents
+
+The following table lists a few common intents to get you started. See the [Android documentation](https://developer.android.com/reference/android/content/Intent) for the full list of actions, categories, extras and flags.
+
+| Use case          | `action`                          | `dataUri`                | `type`         | `extras`                                                     |
+| ----------------- | --------------------------------- | ------------------------ | -------------- | ----------------------------------------------------------- |
+| Open a website    | `android.intent.action.VIEW`      | `https://capawesome.io`  | –              | –                                                           |
+| Open the dialer   | `android.intent.action.DIAL`      | `tel:+12025550123`       | –              | –                                                           |
+| Compose an email  | `android.intent.action.SENDTO`    | `mailto:hi@example.com`  | –              | `{ 'android.intent.extra.SUBJECT': 'Hi' }`                  |
+| Share plain text  | `android.intent.action.SEND`      | –                        | `text/plain`   | `{ 'android.intent.extra.TEXT': 'Hello world!' }`           |
+| Open app settings | `android.settings.APPLICATION_DETAILS_SETTINGS` | `package:com.example.app` | – | –                                                           |
+
+This plugin is intended as a **last resort** for system screens and app integrations that no dedicated plugin covers. Prefer a typed plugin where one exists — for example [Settings Launcher](https://capawesome.io/docs/sdks/capacitor/settings-launcher/) for system settings screens or [App Launcher](https://capawesome.io/docs/sdks/capacitor/app-launcher/) for opening URLs and other apps.
+
+## Package Visibility
+
+On Android 11 (API level 30) and higher, [package visibility](https://developer.android.com/training/package-visibility) limits which other apps your app can interact with. This affects both `startActivity(...)` (an unresolvable intent rejects with the error code `ACTIVITY_NOT_FOUND`) and `canResolveActivity(...)` (which returns `false` for intents your app cannot see).
+
+If you launch or resolve intents that target other apps, declare the intents you query in your app's `AndroidManifest.xml`. The plugin cannot predeclare arbitrary intents on your behalf.
+
+```xml
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <queries>
+    <intent>
+      <action android:name="android.intent.action.VIEW" />
+      <data android:scheme="https" />
+    </intent>
+  </queries>
+</manifest>
+```
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/android-intent-launcher/CHANGELOG.md).
+
+## License
+
+See [LICENSE](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/android-intent-launcher/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.androidintentlauncher"
+    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 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"></manifest>

package/android/src/main/java/io/capawesome/capacitorjs/plugins/androidintentlauncher/AndroidIntentLauncher.java

@@ -0,0 +1,106 @@
+package io.capawesome.capacitorjs.plugins.androidintentlauncher;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import androidx.activity.result.ActivityResult;
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.classes.options.IntentOptions;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.classes.results.CanResolveActivityResult;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.classes.results.StartActivityResult;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.interfaces.NonEmptyResultCallback;
+import java.util.Iterator;
+import java.util.List;
+import org.json.JSONException;
+
+public class AndroidIntentLauncher {
+
+    @NonNull
+    private final AndroidIntentLauncherPlugin plugin;
+
+    public AndroidIntentLauncher(@NonNull AndroidIntentLauncherPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void canResolveActivity(@NonNull IntentOptions options, @NonNull NonEmptyResultCallback<CanResolveActivityResult> callback) {
+        Intent intent = createIntent(options);
+        PackageManager packageManager = getContext().getPackageManager();
+        boolean canResolve = intent.resolveActivity(packageManager) != null;
+        callback.success(new CanResolveActivityResult(canResolve));
+    }
+
+    @NonNull
+    public Intent createIntent(@NonNull IntentOptions options) {
+        Intent intent = new Intent();
+        intent.setAction(options.getAction());
+        String dataUri = options.getDataUri();
+        String type = options.getType();
+        if (dataUri != null && type != null) {
+            intent.setDataAndType(Uri.parse(dataUri), type);
+        } else if (dataUri != null) {
+            intent.setData(Uri.parse(dataUri));
+        } else if (type != null) {
+            intent.setType(type);
+        }
+        List<String> categories = options.getCategories();
+        if (categories != null) {
+            for (String category : categories) {
+                intent.addCategory(category);
+            }
+        }
+        String packageName = options.getPackageName();
+        String className = options.getClassName();
+        if (packageName != null && className != null) {
+            intent.setClassName(packageName, className);
+        } else if (packageName != null) {
+            intent.setPackage(packageName);
+        }
+        JSObject extras = options.getExtras();
+        if (extras != null) {
+            applyExtras(intent, extras);
+        }
+        Integer flags = options.getFlags();
+        if (flags != null) {
+            intent.setFlags(flags);
+        }
+        return intent;
+    }
+
+    @NonNull
+    public StartActivityResult createStartActivityResult(@NonNull ActivityResult result) {
+        Intent data = result.getData();
+        String dataUri = data != null && data.getData() != null ? data.getData().toString() : null;
+        return new StartActivityResult(result.getResultCode(), dataUri);
+    }
+
+    private void applyExtras(@NonNull Intent intent, @NonNull JSObject extras) {
+        Iterator<String> keys = extras.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            Object value;
+            try {
+                value = extras.get(key);
+            } catch (JSONException exception) {
+                continue;
+            }
+            if (value instanceof String) {
+                intent.putExtra(key, (String) value);
+            } else if (value instanceof Boolean) {
+                intent.putExtra(key, (Boolean) value);
+            } else if (value instanceof Integer) {
+                intent.putExtra(key, (Integer) value);
+            } else if (value instanceof Long) {
+                intent.putExtra(key, (Long) value);
+            } else if (value instanceof Double) {
+                intent.putExtra(key, (Double) value);
+            }
+        }
+    }
+
+    @NonNull
+    private Context getContext() {
+        return plugin.getContext();
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/androidintentlauncher/AndroidIntentLauncherPlugin.java

@@ -0,0 +1,103 @@
+package io.capawesome.capacitorjs.plugins.androidintentlauncher;
+
+import android.content.ActivityNotFoundException;
+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.androidintentlauncher.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.classes.options.IntentOptions;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.classes.results.CanResolveActivityResult;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.androidintentlauncher.interfaces.Result;
+
+@CapacitorPlugin(name = "AndroidIntentLauncher")
+public class AndroidIntentLauncherPlugin extends Plugin {
+
+    public static final String ERROR_UNKNOWN_ERROR = "An unknown error occurred.";
+    public static final String TAG = "AndroidIntentLauncherPlugin";
+
+    private AndroidIntentLauncher implementation;
+
+    @Override
+    public void load() {
+        implementation = new AndroidIntentLauncher(this);
+    }
+
+    @PluginMethod
+    public void canResolveActivity(PluginCall call) {
+        try {
+            IntentOptions options = new IntentOptions(call);
+            NonEmptyResultCallback<CanResolveActivityResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull CanResolveActivityResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.canResolveActivity(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void startActivity(PluginCall call) {
+        Intent intent;
+        try {
+            IntentOptions options = new IntentOptions(call);
+            intent = implementation.createIntent(options);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+            return;
+        }
+        try {
+            startActivityForResult(call, intent, "handleStartActivityResult");
+        } catch (ActivityNotFoundException exception) {
+            rejectCall(call, CustomExceptions.ACTIVITY_NOT_FOUND);
+        } catch (Exception exception) {
+            rejectCall(call, CustomExceptions.START_FAILED);
+        }
+    }
+
+    @ActivityCallback
+    private void handleStartActivityResult(@Nullable PluginCall call, @NonNull ActivityResult result) {
+        if (call == null) {
+            return;
+        }
+        resolveCall(call, implementation.createStartActivityResult(result));
+    }
+
+    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 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/androidintentlauncher/classes/CustomException.java

@@ -0,0 +1,20 @@
+package io.capawesome.capacitorjs.plugins.androidintentlauncher.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/androidintentlauncher/classes/CustomExceptions.java

@@ -0,0 +1,11 @@
+package io.capawesome.capacitorjs.plugins.androidintentlauncher.classes;
+
+public class CustomExceptions {
+
+    public static final CustomException ACTION_MISSING = new CustomException(null, "action must be provided.");
+    public static final CustomException ACTIVITY_NOT_FOUND = new CustomException(
+        "ACTIVITY_NOT_FOUND",
+        "No activity was found that can handle the intent."
+    );
+    public static final CustomException START_FAILED = new CustomException("START_FAILED", "The activity could not be started.");
+}