Handle other Android connection methods #111

android/src/main/java/com/stripeterminalreactnative/Mappers.kt

@@ -199,6 +199,13 @@ internal fun mapFromReaderInputOptions(options: ReaderInputOptions): WritableArr
     return mappedOptions
 }
 
+internal fun mapFromReaderEvent(event: ReaderEvent): String {
+    return when (event) {
+        ReaderEvent.CARD_INSERTED -> "cardInserted"
+        ReaderEvent.CARD_REMOVED -> "cardRemoved"
+    }
+}
+
 internal fun mapFromReaderDisplayMessage(message: ReaderDisplayMessage): String {
     return when (message) {
         ReaderDisplayMessage.CHECK_MOBILE_DEVICE -> "checkMobileDevice"

android/src/main/java/com/stripeterminalreactnative/StripeTerminalReactNativeModule.kt

@@ -20,6 +20,7 @@ import com.stripe.stripeterminal.external.callable.BluetoothReaderListener
 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.HandoffReaderListener
 import com.stripe.stripeterminal.external.callable.LocationListCallback
 import com.stripe.stripeterminal.external.callable.PaymentIntentCallback
 import com.stripe.stripeterminal.external.callable.PaymentMethodCallback
@@ -41,6 +42,7 @@ import com.stripe.stripeterminal.external.models.PaymentStatus
 import com.stripe.stripeterminal.external.models.ReadReusableCardParameters
 import com.stripe.stripeterminal.external.models.Reader
 import com.stripe.stripeterminal.external.models.ReaderDisplayMessage
+import com.stripe.stripeterminal.external.models.ReaderEvent
 import com.stripe.stripeterminal.external.models.ReaderInputOptions
 import com.stripe.stripeterminal.external.models.ReaderSoftwareUpdate
 import com.stripe.stripeterminal.external.models.Refund
@@ -263,6 +265,110 @@ class StripeTerminalReactNativeModule(reactContext: ReactApplicationContext) :
         })
     }
 
+    @ReactMethod
+    fun connectLocalMobileReader(params: ReadableMap, promise: Promise) {
+        val readerId = requireParam(params.getString("readerId")) {
+            "You must provide readerId"
+        }
+
+        val selectedReader = requireParam(discoveredReadersList.find {
+            it.serialNumber == readerId
+        }) {
+            "Could not find reader with id $readerId"
+        }
+
+        val locationId = params.getString("locationId") ?: selectedReader.location?.id.orEmpty()
+
+        Terminal.getInstance().connectLocalMobileReader(
+            selectedReader,
+            ConnectionConfiguration.LocalMobileConnectionConfiguration(locationId),
+            object : ReaderCallback {
+                override fun onSuccess(reader: Reader) {
+                    promise.resolve(nativeMapOf {
+                        putMap("reader", mapFromReader(reader))
+                    })
+                }
+
+                override fun onFailure(e: TerminalException) {
+                    promise.resolve(createError(e))
+                }
+            }
+        )
+    }
+
+    @ReactMethod
+    fun connectEmbeddedReader(params: ReadableMap, promise: Promise) =
+        withExceptionResolver(promise) {
+            val readerId = requireParam(params.getString("readerId")) {
+                "You must provide readerId"
+            }
+
+            val selectedReader = requireParam(discoveredReadersList.find {
+                it.serialNumber == readerId
+            }) {
+                "Could not find reader with id $readerId"
+            }
+
+            val locationId = params.getString("locationId") ?: selectedReader.location?.id.orEmpty()
+
+            Terminal.getInstance().connectEmbeddedReader(
+                selectedReader,
+                ConnectionConfiguration.EmbeddedConnectionConfiguration(locationId),
+                object : ReaderCallback {
+                    override fun onSuccess(reader: Reader) {
+                        promise.resolve(nativeMapOf {
+                            putMap("reader", mapFromReader(reader))
+                        })
+                    }
+
+                    override fun onFailure(e: TerminalException) {
+                        promise.resolve(e)
+                    }
+                }
+            )
+        }
+
+    @ReactMethod
+    fun connectHandoffReader(params: ReadableMap, promise: Promise) =
+        withExceptionResolver(promise) {
+            val readerId = requireParam(params.getString("readerId")) {
+                "You must provide readerId"
+            }
+
+            val selectedReader = requireParam(discoveredReadersList.find {
+                it.serialNumber == readerId
+            }) {
+                "Could not find reader with id $readerId"
+            }
+
+            val locationId = params.getString("locationId") ?: selectedReader.location?.id.orEmpty()
+
+            val listener: HandoffReaderListener = object : HandoffReaderListener {
+                override fun onReportReaderEvent(event: ReaderEvent) {
+                    sendEvent("didRequestReaderInput", nativeMapOf {
+                        putString("event", mapFromReaderEvent(event))
+                    })
+                }
+            }
+
+            Terminal.getInstance().connectHandoffReader(
+                selectedReader,
+                ConnectionConfiguration.HandoffConnectionConfiguration(locationId),
+                listener,
+                object : ReaderCallback {
+                    override fun onSuccess(reader: Reader) {
+                        promise.resolve(nativeMapOf {
+                            putMap("reader", mapFromReader(reader))
+                        })
+                    }
+
+                    override fun onFailure(e: TerminalException) {
+                        promise.resolve(createError(e))
+                    }
+                }
+            )
+        }
+
     @ReactMethod
     @Suppress("unused")
     fun connectBluetoothReader(params: ReadableMap, promise: Promise) =
@@ -283,10 +389,6 @@ class StripeTerminalReactNativeModule(reactContext: ReactApplicationContext) :
                     "You must provide a locationId"
                 }
 
-            val connectionConfig = ConnectionConfiguration.BluetoothConnectionConfiguration(
-                locationId
-            )
-
             val listener: BluetoothReaderListener = object : BluetoothReaderListener {
                 override fun onReportAvailableUpdate(update: ReaderSoftwareUpdate) {
                     sendEvent(REPORT_AVAILABLE_UPDATE.listenerName) {
@@ -340,7 +442,7 @@ class StripeTerminalReactNativeModule(reactContext: ReactApplicationContext) :
 
             terminal.connectBluetoothReader(
                 selectedReader,
-                connectionConfig,
+                ConnectionConfiguration.BluetoothConnectionConfiguration(locationId),
                 listener,
                 object : ReaderCallback {
                     override fun onSuccess(reader: Reader) {
@@ -461,9 +563,6 @@ class StripeTerminalReactNativeModule(reactContext: ReactApplicationContext) :
                 sendEvent(REQUEST_READER_DISPLAY_MESSAGE.listenerName) {
                     putString("result", mapFromReaderDisplayMessage(message))
                 }
-                sendEvent(REQUEST_READER_DISPLAY_MESSAGE.listenerName) {
-                    putString("result", mapFromReaderDisplayMessage(message))
-                }
             }
         }
 

e2e/app.e2e.js

@@ -50,13 +50,37 @@ describe('Payments', () => {
   });
 
   it('Change discovery method to bluetooth proximity', async () => {
+    if (device.getPlatform() !== 'ios') {
+      return;
+    }
     await changeDiscoveryMethod('Bluetooth Proximity');
   });
 
   it('Change discovery method to Internet', async () => {
     await changeDiscoveryMethod('Internet');
   });
 
+  it('Change discovery method to Embedded', async () => {
+    if (device.getPlatform() !== 'android') {
+      return;
+    }
+    await changeDiscoveryMethod('Embedded');
+  });
+
+  it('Change discovery method to LocalMobile', async () => {
+    if (device.getPlatform() !== 'android') {
+      return;
+    }
+    await changeDiscoveryMethod('Local mobile');
+  });
+
+  it('Change discovery method to Handoff', async () => {
+    if (device.getPlatform() !== 'android') {
+      return;
+    }
+    await changeDiscoveryMethod('Handoff');
+  });
+
   // temporary skipped due to bug in stripe-termina-ios that connects the device despite an error.
   //
   it('Required update impossible due to low battery', async () => {

example/src/screens/DiscoverReadersScreen.tsx

@@ -49,6 +49,9 @@ export default function DiscoverReadersScreen() {
     connectInternetReader,
     connectUsbReader,
     simulateReaderUpdate,
+    connectEmbeddedReader,
+    connectLocalMobileReader,
+    connectHandoffReader,
   } = useStripeTerminal({
     onFinishDiscoveringReaders: (finishError) => {
       if (finishError) {
@@ -154,6 +157,15 @@ export default function DiscoverReadersScreen() {
     ) {
       const result = await handleConnectBluetoothReader(reader);
       error = result.error;
+    } else if (discoveryMethod === 'localMobile') {
+      const result = await handleConnectLocalMobileReader(reader);
+      error = result.error;
+    } else if (discoveryMethod === 'handoff') {
+      const result = await handleConnectHandoffReader(reader);
+      error = result.error;
+    } else if (discoveryMethod === 'embedded') {
+      const result = await handleConnectEmbeddedReader(reader);
+      error = result.error;
     } else if (discoveryMethod === 'usb') {
       const result = await handleConnectUsbReader(reader);
       error = result.error;
@@ -166,6 +178,54 @@ export default function DiscoverReadersScreen() {
     }
   };
 
+  const handleConnectEmbeddedReader = async (reader: Reader.Type) => {
+    setConnectingReader(reader);
+
+    const { reader: connectedReader, error } = await connectEmbeddedReader({
+      reader,
+      locationId: selectedLocation?.id,
+    });
+
+    if (error) {
+      console.log('connectEmbeddedReader error:', error);
+    } else {
+      console.log('Reader connected successfully', connectedReader);
+    }
+    return { error };
+  };
+
+  const handleConnectHandoffReader = async (reader: Reader.Type) => {
+    setConnectingReader(reader);
+
+    const { reader: connectedReader, error } = await connectHandoffReader({
+      reader,
+      locationId: selectedLocation?.id,
+    });
+
+    if (error) {
+      console.log('connectHandoffReader error:', error);
+    } else {
+      console.log('Reader connected successfully', connectedReader);
+    }
+    return { error };
+  };
+
+  const handleConnectLocalMobileReader = async (reader: Reader.Type) => {
+    setConnectingReader(reader);
+
+    const { reader: connectedReader, error } = await connectLocalMobileReader({
+      reader,
+      locationId: selectedLocation?.id,
+    });
+
+    if (error) {
+      console.log('connectLocalMobileReader error:', error);
+    } else {
+      console.log('Reader connected successfully', connectedReader);
+    }
+    return { error };
+  };
+
   const handleConnectBluetoothReader = async (reader: Reader.Type) => {
     setConnectingReader(reader);
 

example/src/screens/DiscoveryMethodScreen.tsx

@@ -1,6 +1,6 @@
 import { RouteProp, useNavigation, useRoute } from '@react-navigation/core';
 import React from 'react';
-import { StyleSheet, Text, View } from 'react-native';
+import { Platform, StyleSheet, Text, View } from 'react-native';
 import type { Reader } from 'stripe-terminal-react-native';
 import { colors } from '../colors';
 import ListItem from '../components/ListItem';
@@ -28,14 +28,7 @@ export default function DiscoveryMethodScreen() {
       <Text style={styles.info}>
         Discover a reader by scanning for Bluetooth or Bluetooth LE devices.
       </Text>
-      <ListItem
-        onPress={() => onSelect('bluetoothProximity')}
-        title="Bluetooth Proximity"
-      />
-      <Text style={styles.info}>
-        Discover a reader by holding it next to the iOS device (only supported
-        for the BBPOS Chipper 2X BT).
-      </Text>
+
       <Text style={styles.info}>
         {
           'Note: the Stripe Terminal SDK can discover supported readers automatically - you should not connect to the reader in the iOS Settings > Bluetooth page.'
@@ -51,6 +44,28 @@ export default function DiscoveryMethodScreen() {
       <Text style={styles.info}>
         Discover a reader connected to this device via USB.
       </Text>
+
+      {Platform.OS === 'android' ? (
+        <>
+          <ListItem onPress={() => onSelect('embedded')} title="Embedded" />
+          <ListItem onPress={() => onSelect('handoff')} title="Handoff" />
+          <ListItem
+            onPress={() => onSelect('localMobile')}
+            title="Local mobile"
+          />
+        </>
+      ) : (
+        <>
+          <ListItem
+            onPress={() => onSelect('bluetoothProximity')}
+            title="Bluetooth Proximity"
+          />
+          <Text style={styles.info}>
+            Discover a reader by holding it next to the iOS device (only
+            supported for the BBPOS Chipper 2X BT).
+          </Text>
+        </>
+      )}
     </View>
   );
 }

example/src/screens/HomeScreen.tsx

@@ -153,6 +153,12 @@ function mapFromDiscoveryMethod(method: Reader.DiscoveryMethod) {
       return 'Bluetooth Proximity';
     case 'internet':
       return 'Internet';
+    case 'embedded':
+      return 'Embedded';
+    case 'handoff':
+      return 'Handoff';
+    case 'localMobile':
+      return 'Local mobile';
     case 'usb':
       return 'USB';
     default: