@capacitor-community/stripe-terminal 0.0.1

package/CapacitorCommunityStripeTerminal.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorCommunityStripeTerminal'
+  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  = '13.0'
+  s.dependency 'Capacitor'
+  s.dependency 'StripeTerminal'
+  s.swift_version = '5.1'
+end

package/README.md

@@ -0,0 +1,263 @@
+# @capacitor-community/stripe-terminal
+
+Stripe SDK bindings for Capacitor Applications. __This plugin is still in beta.__
+We have confirmed that it works well in the demo project. Please refer to https://github.com/capacitor-community/stripe/tree/main/demo/angular for the implementation.
+
+- [x] Tap To Pay
+- [ ] Internet
+- [ ] Bluetooth
+- [ ] USB
+
+## Install
+
+```bash
+npm install @capacitor-community/stripe-terminal
+npx cap sync
+```
+
+### iOS
+
+- [iOS Configure your app](https://stripe.com/docs/terminal/payments/setup-integration?terminal-sdk-platform=ios#configure)
+
+### Android
+
+Add permissions to your `android/app/src/main/AndroidManifest.xml` file:
+
+```diff
++ <uses-permission android:name="android.permission.BLUETOOTH" />
++ <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
++ <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
++ <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
++ <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+```
+
+If used in conjunction with the `@capacitor-community/stripe` plugin, the following settings may be necessary
+
+Add packagingOptions to your `android/app/build.gradle` file:
+
+```diff
+android {
+...
++  packagingOptions {
++    resources.excludes.add("org/bouncycastle/x509/*")
++  }
+}
+```
+
+## API
+
+<docgen-index>
+
+* [`initialize(...)`](#initialize)
+* [`discoverReaders(...)`](#discoverreaders)
+* [`connectReader(...)`](#connectreader)
+* [`collect(...)`](#collect)
+* [`addListener(TerminalEventsEnum.Loaded, ...)`](#addlistenerterminaleventsenumloaded)
+* [`addListener(TerminalEventsEnum.DiscoveredReaders, ...)`](#addlistenerterminaleventsenumdiscoveredreaders)
+* [`addListener(TerminalEventsEnum.ConnectedReader, ...)`](#addlistenerterminaleventsenumconnectedreader)
+* [`addListener(TerminalEventsEnum.Completed, ...)`](#addlistenerterminaleventsenumcompleted)
+* [`addListener(TerminalEventsEnum.Canceled, ...)`](#addlistenerterminaleventsenumcanceled)
+* [`addListener(TerminalEventsEnum.Failed, ...)`](#addlistenerterminaleventsenumfailed)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+* [Enums](#enums)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### initialize(...)
+
+```typescript
+initialize(options: { tokenProviderEndpoint: string; isTest: boolean; }) => Promise<void>
+```
+
+| Param         | Type                                                             |
+| ------------- | ---------------------------------------------------------------- |
+| **`options`** | <code>{ tokenProviderEndpoint: string; isTest: boolean; }</code> |
+
+--------------------
+
+
+### discoverReaders(...)
+
+```typescript
+discoverReaders(options: { type: TerminalConnectType; locationId?: string; }) => Promise<{ readers: ReaderInterface[]; }>
+```
+
+| Param         | Type                                                                                                |
+| ------------- | --------------------------------------------------------------------------------------------------- |
+| **`options`** | <code>{ type: <a href="#terminalconnecttype">TerminalConnectType</a>; locationId?: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ readers: ReaderInterface[]; }&gt;</code>
+
+--------------------
+
+
+### connectReader(...)
+
+```typescript
+connectReader(options: { reader: ReaderInterface; }) => Promise<void>
+```
+
+| Param         | Type                                                                     |
+| ------------- | ------------------------------------------------------------------------ |
+| **`options`** | <code>{ reader: <a href="#readerinterface">ReaderInterface</a>; }</code> |
+
+--------------------
+
+
+### collect(...)
+
+```typescript
+collect(options: { paymentIntent: string; }) => Promise<void>
+```
+
+| Param         | Type                                    |
+| ------------- | --------------------------------------- |
+| **`options`** | <code>{ paymentIntent: string; }</code> |
+
+--------------------
+
+
+### addListener(TerminalEventsEnum.Loaded, ...)
+
+```typescript
+addListener(eventName: TerminalEventsEnum.Loaded, listenerFunc: () => void) => PluginListenerHandle
+```
+
+| Param              | Type                                                                     |
+| ------------------ | ------------------------------------------------------------------------ |
+| **`eventName`**    | <code><a href="#terminaleventsenum">TerminalEventsEnum.Loaded</a></code> |
+| **`listenerFunc`** | <code>() =&gt; void</code>                                               |
+
+**Returns:** <code><a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### addListener(TerminalEventsEnum.DiscoveredReaders, ...)
+
+```typescript
+addListener(eventName: TerminalEventsEnum.DiscoveredReaders, listenerFunc: () => { reader: ReaderInterface; }) => PluginListenerHandle
+```
+
+| Param              | Type                                                                                |
+| ------------------ | ----------------------------------------------------------------------------------- |
+| **`eventName`**    | <code><a href="#terminaleventsenum">TerminalEventsEnum.DiscoveredReaders</a></code> |
+| **`listenerFunc`** | <code>() =&gt; { reader: <a href="#readerinterface">ReaderInterface</a>; }</code>   |
+
+**Returns:** <code><a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### addListener(TerminalEventsEnum.ConnectedReader, ...)
+
+```typescript
+addListener(eventName: TerminalEventsEnum.ConnectedReader, listenerFunc: () => void) => PluginListenerHandle
+```
+
+| Param              | Type                                                                              |
+| ------------------ | --------------------------------------------------------------------------------- |
+| **`eventName`**    | <code><a href="#terminaleventsenum">TerminalEventsEnum.ConnectedReader</a></code> |
+| **`listenerFunc`** | <code>() =&gt; void</code>                                                        |
+
+**Returns:** <code><a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### addListener(TerminalEventsEnum.Completed, ...)
+
+```typescript
+addListener(eventName: TerminalEventsEnum.Completed, listenerFunc: () => void) => PluginListenerHandle
+```
+
+| Param              | Type                                                                        |
+| ------------------ | --------------------------------------------------------------------------- |
+| **`eventName`**    | <code><a href="#terminaleventsenum">TerminalEventsEnum.Completed</a></code> |
+| **`listenerFunc`** | <code>() =&gt; void</code>                                                  |
+
+**Returns:** <code><a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### addListener(TerminalEventsEnum.Canceled, ...)
+
+```typescript
+addListener(eventName: TerminalEventsEnum.Canceled, listenerFunc: () => void) => PluginListenerHandle
+```
+
+| Param              | Type                                                                       |
+| ------------------ | -------------------------------------------------------------------------- |
+| **`eventName`**    | <code><a href="#terminaleventsenum">TerminalEventsEnum.Canceled</a></code> |
+| **`listenerFunc`** | <code>() =&gt; void</code>                                                 |
+
+**Returns:** <code><a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### addListener(TerminalEventsEnum.Failed, ...)
+
+```typescript
+addListener(eventName: TerminalEventsEnum.Failed, listenerFunc: () => void) => PluginListenerHandle
+```
+
+| Param              | Type                                                                     |
+| ------------------ | ------------------------------------------------------------------------ |
+| **`eventName`**    | <code><a href="#terminaleventsenum">TerminalEventsEnum.Failed</a></code> |
+| **`listenerFunc`** | <code>() =&gt; void</code>                                               |
+
+**Returns:** <code><a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### Interfaces
+
+
+#### PluginListenerHandle
+
+| Prop         | Type                                      |
+| ------------ | ----------------------------------------- |
+| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |
+
+
+### Type Aliases
+
+
+#### ReaderInterface
+
+<code>{ index: number; serialNumber: string; }</code>
+
+
+### Enums
+
+
+#### TerminalConnectType
+
+| Members         | Value                     |
+| --------------- | ------------------------- |
+| **`Simulated`** | <code>'simulated'</code>  |
+| **`Internet`**  | <code>'internet'</code>   |
+| **`Bluetooth`** | <code>'bluetooth'</code>  |
+| **`Usb`**       | <code>'usb'</code>        |
+| **`TapToPay`**  | <code>'tap-to-pay'</code> |
+
+
+#### TerminalEventsEnum
+
+| Members                 | Value                                    |
+| ----------------------- | ---------------------------------------- |
+| **`Loaded`**            | <code>'terminalLoaded'</code>            |
+| **`DiscoveredReaders`** | <code>'terminalDiscoveredReaders'</code> |
+| **`ConnectedReader`**   | <code>'terminalConnectedReader'</code>   |
+| **`Completed`**         | <code>'terminalCompleted'</code>         |
+| **`Canceled`**          | <code>'terminalCanceled'</code>          |
+| **`Failed`**            | <code>'terminalFailed'</code>            |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,70 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    ext.kotlin_version = project.hasProperty("kotlin_version") ? rootProject.ext.kotlin_version : '1.8.20'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.0.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.getcapacitor.community.stripe.terminal"
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 33
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 33
+        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_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+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"
+
+    implementation "com.stripe:stripeterminal-localmobile:2.23.0"
+    implementation "com.stripe:stripeterminal-core:2.23.0"
+    implementation 'com.android.volley:volley:1.2.1'
+    implementation 'com.google.android.gms:play-services-wallet:19.1.0'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/StripeTerminal.java

@@ -0,0 +1,227 @@
+package com.getcapacitor.community.stripe.terminal;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.core.util.Supplier;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.community.stripe.terminal.models.Executor;
+import com.google.android.gms.common.util.BiConsumer;
+import com.stripe.stripeterminal.Terminal;
+import com.stripe.stripeterminal.TerminalApplicationDelegate;
+import com.stripe.stripeterminal.external.callable.Callback;
+import com.stripe.stripeterminal.external.callable.Cancelable;
+import com.stripe.stripeterminal.external.callable.DiscoveryListener;
+import com.stripe.stripeterminal.external.callable.PaymentIntentCallback;
+import com.stripe.stripeterminal.external.callable.ReaderCallback;
+import com.stripe.stripeterminal.external.callable.TerminalListener;
+import com.stripe.stripeterminal.external.models.ConnectionConfiguration;
+import com.stripe.stripeterminal.external.models.ConnectionStatus;
+import com.stripe.stripeterminal.external.models.DiscoveryConfiguration;
+import com.stripe.stripeterminal.external.models.DiscoveryMethod;
+import com.stripe.stripeterminal.external.models.PaymentIntent;
+import com.stripe.stripeterminal.external.models.PaymentStatus;
+import com.stripe.stripeterminal.external.models.Reader;
+import com.stripe.stripeterminal.external.models.TerminalException;
+import com.stripe.stripeterminal.log.LogLevel;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONException;
+
+public class StripeTerminal extends Executor {
+
+    private Cancelable discoveryCancelable;
+    private List<Reader> readers;
+    private String locationId;
+    private PluginCall collectCall;
+    private final JSObject emptyObject = new JSObject();
+    private Boolean isTest;
+
+    public StripeTerminal(
+        Supplier<Context> contextSupplier,
+        Supplier<Activity> activitySupplier,
+        BiConsumer<String, JSObject> notifyListenersFunction,
+        String pluginLogTag
+    ) {
+        super(contextSupplier, activitySupplier, notifyListenersFunction, pluginLogTag, "StripeTerminalExecutor");
+        this.contextSupplier = contextSupplier;
+        this.readers = new ArrayList<Reader>();
+    }
+
+    public void initialize(final PluginCall call) throws TerminalException {
+        this.isTest = call.getBoolean("isTest", true);
+        this.activitySupplier.get()
+            .runOnUiThread(
+                () -> {
+                    TerminalApplicationDelegate.onCreate((Application) this.contextSupplier.get().getApplicationContext());
+                    notifyListeners(TerminalEnumEvent.Loaded.getWebEventName(), emptyObject);
+                    call.resolve();
+                }
+            );
+        TerminalListener listener = new TerminalListener() {
+            @Override
+            public void onUnexpectedReaderDisconnect(@NonNull Reader reader) {
+                // TODO: Listenerを追加
+            }
+            //
+            //            @Override
+            //            public void onConnectionStatusChange(@NonNull ConnectionStatus status) {
+            //                // TODO: Listenerを追加
+            //            }
+            //
+            //            @Override
+            //            public void onPaymentStatusChange(@NonNull PaymentStatus status) {
+            //                // TODO: Listenerを追加
+            //            }
+        };
+        LogLevel logLevel = LogLevel.VERBOSE;
+        TokenProvider tokenProvider = new TokenProvider(this.contextSupplier, call.getString("tokenProviderEndpoint"));
+        if (!Terminal.isInitialized()) {
+            Terminal.initTerminal(this.contextSupplier.get().getApplicationContext(), logLevel, tokenProvider, listener);
+        }
+        Terminal.getInstance();
+    }
+
+    public void onDiscoverReaders(final PluginCall call) {
+        this.locationId = call.getString("locationId");
+        final DiscoveryConfiguration config = new DiscoveryConfiguration(
+            0,
+            DiscoveryMethod.LOCAL_MOBILE,
+            this.isTest,
+            call.getString("locationId")
+        );
+        final DiscoveryListener discoveryListener = readers -> {
+            // 検索したReaderの一覧をListenerで渡す
+            Log.d(logTag, String.valueOf(readers.get(0).getSerialNumber()));
+            this.readers = readers;
+            JSArray readersJSObject = new JSArray();
+
+            int i = 0;
+            for (Reader reader : this.readers) {
+                readersJSObject.put(new JSObject().put("index", String.valueOf(i)).put("serialNumber", reader.getSerialNumber()));
+            }
+            this.notifyListeners(TerminalEnumEvent.DiscoveredReaders.getWebEventName(), new JSObject().put("readers", readersJSObject));
+            call.resolve(new JSObject().put("readers", readersJSObject));
+        };
+        discoveryCancelable =
+            Terminal
+                .getInstance()
+                .discoverReaders(
+                    config,
+                    discoveryListener,
+                    // Callback run after connectReader
+                    new Callback() {
+                        @Override
+                        public void onSuccess() {
+                            Log.d(logTag, "Finished discovering readers");
+                        }
+
+                        @Override
+                        public void onFailure(@NonNull TerminalException ex) {
+                            Log.d(logTag, ex.getLocalizedMessage());
+                        }
+                    }
+                );
+    }
+
+    public void connectReader(final PluginCall call) {
+        JSObject reader = call.getObject("reader");
+        ConnectionConfiguration.LocalMobileConnectionConfiguration config = new ConnectionConfiguration.LocalMobileConnectionConfiguration(
+            this.locationId
+        );
+        Terminal
+            .getInstance()
+            .connectLocalMobileReader(
+                this.readers.get(reader.getInteger("index")),
+                config,
+                new ReaderCallback() {
+                    @Override
+                    public void onSuccess(Reader r) {
+                        notifyListeners(TerminalEnumEvent.ConnectedReader.getWebEventName(), emptyObject);
+                        call.resolve();
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull TerminalException ex) {
+                        ex.printStackTrace();
+                        call.reject(ex.getLocalizedMessage(), ex);
+                    }
+                }
+            );
+    }
+
+    public void cancelDiscovering(final PluginCall call) {
+        if (discoveryCancelable != null) {
+            discoveryCancelable.cancel(
+                new Callback() {
+                    @Override
+                    public void onSuccess() {
+                        call.resolve();
+                    }
+
+                    @Override
+                    public void onFailure(TerminalException ex) {
+                        Log.d(logTag, ex.getLocalizedMessage());
+                        call.reject(ex.getLocalizedMessage(), ex);
+                    }
+                }
+            );
+        } else {
+            call.resolve();
+        }
+    }
+
+    public void collect(final PluginCall call) {
+        // メソッドを分割するためcallを永続化
+        this.collectCall = call;
+
+        Terminal.getInstance().retrievePaymentIntent(call.getString("paymentIntent"), createPaymentIntentCallback);
+    }
+
+    private final PaymentIntentCallback createPaymentIntentCallback = new PaymentIntentCallback() {
+        @Override
+        public void onSuccess(@NonNull PaymentIntent paymentIntent) {
+            Terminal.getInstance().collectPaymentMethod(paymentIntent, collectPaymentMethodCallback);
+        }
+
+        @Override
+        public void onFailure(@NonNull TerminalException ex) {
+            notifyListeners(TerminalEnumEvent.Failed.getWebEventName(), emptyObject);
+            collectCall.reject(ex.getLocalizedMessage(), ex);
+        }
+    };
+
+    // Step 3 - we've collected the payment method, so it's time to process the payment
+    private final PaymentIntentCallback collectPaymentMethodCallback = new PaymentIntentCallback() {
+        @Override
+        public void onSuccess(@NonNull PaymentIntent paymentIntent) {
+            Terminal.getInstance().processPayment(paymentIntent, processPaymentCallback);
+        }
+
+        @Override
+        public void onFailure(@NonNull TerminalException ex) {
+            notifyListeners(TerminalEnumEvent.Failed.getWebEventName(), emptyObject);
+            collectCall.reject(ex.getLocalizedMessage(), ex);
+        }
+    };
+
+    // Step 4 - we've processed the payment! Show a success screen
+    private final PaymentIntentCallback processPaymentCallback = new PaymentIntentCallback() {
+        @Override
+        public void onSuccess(@NonNull PaymentIntent paymentIntent) {
+            notifyListeners(TerminalEnumEvent.Completed.getWebEventName(), emptyObject);
+            collectCall.resolve();
+        }
+
+        @Override
+        public void onFailure(@NonNull TerminalException ex) {
+            notifyListeners(TerminalEnumEvent.Failed.getWebEventName(), emptyObject);
+            collectCall.reject(ex.getLocalizedMessage(), ex);
+        }
+    };
+}

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/StripeTerminalPlugin.java

@@ -0,0 +1,93 @@
+package com.getcapacitor.community.stripe.terminal;
+
+import android.Manifest;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import com.getcapacitor.PermissionState;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.annotation.PermissionCallback;
+import com.stripe.stripeterminal.external.models.TerminalException;
+import java.util.Objects;
+import org.json.JSONException;
+
+@RequiresApi(api = Build.VERSION_CODES.S)
+@CapacitorPlugin(
+    name = "StripeTerminal",
+    permissions = {
+        @Permission(alias = "location", strings = { Manifest.permission.ACCESS_FINE_LOCATION }),
+        @Permission(
+            alias = "bluetooth",
+            strings = {
+                Manifest.permission.BLUETOOTH,
+                Manifest.permission.BLUETOOTH_ADMIN,
+                Manifest.permission.BLUETOOTH_SCAN,
+                Manifest.permission.BLUETOOTH_ADVERTISE,
+                Manifest.permission.BLUETOOTH_CONNECT
+            }
+        )
+    }
+)
+public class StripeTerminalPlugin extends Plugin {
+
+    private final StripeTerminal implementation = new StripeTerminal(
+        this::getContext,
+        this::getActivity,
+        this::notifyListeners,
+        getLogTag()
+    );
+
+    @PluginMethod
+    public void initialize(PluginCall call) throws TerminalException {
+        this._initialize(call);
+    }
+
+    @PermissionCallback
+    private void locationPermsCallback(PluginCall call) throws TerminalException {
+        if (getPermissionState("location") == PermissionState.GRANTED) {
+            this._initialize(call);
+        } else {
+            call.reject("Permission is required to get location");
+        }
+    }
+
+    @PermissionCallback
+    private void bluetoothPermsCallback(PluginCall call) throws TerminalException {
+        if (getPermissionState("bluetooth") == PermissionState.GRANTED) {
+            this._initialize(call);
+        } else {
+            call.reject("Permission is required to get bluetooth");
+        }
+    }
+
+    private void _initialize(PluginCall call) throws TerminalException {
+        if (getPermissionState("location") != PermissionState.GRANTED) {
+            requestPermissionForAlias("location", call, "locationPermsCallback");
+        } else if (getPermissionState("bluetooth") != PermissionState.GRANTED) {
+            requestPermissionForAlias("bluetooth", call, "bluetoothPermsCallback");
+        } else {
+            this.implementation.initialize(call);
+        }
+    }
+
+    @PluginMethod
+    public void discoverReaders(PluginCall call) {
+        if (!Objects.equals(call.getString("type"), "tap-to-pay")) {
+            call.unimplemented();
+        }
+        this.implementation.onDiscoverReaders(call);
+    }
+
+    @PluginMethod
+    public void connectReader(PluginCall call) {
+        this.implementation.connectReader(call);
+    }
+
+    @PluginMethod
+    public void collect(PluginCall call) {
+        this.implementation.collect(call);
+    }
+}

package/android/src/main/java/com/getcapacitor/community/stripe/terminal/TerminalEvent.kt

@@ -0,0 +1,10 @@
+package com.getcapacitor.community.stripe.terminal;
+
+enum class TerminalEnumEvent(val webEventName: String) {
+    Loaded("terminalLoaded"),
+    DiscoveredReaders("terminalDiscoveredReaders"),
+    ConnectedReader("terminalConnectedReader"),
+    Completed("terminalCompleted"),
+    Canceled("terminalCanceled"),
+    Failed("terminalFailed"),
+}