# Mit einem Lesegerät verbinden

Verbinden Sie Ihre Anwendung mit einem Stripe Terminal-Lesegerät.

> Wenn Sie sich noch nicht für ein Lesegerät entschieden haben, vergleichen Sie die verfügbaren [Terminal-Lesegeräte](https://docs.stripe.com/terminal/payments/setup-reader.md) und wählen Sie das aus, das Ihren Bedürfnissen am besten entspricht.

# Simuliertes Lesegerät

> This is a Simuliertes Lesegerät for when terminal-sdk-platform is server-driven and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=server-driven&reader-type=simulated.

Stripe bietet ein simuliertes servergestütztes Lesegerät, mit dem Sie Ihre App entwickeln und testen und Terminal-Zahlungen simulieren können, ohne eine Verbindung zur physischen Hardware herstellen zu müssen.

## Simuliertes Lesegerät erstellen

Um ein simuliertes Lesegerät zu erstellen, verwenden Sie bei der Registrierung des Lesegeräts einen der angegebenen Registrierungscodes (`simulated-wpe`, `simulated-s700` oder `simulated-s710`). Dieser Registrierungscode erstellt ein simuliertes Lesegerätobjekt für WisePOS E, Stripe S700 oder Stripe S710 nur in einer Sandbox. Sie können das simulierte Lesegerät über die Stripe API registrieren:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d location="{{TERMINALLOCATION_ID}}" \
  -d registration_code=simulated-wpe
```

Dadurch wird ein [Reader](https://docs.stripe.com/api/terminal/readers.md)-Objekt zurückgegeben, das Ihr simuliertes Lesegerät darstellt:

```json
{
  "id": "tmr_xxx",
  "object": "terminal.reader",
  "device_sw_version": "2.37.2.0",
  "device_type": "simulated_wisepos_e",
  "ip_address": "0.0.0.0",
  "label": "simulated-wpe-xxx-xxx-xx-xxx",
  "livemode": false,
  "location": "tml_xxx",
  "serial_number": "simulated-wpe-xxx-xxx-xx-xxx",
  "status": "online"
}
```

## Ihr simuliertes Lesegerät abfragen

Das simulierte Lesegerät verhält sich wie ein echtes Lesegerät. Sie können die zugehörigen Informationen vom [Endpoint des Lesegeräts](https://docs.stripe.com/api/terminal/readers/retrieve.md) abrufen:

```curl
curl https://api.stripe.com/v1/terminal/readers/tmr_xxx \
  -u "<<YOUR_SECRET_KEY>>:"
```

```json
{
  "id": "tmr_xxx",
  "object": "terminal.reader",
  "action": null,
  "device_sw_version": "2.37.2.0",
  "device_type": "simulated_wisepos_e",
  "ip_address": "0.0.0.0",
  "label": "simulated-wpe-xxx-xxx-xx-xxx",
  "livemode": false,
  "location": "tml_xxx",
  "metadata": {
  },
  "serial_number": "simulated-wpe-xxx-xxx-xx-xxx",
  "status": "offline"
}
```


# Simuliertes Lesegerät

> This is a Simuliertes Lesegerät for when terminal-sdk-platform is js and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=js&reader-type=simulated.

Stripe Terminal SDKs und die servergestützte Integration verfügen über ein integriertes simuliertes Kartenlesegerät, sodass Sie Ihre App entwickeln und testen können, ohne eine Verbindung zu physischer Hardware herstellen zu müssen. Mit dem simulierten Lesegerät können Sie alle Terminal-Abläufe in Ihrer App nachbilden, unabhängig davon, ob Ihre Integration abgeschlossen ist oder sich noch im Aufbau befindet.

Das simulierte Lesegerät bietet keine Nutzeroberfläche. Nachdem Sie in Ihrer App eine Verbindung damit hergestellt haben, können Sie sehen, dass es funktioniert, wenn Aufrufe des Stripe SDK oder der API erfolgreich sind.

Simulierte Lesegeräte für SDKs simulieren bei Bedarf automatisch die Kartenpräsentation. Aktualisieren Sie für die serverseitige Integration Ihre Integration auf [Kartenwährung simulieren](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Um das simulierte Lesegerät zu verwenden, rufen Sie [discoverReaders](https://docs.stripe.com/terminal/references/api/js-sdk.md#discover-readers) auf, um nach Lesegeräten zu suchen, und legen Sie die Option `simulated` auf `true` fest. Wenn `discoverReaders` ein Ergebnis zurückgibt, rufen Sie [connectReader](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) auf, um eine Verbindung mit dem simulierten Lesegerät herzustellen.

```javascript
// Handler for a "Connect Reader" button
async function connectReaderHandler() {
  const config = {simulated: true};
  const discoverResult = await terminal.discoverReaders(config);
  if (discoverResult.error) {
    console.log('Failed to discover: ', discoverResult.error);
  } else if (discoverResult.discoveredReaders.length === 0) {
    console.log('No available readers.');
  } else {
    // Just select the first reader here.
    const selectedReader = discoverResult.discoveredReaders[0];

    const connectResult = await terminal.connectReader(selectedReader);
    if (connectResult.error) {
      console.log('Failed to connect: ', connectResult.error);
    } else {
      console.log('Connected to reader: ', connectResult.reader.label);
    }
  }
}
```

### Konfiguration von simulierten Lesegeräten

- [setSimulatorConfiguration (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-setsimulatorconfig)

Das simulierte Lesegerät kann in geringem Maße konfiguriert werden, sodass Sie verschiedene Abläufe innerhalb Ihrer Point-of-Sale-Anwendung testen können, z.&nbsp;B. verschiedene Karten oder aber Fehlerszenarien, wie eine abgelehnte Zahlung. Um dieses Verhalten zu aktivieren, verwenden Sie den folgenden Code, bevor Sie Ihre Zahlungsmethode erfassen:

```javascript
terminal.setSimulatorConfiguration({testCardNumber: '4242424242424242'});
```


# Simuliertes Lesegerät

> This is a Simuliertes Lesegerät for when terminal-sdk-platform is ios and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=simulated.

Stripe Terminal SDKs und die servergestützte Integration verfügen über ein integriertes simuliertes Kartenlesegerät, sodass Sie Ihre App entwickeln und testen können, ohne eine Verbindung zu physischer Hardware herstellen zu müssen. Mit dem simulierten Lesegerät können Sie alle Terminal-Abläufe in Ihrer App nachbilden, unabhängig davon, ob Ihre Integration abgeschlossen ist oder sich noch im Aufbau befindet.

Das simulierte Lesegerät bietet keine Nutzeroberfläche. Nachdem Sie in Ihrer App eine Verbindung damit hergestellt haben, können Sie sehen, dass es funktioniert, wenn Aufrufe des Stripe SDK oder der API erfolgreich sind.

Simulierte Lesegeräte für SDKs simulieren bei Bedarf automatisch die Kartenpräsentation. Aktualisieren Sie für die serverseitige Integration Ihre Integration auf [Kartenwährung simulieren](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Um das simulierte Lesegerät zu verwenden, rufen Sie [discoverReaders](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) auf, um nach Lesegeräten zu suchen, und legen Sie die Option `simulated` auf `true` fest. Wenn `discoverReaders` ein Ergebnis zurückgibt, rufen Sie [connectReader](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:delegate:completion:) auf, um eine Verbindung mit dem simulierten Lesegerät herzustellen.

Bei der Verbindung mit einem mobilen Lesegerät oder einem Tap to Pay-Lesegerät muss Ihre Integration die `locationId` in der Verbindungskonfiguration enthalten, und zwar auch für das simulierte Lesegerät. Da das simulierte Lesegerät keinem tatsächlichen Standort zugeordnet werden kann, geben Sie stattdessen die Pseudo-`locationId` des simulierten Lesegeräts an.

```swift
import UIKit
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {

    var discoverCancelable: Cancelable?

    // ...

    // Action for a "Discover Readers" button
    func discoverReadersAction() throws {let config = try BluetoothScanDiscoveryConfigurationBuilder().setSimulated(true).build()
        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
            if let error = error {
                print("discoverReaders failed: \(error)")
            } else {
                print("discoverReaders succeeded")
            }
        }
    }

    // ...

    // MARK: DiscoveryDelegate

    // This delegate method can get called multiple times throughout the discovery process.
    // You might want to update a UITableView and display all available readers.
    // Here, we're automatically connecting to the first reader we discover.
    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {

        // Select the first reader we discover
        guard let selectedReader = readers.first else { return }

        // Since the simulated reader is not associated with a real location, we recommend
        // specifying its existing mock location.
        guard let locationId = selectedReader.locationId else { return }

        // Only connect if we aren't currently connected.
        guard terminal.connectionStatus == .notConnected || terminal.connectionStatus == .discovering else { return }
// Replace 'yourMobileReaderDelegate' with your actual MobileReaderDelegate implementation
        let mobileReaderDelegate = yourMobileReaderDelegate
        do {
            connectionConfig = try BluetoothConnectionConfigurationBuilder(
                // When connecting to a physical reader, your integration should specify either the
                // same location as the last connection (selectedReader.locationId) or a new location
                // of your user's choosing.
                delegate: mobileReaderDelegate,
                locationId: locationId
            )
            .setAutoReconnectOnUnexpectedDisconnect(true) // This is optional as it's the default value
            .build()
        } catch {
            // Handle error building the connection configuration
            return
        }

        // Note `readerDelegate` should be provided by your application.
        // See our Quickstart guide at https://stripe.com/docs/terminal/quickstart
        // for more example code.
        Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in
            if let reader = reader {
                print("Successfully connected to reader: \(reader)")
            } else if let error = error {
                print("connectReader failed: \(error)")
            }
        }
    }
}
```

### Konfiguration von simulierten Lesegeräten

- [SimulatorConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPSimulatorConfiguration.html)

Das simulierte Lesegerät kann in geringem Maße konfiguriert werden, sodass Sie verschiedene Abläufe innerhalb Ihrer Point-of-Sale-Anwendung testen können, z.&nbsp;B. verschiedene Karten oder aber Fehlerszenarien, wie eine abgelehnte Zahlung. Um dieses Verhalten zu aktivieren, verwenden Sie den folgenden Code, bevor Sie Ihre Zahlungsmethode erfassen:

#### Swift

```swift
let simulatorConfiguration = Terminal.shared.simulatorConfiguration
simulatorConfiguration.simulatedCard = SimulatedCard(type: .amex)
simulatorConfiguration.simulatedTipAmount = 1000
```


# Simuliertes Lesegerät

> This is a Simuliertes Lesegerät for when terminal-sdk-platform is android and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=simulated.

Stripe Terminal SDKs und die servergestützte Integration verfügen über ein integriertes simuliertes Kartenlesegerät, sodass Sie Ihre App entwickeln und testen können, ohne eine Verbindung zu physischer Hardware herstellen zu müssen. Mit dem simulierten Lesegerät können Sie alle Terminal-Abläufe in Ihrer App nachbilden, unabhängig davon, ob Ihre Integration abgeschlossen ist oder sich noch im Aufbau befindet.

Das simulierte Lesegerät bietet keine Nutzeroberfläche. Nachdem Sie in Ihrer App eine Verbindung damit hergestellt haben, können Sie sehen, dass es funktioniert, wenn Aufrufe des Stripe SDK oder der API erfolgreich sind.

Simulierte Lesegeräte für SDKs simulieren bei Bedarf automatisch die Kartenpräsentation. Aktualisieren Sie für die serverseitige Integration Ihre Integration auf [Kartenwährung simulieren](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Zur Verwendung des simulierten Lesegeräts rufen Sie [discoverReaders](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) auf, um nach Lesegeräten zu suchen, wobei die Option `isSimulated` in der ausgewählten `DiscoveryConfiguration` auf `true` festgelegt ist. Wenn `discoverReaders` ein Ergebnis zurückgibt, rufen Sie [connectReader](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) auf, um eine Verbindung mit dem simulierten Lesegerät herzustellen.

Wenn Sie eine Verbindung mit einem mobilen Lesegerät herstellen, muss Ihre Integration die `locationId` in der Verbindungskonfiguration enthalten, und zwar auch für das simulierte Lesegerät. Da das simulierte Lesegerät keinem tatsächlichen Standort zugeordnet werden kann, geben Sie stattdessen die Pseudo-`locationId` des simulierten Lesegeräts an.

```kotlin
// Handler for a "Connect Reader" button
fun onConnect() {
    val config = BluetoothDiscoveryConfiguration(timeout = 0, isSimulated = true)

    Terminal.getInstance().discoverReaders(
        config,
        object : DiscoveryListener {
            override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
                // Select the first reader here.
                val firstReader = readers.first()
                // Replace 'yourMobileReaderListener' with your actual MobileReaderListener implementation
                val mobileReaderListener = yourMobileReaderListener
                val autoReconnectOnUnexpectedDisconnect = true

                // When connecting to a physical reader, specify either the
                // same location as the last connection (selectedReader.location?.id) or a new location
                // of your user's choosing.
                //
                // Since the simulated reader isn't associated with a real location, we recommend
                // specifying its existing mock location.
                val connectionConfig = BluetoothConnectionConfiguration(
                    locationId = firstReader.location?.id.orEmpty(),
                    autoReconnectOnUnexpectedDisconnect = autoReconnectOnUnexpectedDisconnect,
                    bluetoothReaderListener = mobileReaderListener
                )

                Terminal.getInstance().connectReader(
                    firstReader,
                    connectionConfig,
                    object : ReaderCallback {
                        override fun onSuccess(reader: Reader) {
                            // Placeholder for handling successful operation
                        }

                        override fun onFailure(e: TerminalException) {
                            // Placeholder for handling exception
                        }
                    }
                )
            }
        },
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}
```

### Konfiguration von simulierten Lesegeräten

- [SimulatorConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-simulator-configuration/index.html)

Das simulierte Lesegerät kann in geringem Maße konfiguriert werden, sodass Sie verschiedene Abläufe innerhalb Ihrer Point-of-Sale-Anwendung testen können, z.&nbsp;B. verschiedene Karten oder aber Fehlerszenarien, wie eine abgelehnte Zahlung. Um dieses Verhalten zu aktivieren, verwenden Sie den folgenden Code, bevor Sie Ihre Zahlungsmethode erfassen:

#### Kotlin

```kotlin
val simulatedFixedTipAmount = 1000L;

val simulatorConfig = SimulatorConfiguration(
    simulatedCard = SimulatedCard(SimulatedCardType.AMEX),
    simulatedTipAmount = simulatedFixedTipAmount
);

Terminal.getInstance().setSimulatorConfiguration(simulatorConfig);
```


# Simuliertes Lesegerät

> This is a Simuliertes Lesegerät for when terminal-sdk-platform is react-native and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=simulated.

Stripe Terminal SDKs und die servergestützte Integration verfügen über ein integriertes simuliertes Kartenlesegerät, sodass Sie Ihre App entwickeln und testen können, ohne eine Verbindung zu physischer Hardware herstellen zu müssen. Mit dem simulierten Lesegerät können Sie alle Terminal-Abläufe in Ihrer App nachbilden, unabhängig davon, ob Ihre Integration abgeschlossen ist oder sich noch im Aufbau befindet.

Das simulierte Lesegerät bietet keine Nutzeroberfläche. Nachdem Sie in Ihrer App eine Verbindung damit hergestellt haben, können Sie sehen, dass es funktioniert, wenn Aufrufe des Stripe SDK oder der API erfolgreich sind.

Simulierte Lesegeräte für SDKs simulieren bei Bedarf automatisch die Kartenpräsentation. Aktualisieren Sie für die serverseitige Integration Ihre Integration auf [Kartenwährung simulieren](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Um das simulierte Lesegerät zu verwenden, rufen Sie [discoverReaders](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) auf, um nach Lesegeräten zu suchen, wobei die Option `simulated` auf `true` festgelegt ist. Wenn der Callback `onUpdateDiscoveredReaders` mit einem Array der Lesegeräte als Argument aufgerufen wird, rufen Sie [connectReader](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) auf, um eine Verbindung zum simulierten Lesegerät herzustellen.

Bei der Verbindung mit einem mobilen Lesegerät oder einem TapToPay-Lesegerät muss Ihre Integration die `locationId` in der Verbindungskonfiguration enthalten, und zwar auch für das simulierte Lesegerät. Da das simulierte Lesegerät keinem tatsächlichen Standort zugeordnet werden kann, geben Sie stattdessen die Pseudo-`locationId` des simulierten Lesegeräts an.

```js
function DiscoverReadersScreen() {
  const { discoverReaders, connectReader, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
        // Here, we're automatically connecting to the first discovered reader.
        handleConnectBluetoothReader(readers[0]);
      },
    });

  useEffect(() => {
    handleDiscoverReaders();
  }, []);

  const handleDiscoverReaders = async () => {
    // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method
    // within the `useStripeTerminal` hook.
    const { error } = await discoverReaders({
      discoveryMethod: 'bluetoothScan',
      simulated: true,
    });

    if (error) {
      Alert.alert(
        'Discover readers error: ',
        `${error.code}, ${error.message}`
      );
    }
  };

  const handleConnectBluetoothReader = async (discoveredReader: Reader.Type) => {
    const { reader, error } = await connectReader({
        reader: discoveredReader,
        // Since the simulated reader is not associated with a real location, we recommend
        // specifying its existing mock location.
        locationId: discoveredReader.locationId,
      },
      'bluetoothScan'
    );

    if (error) {
      console.log('connectReader error', error);
      return;
    }

    console.log('Reader connected successfully', reader);
  };

  return <View />;
}
```

### Konfiguration von simulierten Lesegeräten

- [setSimulatedCard (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#setSimulatedCard)

Das simulierte Lesegerät kann in geringem Maße konfiguriert werden, sodass Sie verschiedene Abläufe innerhalb Ihrer Point-of-Sale-Anwendung testen können, z.&nbsp;B. verschiedene Karten oder aber Fehlerszenarien, wie eine abgelehnte Zahlung. Um dieses Verhalten zu aktivieren, verwenden Sie den folgenden Code, bevor Sie Ihre Zahlungsmethode erfassen:

```js
const { error } = await setSimulatedCard('4242424242424242');

if (error) {
  // Placeholder for handling exception
}

// Placeholder for handling successful operation
```


# Bluetooth-Lesegeräte

> This is a Bluetooth-Lesegeräte for when terminal-sdk-platform is ios and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=bluetooth.

Über Bluetooth verbundene Lesegeräte sind Bluetooth LE-Geräte. Sie erfassen Zahlungsdetails, sind aber für die Kommunikation mit Stripe auf ein gekoppeltes Mobilgerät angewiesen.

Befolgen Sie diese Schritte, um Ihre App über Bluetooth mit einem Terminal-Lesegerät zu verbinden:

1. [Lesegeräte erkennen](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

> Koppeln Sie das Lesegerät nicht über die Einstellungen des mobilen Geräts. Durch Koppeln des Lesegeräts über die Einstellungen des mobilen Geräts wird die Verbindung des Lesegeräts zu Ihrer App verhindert.

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:)
- [BluetoothScanDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPBluetoothScanDiscoveryConfiguration.html)

Stellen Sie zunächst sicher, dass Ihr Lesegerät eingeschaltet ist und sich in unmittelbarer Nähe befindet.

Suchen Sie dann in Ihrer App mit der Methode `discoverReaders` mithilfe von `BluetoothScanDiscoveryConfiguration` nach über Bluetooth verbundenen Lesegeräten in der Nähe.

#### Swift

```swift
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {

    var discoverCancelable: Cancelable?

    // ...

    // Action for a "Discover Readers" button
    func discoverReadersAction() throws {
        let config = try BluetoothScanDiscoveryConfigurationBuilder().build()
        // In addition to Terminal's completion block methods, Swift async alternatives are available.
        // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example
        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
            if let error = error {
                print("discoverReaders failed: \(error)")
            } else {
                print("discoverReaders succeeded")
            }
        }
    }

    // ...

    // MARK: DiscoveryDelegate

    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {
        // In your app, display the discovered readers to the user.
        // Call `connectReader` after the user selects a reader to connect to.
    }
}

```

#### Bluetooth Proximity  * (BBPOS Chipper 2X BT only)

Die Suchergebnisse für Bluetooth-Näherungsfilter zeigen das nächstgelegene Lesegerät an. Wenn das Lesegerät erkannt wird, blinkt es mehrfarbig, sodass Ihre Nutzer/innen das erkannte Lesegerät unter vielen anderen Lesegeräten identifizieren können. Nachdem das SDK ein Lesegerät erkannt hat, wechselt es nicht zu einem näheren Lesegerät, es sei denn, Sie schalten das erkannte Lesegerät aus.

Beachten Sie, dass das SDK bei Verwendung von Bluetooth Proximity das Lesegerät zweimal an den Callback Ihrer Anwendung zurückgibt. Beim ersten Mal erhält Ihre Anwendung ein `Reader`-Objekt, das nur mit der Seriennummer des Lesegeräts vorbefüllt ist. Nach einer kurzen Verzögerung erhält Ihre Anwendung dasselbe `Reader`-Objekt mit neuen Informationen, z.&nbsp;B. dem Akkustand des Lesegeräts.

Wir empfehlen, das erkannte Lesegerät auf der Nutzeroberfläche Ihrer App anzuzeigen, sodass der/die Nutzer/in die Verbindung zum Lesegerät entweder bestätigen oder abbrechen kann, wenn er/sie keine Verbindung zu diesem Lesegerät herstellen möchte.

#### Bluetooth-Scan

Der Bluetooth-Scan sucht nach allen in der Nähe befindlichen Lesegeräten und gibt eine Liste erkannter Lesegeräte an Ihre App zurück. Während des Erkennungsvorgangs ruft das SDK weiterhin die Methode `DiscoveryDelegate.didUpdateDiscoveredReaders` mit der aktuellen Liste von Lesegeräten in der Nähe auf.

Während des Erkennungsvorgangs geht der `SCPConnectionStatus` des Terminals in `SCPConnectionStatus.SCPConnectionStatusDiscovering` über, während die Erkennung ausgeführt wird.

Mit der Bluetooth-Scan-Erkennungsmethode können Sie eine Zeitüberschreitung festlegen, um die Dauer des Scans zu begrenzen. Diese können Sie zur Verwaltung der Akkulaufzeit nutzen oder um eine Fehlermeldung auszulösen, wenn kein Gerät gefunden wird.

Wir empfehlen, in Ihrer mobilen Anwendung eine automatisch aktualisierte Liste der erkannten Lesegeräte mit Seriennummern anzuzeigen, um den Nutzerinnen und Nutzern die Identifizierung ihres mobilen Lesegeräts zu erleichtern. Die Eigenschaft `Label` wird bei mobilen Lesegeräten während der Erkennung nicht ausgefüllt. Wenn Sie benutzerfreundliche Namen für Lesegeräte anzeigen möchten, verwalten Sie bitte Ihre eigene Zuordnung von Seriennummern zu Labels in Ihrer Anwendung.

#### Bluetooth-Kopplung

Um die Sicherheit zu verbessern und die EU-Vorschriften einzuhalten, verwendet Stripe ab November&nbsp;2025 für WisePad 3-Kartenleser den Bluetooth-Kopplungsprozess mit numerischem Vergleich. Bei diesem Verfahren müssen Sie einen Passkey sowohl auf dem Kartenleser als auch auf dem POS-Gerät beim Koppeln überprüfen. Nachdem Sie Ihr Gerät auf die [neueste Softwareversion](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases) aktualisiert haben, befolgen Sie diese Schritte, wenn Sie den WisePad 3 mit einer neuen mobilen Anwendung verbinden. Nachdem Ihr POS-Gerät den WisePad 3 entdeckt und angezeigt hat:

1. Überprüfen Sie, dass der 6-stellige Code sowohl auf dem WisePad&nbsp;3 als auch auf dem POS-Gerät übereinstimmt.
1. Wählen Sie **Bestätigen** auf dem WisePad 3.
1. Bitte wählen Sie auf Ihrem POS-Gerät die Option **Koppeln** aus.

> #### Hinweis
> 
> Sie müssen nur dann eine numerische Vergleichskopplung durchführen, wenn Sie ein WisePad 3 mit einem neuen POS-Gerät koppeln oder wenn Sie eine erneute Kopplung mit einem bestehenden „vergessenen” POS-Gerät vornehmen.

## Mit einem Lesegerät verbinden [Clientseitig]

- [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:)
- [BluetoothConnectionConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPBluetoothConnectionConfiguration.html)

Um eine Verbindung zu einem erkannten Lesegerät herzustellen, rufen Sie die Methode `connectReader` in Ihrer App auf.

Sie müssen Ihr [Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei Einrichtung der Verbindung an einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Dazu erstellen und verwenden Sie eine `BluetoothConnectionConfiguration`, wobei die `locationId` auf die beim Verbindungsaufbau relevante Standort-ID festgelegt wird.

#### Swift

```swift
// Call `connectReader` with the selected reader and a connection config
// to register to a location as set by your app.
let connectionConfig: BluetoothConnectionConfiguration
do {
    connectionConfig = try BluetoothConnectionConfigurationBuilder(delegate: yourMobileReaderDelegate, locationId: ""{{LOCATION_ID}}"")
    .build()
} catch {
    // Handle the error building the connection configuration
    return
}
Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in
    if let reader = reader {
        print("Successfully connected to reader: \(reader)")
    } else if let error = error {
        print("connectReader failed: \(error)")
    }
}
```

Damit Ihre App im Hintergrund ausgeführt wird und mit dem Lesegerät verbunden bleibt, müssen Sie [Ihre App so konfigurieren](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=ios#configure), dass sie den gewünschten Hintergrundmodus enthält.

> #### Standby-Modus verwenden
> 
> Programmieren Sie Ihre App nicht so, dass sie `disconnectReader` aufruft, um Strom zu sparen. Das Lesegerät verwaltet den Strom effizient über seinen Standby-Modus.

## Umgang mit Verbindungsabbrüchen von Lesegeräten

- [MobileReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPMobileReaderDelegate.html)
- [DisconnectReason (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPDisconnectReason.html)

Zwischen Ihrer App und dem Lesegerät kann es manchmal zu Verbindungsabbrüchen kommen. Dies kann zum Beispiel passieren, wenn das Lesegerät zu weit entfernt oder der Akku leer ist. Sie können eine unerwartete Unterbrechung während des Tests simulieren, indem Sie das Lesegerät ausschalten.

`MobileReaderDelegate` enthält die Methode `reader:didDisconnect:`, die Ihrer Anwendung den `DisconnectReason` mitteilt, um herauszufinden, warum das Lesegerät getrennt wurde.

Gehen Sie wie folgt vor, um Verbindungsabbrüche selbst zu handhaben:

1. Setzen Sie `autoReconnectOnUnexpectedDisconnect` während der Verbindungsherstellung auf `false`.
1. Bearbeiten Sie den Rückruf bei Trennung son, dass nur eine Meldung in der App angezeigt wird. Diese weist die Nutzer/innen darauf hin, dass das Lesegerät unerwartet getrennt wurde, und mit der Erkennung und erneuten Verbindung des Lesegeräts begonnen werden kann.

#### Swift

```swift
import StripeTerminal

class ReaderViewController: UIViewController, MobileReaderDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set the reader delegate when connecting to a reader
    }

    // ...



    func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }
}
```

### Verbundenes Lesegerät neu starten

- [rebootReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)rebootReader:.html)

Die Lesegeräte Stripe&nbsp;Reader&nbsp;M2 und BBPOS&nbsp;WisePad&nbsp;3 werden automatisch neugestartet, nachdem sie 24&nbsp;Stunden lang in Betrieb waren. Sie können das Lesegerät jedoch mithilfe der `rebootReader` API zum Neustart zwingen und so diesen 24-Stunden-Rhythmus zurücksetzen. Dabei trennt sich das Lesegerät vom SDK und führt einen Neustart durch. Wenn Sie die automatische Wiederverbindung verwenden, versucht das SDK anschließend, die Verbindung mit dem Lesegerät wiederherzustellen.

#### Swift

```swift
Terminal.shared.rebootReader { error in
    if let error = error {
        // Placeholder for handling the error
    } else {
        // Reboot succeeded and the reader will disconnect.
        // If your app is using automatic reconnect the reconnect will begin.
    }
}

```

#### Automatisch versuchen, die Verbindung wiederherzustellen

Wenn die Verbindung zu einem Lesegerät getrennt wird, versuchen wir standardmäßig automatisch, die Verbindung wiederherzustellen. Wir empfehlen, während des gesamten Vorgangs Benachrichtigungen über den Status des Lesegeräts in Ihrer App anzuzeigen.

Gehen Sie wie folgt vor, um bei der automatischen Wiederverbindung Benachrichtigungen in Ihrer App anzuzeigen:

1. Implementieren Sie die Rückrufe für die Wiederverbindung des Lesegeräts im `MobileReaderDelegate`.
1. Übergeben Sie `MobileReaderDelegate` an Ihre `BluetoothConnectionConfiguration`.
1. Wenn das SDK [`reader:didStartReconnect:disconnectReason:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didStartReconnect:disconnectReason:) an Ihre App sendet, zeigen Sie eine Meldung an, die besagt, dass die Verbindung zum Lesegerät getrennt wurde und die Verbindung erneut wiederhergestellt wird.
   - Sie können den Verbindungsversuch jederzeit mit dem `Cancelable`-Objekt stoppen.
1. Wenn sich das SDK wieder erfolgreich verbunden hat, nachdem [`readerDidSucceedReconnect:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)readerDidSucceedReconnect:) gesendet wurde, zeigen Sie eine Meldung an, die besagt, dass die Verbindung wiederhergestellt wurde und der Betrieb normal fortgesetzt werden kann.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann und sowohl [`readerDidFailReconnect:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)readerDidFailReconnect:) als auch `reader:didDisconnect:` sendet, zeigen Sie eine Meldung an, die besagt, dass die Verbindung unerwartet getrennt wurde.

#### Swift

```swift
import StripeTerminal

extension ReaderViewController: MobileReaderDelegate {
    // MARK: MobileReaderDelegate

    func reader(_ reader: Reader, didStartReconnect cancelable: Cancelable, disconnectReason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    func readerDidSucceedReconnect(_ reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }
    func readerDidFailReconnect(_ reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }
}
```

#### Automatische Wiederverbindung beim Anwendungsstart

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie die Seriennummer an einem dauerhaften Datenspeicherort, z. B. in der [UserDefaults API](https://developer.apple.com/documentation/foundation/userdefaults) (iOS).

1. Wenn Ihre App gestartet wird, überprüfen Sie den dauerhaften Datenspeicherort auf eine gespeicherte Seriennummer. Wenn eines gefunden wird, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, dieses Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Benutzeroberfläche an, um darauf hinzuweisen, dass eine automatische Wiederverbindung stattfindet.

## Lesegerätesoftware aktualisieren [Clientseitig]



- [MobileReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPMobileReaderDelegate.html)

Ihre Anwendung muss mobile Lesegeräte aktualisieren, damit Folgendes angewendet wird:

- Regionale Konfigurationen, die Sie über die Anforderungen des Kartennetzwerks und des Ausstellers auf dem Laufenden halten
- Sicherheitsupdates

Erforderliche Updates werden installiert, wenn eine Verbindung mit dem Lesegerät aufgebaut wurde. Sie können das Lesegerät erst verwenden, wenn die Aktualisierung abgeschlossen ist.

> Um Updates installieren zu können, muss der Akkustand des Lesegeräts höher als 50&nbsp;% sein.

### Erforderliche Aktualisierungen

Wenn für das Lesegerät sofort erforderliche Updates verfügbar sind, erhält der `MobileReaderDelegate` der Integration den Rückruf `didStartInstallingUpdate` mit einem `ReaderSoftwareUpdate`.

Das `ReaderSoftwareUpdate` enthält die notwendigen Details des Updates, einschließlich einer Schätzung der Gesamtdauer des Updates, die von `durationEstimate` angegeben wird.

Während des Installationsvorgangs geht der `connectionStatus` des Terminal in `connecting` über, während das Update auf dem Lesegerät installiert wird.

Ihre Anwendung muss Nutzer/innen darüber benachrichtigen, dass ein Update installiert wird, und den Fortschritt auf Ihrer Nutzeroberfläche anzeigen. Machen Sie deutlich, warum der Verbindungsaufbau länger als gewöhnlich dauern kann.

Wenn der erforderliche Aktualisierungsvorgang fehlschlägt, teilt Stripe den Fehler dem `MobileReaderDelegate` mit `didFinishInstallingUpdate` mit. Sie können sich nach einem fehlgeschlagenen erforderlichen Update nicht wieder mit dem Lesegerät verbinden, es sei denn, die folgenden Bedingungen sind erfüllt:

- Das Lesegerät führt innerhalb der letzten 30 Tage die neueste Softwareversion für den Standort aus.
- Die iOS SDK-Version ist neuer als oder gleich `3.5.0`.

Wenn die Bedingungen erfüllt sind, ist der Verbindungsvorgang trotz unvollständiger Aktualisierung erfolgreich. Stripe wiederholt die erforderliche Aktualisierung, wenn Sie das nächste Mal eine Verbindung zu diesem Lesegerät herstellen, bis es erfolgreich installiert wurde.

#### Swift

```swift
import UIKit
import StripeTerminal

class ReaderViewController: UIViewController, MobileReaderDelegate {

    // ...

    // MARK: MobileReaderDelegate

    func reader(_ reader: Reader, didStartInstallingUpdate update: ReaderSoftwareUpdate, cancelable: Cancelable?) {
        // Show UI communicating that a required update has started installing
    }

    func reader(_ reader: Reader, didReportReaderSoftwareUpdateProgress progress: Float) {
        // Update the progress of the installation
    }

    func reader(_ reader: Reader, didFinishInstallingUpdate update: ReaderSoftwareUpdate?, error: Error?) {
        // Report success or failure of the update
    }

    // ...
}
```

Sie können erforderliche Aktualisierungen mithilfe des Objekts `Cancelable` abbrechen, was ebenfalls zu einer fehlgeschlagenen Verbindung zum Lesegerät führt. Laufende inkrementelle Aktualisierungen können nicht abgebrochen werden.

### Optionale Updates

Sie können optionale Aktualisierungen bis zu dem Datum verschieben, an dem sie erforderlich werden. Das SDK benachrichtigt Sie über den `MobileReaderDelegate` über optionale Aktualisierungen, wenn das Lesegerät verbunden ist, aber keine Transaktion durchführt. Wenn eine optionale Aktualisierung verfügbar ist, empfängt der `MobileReaderDelegate` Ihrer Anwendung den Rückruf `didReportAvailableUpdate` mit dem `ReaderSoftwareUpdate`-Objekt, das die Aktualisierungsdetails enthält, darunter:

- Geschätzte Zeit für den Abschluss der Aktualisierung (`durationEstimate`)
- Zeitstempel, nach dem die Aktualisierung erforderlich wird (`requiredAt`)

Benachrichtigen Sie die Nutzer/innen in Ihrer Anwendung, wenn eine Aktualisierung verfügbar ist, und zeigen Sie eine Aufforderung an, optional mit der Aktualisierung fortzufahren.

Um mit der zuvor mit `didReportAvailableUpdate` gemeldeten Aktualisierung fortzufahren, rufen Sie `Terminal.shared.installAvailableUpdate` auf.

Das verfügbare Update wird auch als `reader.availableUpdate` im Reader-Objekt gespeichert.

Verhindern Sie während der Aktualisierung, dass die Nutzer/innen die Seite in Ihrer App verlassen, und weisen Sie die Nutzer/innen an, das Lesegerät in Reichweite und eingeschaltet zu lassen, bis die Aktualisierung abgeschlossen ist. Wir empfehlen, Ihren Nutzern/Nutzerinnen auch eine visuelle Anzeige des Aktualisierungsfortschritts zur Verfügung zu stellen. `MobileReaderDelegate` meldet den Aktualisierungsfortschritt in der Methode `didReportReaderSoftwareUpdateProgress`.

Wenn das `requiredAt`-Datum einer optionalen Aktualisierung verstrichen ist, wird die Aktualisierung erst installiert, wenn das Lesegerät verbunden wird.

#### Swift

```swift
import UIKit
import StripeTerminal

class ReaderViewController: UIViewController, MobileReaderDelegate {

    // ...

    // MARK: MobileReaderDelegate

    func reader(_ reader: Reader, didReportAvailableUpdate update: ReaderSoftwareUpdate) {
        // An update is available for the connected reader. Show this update in your application.
        // Install this update using `Terminal.shared.installAvailableUpdate`.
    }

}
```

Unter [Aktualisierungen für Lesegeräte testen](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates) erfahren Sie, wie Sie sicherstellen können, dass Ihre Anwendung die verschiedenen Aktualisierungstypen für ein Lesegerät verarbeiten kann.


# Bluetooth-Lesegeräte

> This is a Bluetooth-Lesegeräte for when terminal-sdk-platform is android and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=bluetooth.

Über Bluetooth verbundene Lesegeräte sind Bluetooth LE-Geräte. Sie erfassen Zahlungsdetails, sind aber für die Kommunikation mit Stripe auf ein gekoppeltes Mobilgerät angewiesen.

Befolgen Sie diese Schritte, um Ihre App über Bluetooth mit einem Terminal-Lesegerät zu verbinden:

1. [Lesegeräte erkennen](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

> Koppeln Sie das Lesegerät nicht über die Einstellungen des mobilen Geräts. Durch Koppeln des Lesegeräts über die Einstellungen des mobilen Geräts wird die Verbindung des Lesegeräts zu Ihrer App verhindert.

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [BluetoothDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-bluetooth-discovery-configuration/index.html)

Stellen Sie zunächst sicher, dass Ihr Lesegerät eingeschaltet ist und sich in unmittelbarer Nähe befindet.

Suchen Sie dann in Ihrer App mit der Methode `discoverReaders` mithilfe von `BluetoothDiscoveryConfiguration` nach über Bluetooth verbundenen Lesegeräten in der Nähe.

#### Kotlin

```kotlin
class DiscoverReadersActivity : AppCompatActivity(), DiscoveryListener {

    var discoverCancelable: Cancelable? = null

    // ...

    // Action for a "Discover Readers" button
    fun discoverReadersAction() {
        val timeout = 0
        val isSimulated = false

        val config = BluetoothDiscoveryConfiguration(
            timeout = timeout,
            isSimulated = isSimulated
        )

        discoverCancelable = Terminal.getInstance().discoverReaders(
            config,
            this,
            object : Callback {
                override fun onSuccess() {
                    // Placeholder for handling successful operation
                }

                override fun onFailure(e: TerminalException) {
                    // Placeholder for handling exception
                }
            }
        )
    }

    // DiscoveryListener
    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
        // In your app, display the discovered readers to the user.
        // Call `connectReader` after the user selects a reader to connect to.
    }
}
```

#### Bluetooth-Scan

Der Bluetooth-Scan sucht nach allen in der Nähe befindlichen Lesegeräten und gibt eine Liste erkannter Lesegeräte an Ihre App zurück. Während des Erkennungsvorgangs ruft das SDK weiterhin die Methode `onUpdateDiscoveredReaders` mit der aktuellen Liste von Lesegeräten in der Nähe auf.

Während des Erkennungsvorgangs geht der `connectionStatus` des Terminals in `ConnectionStatus.DISCOVERING` über, während die Erkennung ausgeführt wird.

Mit der Bluetooth-Scan-Erkennungsmethode können Sie eine Zeitüberschreitung festlegen, um die Dauer des Scans zu begrenzen. Diese können Sie zur Verwaltung der Akkulaufzeit nutzen oder um eine Fehlermeldung auszulösen, wenn kein Gerät gefunden wird.

Wir empfehlen, in Ihrer mobilen Anwendung eine automatisch aktualisierte Liste der erkannten Lesegeräte mit Seriennummern anzuzeigen, um den Nutzerinnen und Nutzern die Identifizierung ihres mobilen Lesegeräts zu erleichtern. Die Eigenschaft `Label` wird bei mobilen Lesegeräten während der Erkennung nicht ausgefüllt. Wenn Sie benutzerfreundliche Namen für Lesegeräte anzeigen möchten, verwalten Sie bitte Ihre eigene Zuordnung von Seriennummern zu Labels in Ihrer Anwendung.

#### Bluetooth-Kopplung

Um die Sicherheit zu verbessern und die EU-Vorschriften einzuhalten, verwendet Stripe ab November&nbsp;2025 für WisePad 3-Kartenleser den Bluetooth-Kopplungsprozess mit numerischem Vergleich. Bei diesem Verfahren müssen Sie einen Passkey sowohl auf dem Kartenleser als auch auf dem POS-Gerät beim Koppeln überprüfen. Nachdem Sie Ihr Gerät auf die [neueste Softwareversion](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases) aktualisiert haben, befolgen Sie diese Schritte, wenn Sie den WisePad 3 mit einer neuen mobilen Anwendung verbinden. Nachdem Ihr POS-Gerät den WisePad 3 entdeckt und angezeigt hat:

1. Überprüfen Sie, dass der 6-stellige Code sowohl auf dem WisePad&nbsp;3 als auch auf dem POS-Gerät übereinstimmt.
1. Wählen Sie **Bestätigen** auf dem WisePad 3.
1. Bitte wählen Sie auf Ihrem POS-Gerät die Option **Koppeln** aus.

> #### Hinweis
> 
> Sie müssen nur dann eine numerische Vergleichskopplung durchführen, wenn Sie ein WisePad 3 mit einem neuen POS-Gerät koppeln oder wenn Sie eine erneute Kopplung mit einem bestehenden „vergessenen” POS-Gerät vornehmen.

## Mit einem Lesegerät verbinden [Clientseitig]

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [BluetoothConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-bluetooth-connection-configuration/index.html)

Um eine Verbindung zu einem erkannten Lesegerät herzustellen, rufen Sie die Methode `connectReader` in Ihrer App auf.

Sie müssen Ihr [Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei Einrichtung der Verbindung an einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Dazu erstellen und verwenden Sie eine `BluetoothConnectionConfiguration`, wobei die `locationId` auf die beim Verbindungsaufbau relevante Standort-ID festgelegt wird.

#### Kotlin

```kotlin
// Implement your MobileReaderListener
val mobileReaderListener = yourMobileReaderListener
val autoReconnectOnUnexpectedDisconnect = true

val connectionConfig = BluetoothConnectionConfiguration(
    ""{{LOCATION_ID}}"",
    autoReconnectOnUnexpectedDisconnect,
    mobileReaderListener
)

Terminal.getInstance().connectReader(
    selectedReader,
    connectionConfig,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

> #### Standby-Modus verwenden
> 
> Programmieren Sie Ihre App nicht so, dass sie `disconnectReader` aufruft, um Strom zu sparen. Das Lesegerät verwaltet den Strom effizient über seinen Standby-Modus.

## Umgang mit Verbindungsabbrüchen von Lesegeräten

- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)
- [DisconnectReason (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-disconnect-reason/index.html)

Zwischen Ihrer App und dem Lesegerät kann es manchmal zu Verbindungsabbrüchen kommen. Dies kann zum Beispiel passieren, wenn das Lesegerät zu weit entfernt oder der Akku leer ist. Sie können eine unerwartete Unterbrechung während des Tests simulieren, indem Sie das Lesegerät ausschalten.

Der `MobileReaderListener` enthält einen `onDisconnect`-Rückruf, der Ihrer Anwendung den `DisconnectReason` mitteilt, um herauszufinden, warum das Lesegerät getrennt wurde.

Gehen Sie wie folgt vor, um Verbindungsabbrüche selbst zu handhaben:

1. Setzen Sie `autoReconnectOnUnexpectedDisconnect` während der Verbindungsherstellung auf `false`.
1. Bearbeiten Sie den Rückruf bei Trennung son, dass nur eine Meldung in der App angezeigt wird. Diese weist die Nutzer/innen darauf hin, dass das Lesegerät unerwartet getrennt wurde, und mit der Erkennung und erneuten Verbindung des Lesegeräts begonnen werden kann.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Verbundenes Lesegerät neu starten

- [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html)

Die Lesegeräte Stripe&nbsp;Reader&nbsp;M2 und BBPOS&nbsp;WisePad&nbsp;3 werden automatisch neugestartet, nachdem sie 24&nbsp;Stunden lang in Betrieb waren. Sie können das Lesegerät jedoch mithilfe der `rebootReader` API zum Neustart zwingen und so diesen 24-Stunden-Rhythmus zurücksetzen. Dabei trennt sich das Lesegerät vom SDK und führt einen Neustart durch. Wenn Sie die automatische Wiederverbindung verwenden, versucht das SDK anschließend, die Verbindung mit dem Lesegerät wiederherzustellen.

#### Kotlin

```kotlin
Terminal.getInstance().rebootReader(
    object : Callback {
        override fun onSuccess() {
            // Reboot succeeded and the reader will disconnect.
            // If your app is using automatic reconnect the reconnect will begin.
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

#### Automatisch versuchen, die Verbindung wiederherzustellen

Wenn die Verbindung zu einem Lesegerät getrennt wird, versuchen wir standardmäßig automatisch, die Verbindung wiederherzustellen. Wir empfehlen, während des gesamten Vorgangs Benachrichtigungen über den Status des Lesegeräts in Ihrer App anzuzeigen.

Gehen Sie wie folgt vor, um bei der automatischen Wiederverbindung Benachrichtigungen in Ihrer App anzuzeigen:

1. Implementieren Sie die Rückrufe für die Wiederverbindung des Lesegeräts im `MobileReaderListener`.
1. Übergeben Sie den `MobileReaderListener` an Ihre `BluetoothConnectionConfiguration`.
1. Wenn das SDK [onReaderReconnectStarted](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-started.html) an Ihre App sendet, zeigen Sie eine Meldung an, die besagt, dass die Verbindung zum Lesegerät getrennt wurde und eine erneute Herstellung der Verbindung durchgeführt wird.
   - Sie können den Verbindungsversuch jederzeit mit dem `Cancelable`-Objekt stoppen.
1. Wenn sich das SDK wieder erfolgreich verbunden hat, nachdem [`onReaderReconnectSucceeded`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-succeeded.html) gesendet wurde, zeigen Sie eine Meldung an, die besagt, dass die Verbindung wiederhergestellt wurde und der Betrieb normal fortgesetzt werden kann.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann und sowohl [`onReaderReconnectFailed`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-failed.html) als auch `onDisconnect` sendet, zeigen Sie eine Meldung an, die besagt, dass die Verbindung unerwartet getrennt wurde.

#### Kotlin

```kotlin
class CustomMobileReaderListener : MobileReaderListener {
    // ...

    override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    override fun onReaderReconnectSucceeded(reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }

    override fun onReaderReconnectFailed(reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }

    // ...
}
```

#### Automatische Wiederverbindung beim Anwendungsstart

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie dessen Seriennummer an einem dauerhaften Datenspeicherort wie beispielsweise der [Shared Preferences API](https://developer.android.com/training/data-storage/shared-preferences) (Android).

1. Wenn Ihre App gestartet wird, überprüfen Sie den dauerhaften Datenspeicherort auf eine gespeicherte Seriennummer. Wenn eines gefunden wird, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, dieses Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Benutzeroberfläche an, um darauf hinzuweisen, dass eine automatische Wiederverbindung stattfindet.

## Lesegerätesoftware aktualisieren [Clientseitig]



- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)

Ihre Anwendung muss mobile Lesegeräte aktualisieren, damit Folgendes angewendet wird:

- Regionale Konfigurationen, die Sie über die Anforderungen des Kartennetzwerks und des Ausstellers auf dem Laufenden halten
- Sicherheitsupdates

Erforderliche Updates werden installiert, wenn eine Verbindung mit dem Lesegerät aufgebaut wurde. Sie können das Lesegerät erst verwenden, wenn die Aktualisierung abgeschlossen ist.

> Um Updates installieren zu können, muss der Akkustand des Lesegeräts höher als 50&nbsp;% sein.

### Erforderliche Aktualisierungen

Wenn für das Lesegerät sofort erforderliche Updates verfügbar sind, erhält der `MobileReaderListener` der Integration `onStartInstallingUpdate` mit einem `ReaderSoftwareUpdate`.

Das `ReaderSoftwareUpdate` enthält die notwendigen Details des Updates, einschließlich einer Schätzung der Gesamtdauer des Updates, die von `durationEstimate` angegeben wird.

Während des Installationsvorgangs geht der `connectionStatus` des Terminal in `ConnectionStatus.CONNECTING` über, während das Update auf dem Lesegerät installiert wird.

Ihre Anwendung muss Nutzer/innen darüber benachrichtigen, dass ein Update installiert wird, und den Fortschritt auf Ihrer Nutzeroberfläche anzeigen. Machen Sie deutlich, warum der Verbindungsaufbau länger als gewöhnlich dauern kann.

Wenn der erforderliche Aktualisierungsprozess fehlschlägt, teilt Stripe den Fehler dem `MobileReaderListener` mit `onFinishInstallingUpdate` mit. Sie können sich nach einem fehlgeschlagenen erforderlichen Update nicht wieder mit dem Lesegerät verbinden, es sei denn, die folgenden Bedingungen sind erfüllt:

- Das Lesegerät führt innerhalb der letzten 30 Tage die neueste Softwareversion für den Standort aus.
- Die Android SDK-Version ist neuer als oder gleich `3.5.0`.

Wenn die Bedingungen erfüllt sind, ist der Verbindungsvorgang trotz unvollständiger Aktualisierung erfolgreich. Stripe wiederholt die erforderliche Aktualisierung, wenn Sie das nächste Mal eine Verbindung zu diesem Lesegerät herstellen, bis es erfolgreich installiert wurde.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onStartInstallingUpdate(update: ReaderSoftwareUpdate, cancelable: Cancelable) {
        // Show UI communicating that a required update has started installing
    }

    override fun onReportReaderSoftwareUpdateProgress(progress: Float) {
        // Update the progress of the installation
    }

    override fun onFinishInstallingUpdate(update: ReaderSoftwareUpdate?, e: TerminalException?) {
        // Report success or failure of the update
    }

    // ...
}
```

Sie können erforderliche Aktualisierungen mithilfe des Objekts `Cancelable` abbrechen, was ebenfalls zu einer fehlgeschlagenen Verbindung zum Lesegerät führt. Laufende inkrementelle Aktualisierungen können nicht abgebrochen werden.

### Optionale Updates

Sie können optionale Aktualisierungen bis zu dem Datum verschieben, an dem sie erforderlich werden. Das SDK benachrichtigt Sie über den `MobileReaderListener` jedes Mal über optionale Aktualisierungen, wenn das Lesegerät verbunden ist, aber keine Transaktion durchführt. Wenn eine optionale Aktualisierung verfügbar ist, empfängt der `MobileReaderListener` Ihrer Anwendung den Rückruf `onReportAvailableUpdate` mit dem `ReaderSoftwareUpdate`-Objekt, das die Aktualisierungsdetails enthält, darunter:

- Geschätzte Zeit für den Abschluss der Aktualisierung (`durationEstimate`)
- Datum, nach dem die Aktualisierung erforderlich wird (`requiredAt`)

Benachrichtigen Sie die Nutzer/innen in Ihrer Anwendung, wenn eine Aktualisierung verfügbar ist, und zeigen Sie eine Aufforderung an, optional mit der Aktualisierung fortzufahren.

Um mit der zuvor mit `onReportAvailableUpdate` gemeldeten Aktualisierung fortzufahren, rufen Sie `Terminal.getInstance().installAvailableUpdate` auf.

Das verfügbare Update wird auch als `reader.availableUpdate` im Reader-Objekt gespeichert.

Verhindern Sie während der Aktualisierung, dass die Nutzer/innen die Seite in Ihrer App verlassen, und weisen Sie die Nutzer/innen an, das Lesegerät in Reichweite und eingeschaltet zu lassen, bis die Aktualisierung abgeschlossen ist. Wir empfehlen, Ihren Nutzern/Nutzerinnen auch eine visuelle Anzeige des Aktualisierungsfortschritts zur Verfügung zu stellen. Der `MobileReaderListener` meldet den Fortschritt der Aktualisierung in der Methode `onReportReaderSoftwareUpdateProgress`.

Wenn das `requiredAt`-Datum einer optionalen Aktualisierung verstrichen ist, wird die Aktualisierung erst installiert, wenn das Lesegerät verbunden wird.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onReportAvailableUpdate(update: ReaderSoftwareUpdate) {
        // An update is available for the connected reader. Show this update in your application.
        // Install this update using `Terminal.getInstance().installAvailableUpdate`.
    }

    // ...
}
```

Unter [Aktualisierungen für Lesegeräte testen](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates) erfahren Sie, wie Sie sicherstellen können, dass Ihre Anwendung die verschiedenen Aktualisierungstypen für ein Lesegerät verarbeiten kann.


# Bluetooth-Lesegeräte

> This is a Bluetooth-Lesegeräte for when terminal-sdk-platform is react-native and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=bluetooth.

Über Bluetooth verbundene Lesegeräte sind Bluetooth LE-Geräte. Sie erfassen Zahlungsdetails, sind aber für die Kommunikation mit Stripe auf ein gekoppeltes Mobilgerät angewiesen.

Befolgen Sie diese Schritte, um Ihre App über Bluetooth mit einem Terminal-Lesegerät zu verbinden:

1. [Lesegeräte erkennen](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

> Koppeln Sie das Lesegerät nicht über die Einstellungen des mobilen Geräts. Durch Koppeln des Lesegeräts über die Einstellungen des mobilen Geräts wird die Verbindung des Lesegeräts zu Ihrer App verhindert.

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders)

Stellen Sie zunächst sicher, dass Ihr Lesegerät eingeschaltet ist und sich in unmittelbarer Nähe befindet.

Suchen Sie dann in Ihrer App mit der Methode `discoverReaders` nach über Bluetooth verbundenen Lesegeräten in der Nähe und legen Sie `discoveryMethod` auf `bluetoothScan` fest.

```js
function DiscoverReadersScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
      },
    });

  useEffect(() => {
    handleDiscoverReaders();
  }, [discoverReaders]);

  const handleDiscoverReaders = async () => {
    // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method
    // within the `useStripeTerminal` hook.
    const { error } = await discoverReaders({
      discoveryMethod: 'bluetoothScan',
    });

    if (error) {
      Alert.alert(
        'Discover readers error: ',
        `${error.code}, ${error.message}`
      );
    }
  };

  return <View />;
}
```

#### Bluetooth-Scan

Der Bluetooth-Scan sucht nach allen in der Nähe befindlichen Lesegeräten und gibt eine Liste erkannter Lesegeräte an Ihre App zurück. Während des Erkennungsvorgangs ruft das SDK weiterhin `onUpdateDiscoveredReaders` innerhalb des `useStripeTerminal`-Hook mit der aktuellen Liste von Lesegeräten in der Nähe auf.

Mit der Bluetooth-Scan-Erkennungsmethode können Sie eine Zeitüberschreitung festlegen, um die Dauer des Scans zu begrenzen. Diese können Sie zur Verwaltung der Akkulaufzeit nutzen oder um eine Fehlermeldung auszulösen, wenn kein Gerät gefunden wird.

Wir empfehlen, in Ihrer mobilen Anwendung eine automatisch aktualisierte Liste der erkannten Lesegeräte mit Seriennummern anzuzeigen, um den Nutzerinnen und Nutzern die Identifizierung ihres mobilen Lesegeräts zu erleichtern. Die Eigenschaft `Label` wird bei mobilen Lesegeräten während der Erkennung nicht ausgefüllt. Wenn Sie benutzerfreundliche Namen für Lesegeräte anzeigen möchten, verwalten Sie bitte Ihre eigene Zuordnung von Seriennummern zu Labels in Ihrer Anwendung.

#### Bluetooth-Kopplung

Um die Sicherheit zu verbessern und die EU-Vorschriften einzuhalten, verwendet Stripe ab November&nbsp;2025 für WisePad 3-Kartenleser den Bluetooth-Kopplungsprozess mit numerischem Vergleich. Bei diesem Verfahren müssen Sie einen Passkey sowohl auf dem Kartenleser als auch auf dem POS-Gerät beim Koppeln überprüfen. Nachdem Sie Ihr Gerät auf die [neueste Softwareversion](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases) aktualisiert haben, befolgen Sie diese Schritte, wenn Sie den WisePad 3 mit einer neuen mobilen Anwendung verbinden. Nachdem Ihr POS-Gerät den WisePad 3 entdeckt und angezeigt hat:

1. Überprüfen Sie, dass der 6-stellige Code sowohl auf dem WisePad&nbsp;3 als auch auf dem POS-Gerät übereinstimmt.
1. Wählen Sie **Bestätigen** auf dem WisePad 3.
1. Bitte wählen Sie auf Ihrem POS-Gerät die Option **Koppeln** aus.

> #### Hinweis
> 
> Sie müssen nur dann eine numerische Vergleichskopplung durchführen, wenn Sie ein WisePad 3 mit einem neuen POS-Gerät koppeln oder wenn Sie eine erneute Kopplung mit einem bestehenden „vergessenen” POS-Gerät vornehmen.

## Mit einem Lesegerät verbinden [Clientseitig]

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)

Um eine Verbindung zu einem erkannten Lesegerät herzustellen, rufen Sie die Methode `connectReader` in Ihrer App auf.

Sie müssen Ihr [Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei der Herstellung der Verbindung mit einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Stellen Sie dazu sicher, dass `locationId` auf die beim Verbindungsaufbau relevante Standort-ID festgelegt ist.

```js
const handleConnectBluetoothReader = async (id) => {
  const { reader, error } = await connectReader(
    {
      reader: selectedReader,
      locationId: {{LOCATION_ID}},
    },
    'bluetoothScan'
  );

  if (error) {
    console.log('connectReader error', error);
    return;
  }

  console.log('Reader connected successfully', reader);
};
```

> #### Standby-Modus verwenden
> 
> Programmieren Sie Ihre App nicht so, dass sie `disconnectReader` aufruft, um Strom zu sparen. Das Lesegerät verwaltet den Strom effizient über seinen Standby-Modus.

## Umgang mit Verbindungsabbrüchen von Lesegeräten

- [REPORT_UNEXPECTED_READER_DISCONNECT (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT)
- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)
- [DisconnectReason (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.html#DisconnectReason)

Zwischen Ihrer App und dem Lesegerät kann es manchmal zu Verbindungsabbrüchen kommen. Dies kann zum Beispiel passieren, wenn das Lesegerät zu weit entfernt oder der Akku leer ist. Sie können eine unerwartete Unterbrechung während des Tests simulieren, indem Sie das Lesegerät ausschalten.

`UserCallbacks` enthält die Information `onDidDisconnect`, die Ihrer Anwendung den `DisconnectReason` mitteilt, um herauszufinden, warum das Lesegerät getrennt wurde.

Gehen Sie wie folgt vor, um Verbindungsabbrüche selbst zu handhaben:

1. Setzen Sie `autoReconnectOnUnexpectedDisconnect` während der Verbindungsherstellung auf `false`.
1. Bearbeiten Sie den Rückruf bei Trennung son, dass nur eine Meldung in der App angezeigt wird. Diese weist die Nutzer/innen darauf hin, dass das Lesegerät unerwartet getrennt wurde, und mit der Erkennung und erneuten Verbindung des Lesegeräts begonnen werden kann.

```js
const terminal = useStripeTerminal({
  onDidDisconnect: (result) => {
    // Consider displaying a UI to notify the user and start rediscovering readers
  },
});
```

### Verbundenes Lesegerät neu starten

- [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader)

Die Lesegeräte Stripe&nbsp;Reader&nbsp;M2 und BBPOS&nbsp;WisePad&nbsp;3 werden automatisch neugestartet, nachdem sie 24&nbsp;Stunden lang in Betrieb waren. Sie können das Lesegerät jedoch mithilfe der `rebootReader` API zum Neustart zwingen und so diesen 24-Stunden-Rhythmus zurücksetzen. Dabei trennt sich das Lesegerät vom SDK und führt einen Neustart durch. Wenn Sie die automatische Wiederverbindung verwenden, versucht das SDK anschließend, die Verbindung mit dem Lesegerät wiederherzustellen.

```js
const { error } = await rebootReader();

if (error) {
  console.log('rebootReader error:', error);
  return;
}

console.log('rebootReader succeeded');
```

#### Automatisch versuchen, die Verbindung wiederherzustellen

Wenn die Verbindung zu einem Lesegerät getrennt wird, versuchen wir standardmäßig automatisch, die Verbindung wiederherzustellen. Wir empfehlen, während des gesamten Vorgangs Benachrichtigungen über den Status des Lesegeräts in Ihrer App anzuzeigen.

Gehen Sie wie folgt vor, um bei der automatischen Wiederverbindung Benachrichtigungen in Ihrer App anzuzeigen:

1. Legen Sie `autoReconnectOnUnexpectedDisconnect` für `ConnectBluetoothReaderParams` auf „true“ fest.
1. Implementieren Sie die Rückrufe für die automatische Wiederverbindung, die in den `UserCallbacks` gefunden wurden.
1. Wenn das SDK `onDidStartReaderReconnect` an Ihre App sendet, zeigen Sie eine Meldung an, dass die Verbindung zum Lesegerät unterbrochen wurde und eine erneute Verbindung durchgeführt wird.
   - Sie können den Verbindungsversuch jederzeit mit `cancelReaderReconnection` stoppen.
1. Wenn sich das SDK wieder erfolgreich verbunden hat, nachdem `onDidSucceedReaderReconnect` gesendet wurde, zeigen Sie eine Meldung an, dass die Verbindung wiederhergestellt wurde und der Betrieb normal fortgesetzt werden kann.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann und und `onDidFailReaderReconnect` sendet, zeigen Sie eine Meldung an, dass die Verbindung unerwartet getrennt wurde.

#### Automatische Wiederverbindung beim Anwendungsstart

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie dessen Seriennummer an einem dauerhaften Datenspeicherort wie beispielsweise [Async Storage](https://github.com/react-native-async-storage/async-storage) (React Native).

1. Wenn Ihre App gestartet wird, überprüfen Sie den dauerhaften Datenspeicherort auf eine gespeicherte Seriennummer. Wenn eines gefunden wird, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, dieses Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Benutzeroberfläche an, um darauf hinzuweisen, dass eine automatische Wiederverbindung stattfindet.

## Lesegerätesoftware aktualisieren [Clientseitig]



- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)

Ihre Anwendung muss mobile Lesegeräte aktualisieren, damit Folgendes angewendet wird:

- Regionale Konfigurationen, die Sie über die Anforderungen des Kartennetzwerks und des Ausstellers auf dem Laufenden halten
- Sicherheitsupdates

Erforderliche Updates werden installiert, wenn eine Verbindung mit dem Lesegerät aufgebaut wurde. Sie können das Lesegerät erst verwenden, wenn die Aktualisierung abgeschlossen ist.

> Um Updates installieren zu können, muss der Akkustand des Lesegeräts höher als 50&nbsp;% sein.

### Erforderliche Aktualisierungen

Wenn für das Lesegerät sofort erforderliche Updates verfügbar sind, erhält die Integration `onDidStartInstallingUpdate` vom `useStripeTerminal`-Hook mit einem `Reader.SoftwareUpdate`.

Das `Reader.SoftwareUpdate` enthält die erforderlichen Details des Updates, einschließlich einer Schätzung der Gesamtdauer des Updates, die von `estimatedUpdateTime` angegeben wird.

Während des Installationsvorgangs geht der `connectionStatus` des Terminal auf `"connecting"` über, während das Update auf dem Lesegerät installiert wird.

Ihre Anwendung muss Nutzer/innen darüber benachrichtigen, dass ein Update installiert wird, und den Fortschritt auf Ihrer Nutzeroberfläche anzeigen. Machen Sie deutlich, warum der Verbindungsaufbau länger als gewöhnlich dauern kann.

Wenn der erforderliche Aktualisierungsprozess fehlschlägt, teilt Stripe den Fehler dem `useStripeTerminal`-Hook mit `onDidFinishInstallingUpdate` mit. Sie können sich nach einem fehlgeschlagenen erforderlichen Update nicht wieder mit dem Lesegerät verbinden, es sei denn, die folgenden Bedingungen sind erfüllt:

- Das Lesegerät führt innerhalb der letzten 30 Tage die neueste Softwareversion für den Standort aus.
- Die React Native SDK-Version ist neuer als oder gleich `0.0.1-beta.18`.

Wenn die Bedingungen erfüllt sind, ist der Verbindungsvorgang trotz unvollständiger Aktualisierung erfolgreich. Stripe wiederholt die erforderliche Aktualisierung, wenn Sie das nächste Mal eine Verbindung zu diesem Lesegerät herstellen, bis es erfolgreich installiert wurde.

```js
const terminal = useStripeTerminal({
  onDidReportReaderSoftwareUpdateProgress: (progress) => {
    setCurrentProgress((Number(progress) * 100).toFixed(0).toString());
  },
  onDidFinishInstallingUpdate: ({ error }) => {
  },
  onDidStartInstallingUpdate: (update) => {
  },
});
```

Sie können erforderliche Updates mithilfe der API `cancelInstallingUpdate` abbrechen, was ebenfalls zu einer fehlgeschlagenen Verbindung zum Lesegerät führt. Laufende inkrementelle Updates können nicht abgebrochen werden.

### Optionale Updates

Sie können optionale Aktualisierungen bis zu dem Datum verschieben, an dem sie erforderlich werden. Das SDK benachrichtigt Sie immer über den Rückruf `onDidReportAvailableUpdate` des `useStripeTerminal`-Hooks über optionale Aktualisierungen, wenn das Lesegerät verbunden ist, aber keine Transaktion durchführt. Wenn eine optionale Aktualisierung verfügbar ist, empfängt der `useStripeTerminal`-Hook Ihrer Anwendung den Rückruf `onDidReportAvailableUpdate` mit dem `SoftwareUpdate`-Objekt, das die Aktualisierungsdetails enthält, einschließlich:

- Geschätzte Zeit für den Abschluss der Aktualisierung (`estimatedUpdateTime`)
- Datum, nach dem die Aktualisierung erforderlich wird (`requiredAt`)

Benachrichtigen Sie die Nutzer/innen in Ihrer Anwendung, wenn eine Aktualisierung verfügbar ist, und zeigen Sie eine Aufforderung an, optional mit der Aktualisierung fortzufahren.

Um mit der zuvor mit `onDidReportAvailableUpdate` gemeldeten Aktualisierung fortzufahren, rufen Sie `installAvailableUpdate` über den `useStripeTerminal`-Hook auf.

Das verfügbare Update wird auch als `reader.availableUpdate` im Reader-Objekt gespeichert.

Verhindern Sie während der Aktualisierung, dass die Nutzer/innen die Seite in Ihrer App verlassen, und weisen Sie die Nutzer/innen an, das Lesegerät in Reichweite und eingeschaltet zu lassen, bis die Aktualisierung abgeschlossen ist. Wir empfehlen, Ihren Nutzern/Nutzerinnen auch eine visuelle Anzeige des Aktualisierungsfortschritts zur Verfügung zu stellen. Der Hook `useStripeTerminal` meldet den Aktualisierungsfortschritt in der Methode `onDidReportReaderSoftwareUpdateProgress`.

Wenn das `requiredAt`-Datum einer optionalen Aktualisierung verstrichen ist, wird die Aktualisierung erst installiert, wenn das Lesegerät verbunden wird.

```js
const terminal = useStripeTerminal({
  onDidReportAvailableUpdate: (update) => {
    // An update is available for the connected reader. Show this update in your application.
    // Install this update using the `installAvailableUpdate` method from the `useStripeTerminal` hook.
  },
});
```

Unter [Aktualisierungen für Lesegeräte testen](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates) erfahren Sie, wie Sie sicherstellen können, dass Ihre Anwendung die verschiedenen Aktualisierungstypen für ein Lesegerät verarbeiten kann.


# USB-Lesegeräte

> This is a USB-Lesegeräte for when terminal-sdk-platform is android and reader-type is usb. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=usb.

Verwenden Sie Stripe Terminal Android SDK 3.0.0  (oder höher), um USB-Verbindungen für den [Stripe Reader M2](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) und die [BBPOS WisePad&nbsp;3](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepad3.md)-Lesegeräte zu unterstützen.

Sie müssen ein USB-Kabel verwenden, das sowohl Datenübertragung als auch Aufladen unterstützt, wie das USB&nbsp;2.0-Kabel, das im Lieferumfang des Stripe Reader&nbsp;M2 und des BBPOS WisePad&nbsp;3 enthalten ist. Wenn das mit Ihrem Terminal-Lesegerät gelieferte Kabel nur zum Aufladen geeignet ist, verwenden Sie ein USB 2.0-Kabel eines Drittanbieters, das Daten übertragen kann.

So verbinden Sie Ihre App per USB-Kabel mit einem Datenterminal:

1. [Lesegeräte erkennen](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

## Lesegeräte entdecken [Client-seitig]

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [UsbDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-usb-discovery-configuration/index.html)

Stellen Sie sicher, dass das Lesegerät eingeschaltet und über ein USB&nbsp;2.0-Kabel mit dem Gerät verbunden ist, auf dem Ihre App ausgeführt wird, und dass die Berechtigung zum Zugriff auf das über USB verbundene Lesegerät erteilt wurde.

Wenn Sie das Lesegerät zum ersten Mal anschließen, wird eine Aufforderung des Android-Systems angezeigt, eine Verbindung zum Lesegerät herzustellen. Sie können das Kontrollkästchen „Immer geöffnet“ aktivieren, um Ihre App ohne Nachfrage zu öffnen, wenn sie mit einem Lesegerät verbunden ist.

Suchen Sie dann in Ihrer App mit der Methode `discoverReaders` nach dem verbundenen Lesegerät, indem Sie  `UsbDiscoveryConfiguration` verwenden.

#### Kotlin

```kotlin
class DiscoverReadersActivity : AppCompatActivity(), DiscoveryListener {
    // ...

    var discoverCancelable: Cancelable? = null

    // Action for a "Discover Readers" button
    fun discoverReadersAction() {
        val timeout = 0
        val isSimulated = false

        val config = UsbDiscoveryConfiguration(
            timeout = timeout,
            isSimulated = isSimulated
        )

        Terminal.getInstance().discoverReaders(
            config,
            this,
            object : Callback {
                override fun onSuccess() {
                    // Placeholder for handling successful operation
                }

                override fun onFailure(e: TerminalException) {
                    // Placeholder for handling exception
                }
            }
        )
    }

    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
        // In your app, display the discovered readers to the user.
        // Call `connectReader` after the user selects a reader to connect to.
    }

    // ...
}
```

## Mit einem Lesegerät verbinden [Client-seitig]

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [UsbConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-usb-connection-configuration/index.html)

Um eine Verbindung zu einem erkannten Lesegerät herzustellen, rufen Sie die Methode `connectReader` in Ihrer App auf.

Sie müssen Ihr [Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei der Herstellung der Verbindung bei einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Übergeben Sie dazu  und erstellen bzw. verwenden Sie eine `UsbConnectionConfiguration`, wobei die `locationId` beim Verbindungsaufbau auf die entsprechende Standort-ID  festgelegt wird.

#### Kotlin

```kotlin
// Implement your MobileReaderListener
val mobileReaderListener = yourMobileReaderListener
val autoReconnectOnUnexpectedDisconnect = true

val connectionConfig = UsbConnectionConfiguration(
    ""{{LOCATION_ID}}"",
    autoReconnectOnUnexpectedDisconnect,
    mobileReaderListener
)

Terminal.getInstance().connectReader(
    selectedReader,
    connectionConfig,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

> #### Standby-Modus verwenden
> 
> Programmieren Sie Ihre App nicht so, dass sie `disconnectReader` aufruft, um Strom zu sparen. Das Lesegerät verwaltet den Strom effizient über seinen Standby-Modus.

## Umgang mit Verbindungsabbrüchen von Lesegeräten

- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)
- [DisconnectReason (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-disconnect-reason/index.html)

Zwischen Ihrer App und dem Lesegerät kann es manchmal zu Verbindungsabbrüchen kommen. Dies kann zum Beispiel passieren, wenn das USB-Kabel, das es mit Ihrem Gerät verbindet, getrennt wird. Sie können eine unerwartete Unterbrechung während des Tests simulieren, indem Sie das Lesegerät ausschalten.

Der `MobileReaderListener` enthält einen `onDisconnect`-Rückruf, der Ihrer Anwendung den `DisconnectReason` mitteilt, um herauszufinden, warum das Lesegerät getrennt wurde.

Gehen Sie wie folgt vor, um Verbindungsabbrüche selbst zu handhaben:

1. Setzen Sie `autoReconnectOnUnexpectedDisconnect` während der Verbindungsherstellung auf `false`.
1. Bearbeiten Sie den Rückruf bei Trennung son, dass nur eine Meldung in der App angezeigt wird. Diese weist die Nutzer/innen darauf hin, dass das Lesegerät unerwartet getrennt wurde, und mit der Erkennung und erneuten Verbindung des Lesegeräts begonnen werden kann.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Verbundenes Lesegerät neu starten

- [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html)

Die Lesegeräte Stripe&nbsp;Reader&nbsp;M2 und BBPOS&nbsp;WisePad&nbsp;3 werden automatisch neugestartet, nachdem sie 24&nbsp;Stunden lang in Betrieb waren. Sie können das Lesegerät jedoch mithilfe der `rebootReader` API zum Neustart zwingen und so diesen 24-Stunden-Rhythmus zurücksetzen. Dabei trennt sich das Lesegerät vom SDK und führt einen Neustart durch. Wenn Sie die automatische Wiederverbindung verwenden, versucht das SDK anschließend, die Verbindung mit dem Lesegerät wiederherzustellen.

#### Kotlin

```kotlin
Terminal.getInstance().rebootReader(
    object : Callback {
        override fun onSuccess() {
            // Reboot succeeded and the reader will disconnect.
            // If your app is using automatic reconnect the reconnect will begin.
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

#### Automatisch versuchen, die Verbindung wiederherzustellen

Wenn die Verbindung zu einem Lesegerät getrennt wird, versuchen wir standardmäßig automatisch, die Verbindung wiederherzustellen. Wir empfehlen, während des gesamten Vorgangs Benachrichtigungen über den Status des Lesegeräts in Ihrer App anzuzeigen.

Gehen Sie wie folgt vor, um bei der automatischen Wiederverbindung Benachrichtigungen in Ihrer App anzuzeigen:

1. Implementieren Sie die Rückrufe für die Wiederverbindung des Lesegeräts im `MobileReaderListener`.
1. Übergeben Sie den `MobileReaderListener` an Ihre `UsbConnectionConfiguration`.
1. Wenn das SDK [onReaderReconnectStarted](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-started.html) an Ihre App sendet, zeigen Sie eine Meldung an, die besagt, dass die Verbindung zum Lesegerät getrennt wurde und eine erneute Herstellung der Verbindung durchgeführt wird.
   - Sie können den Verbindungsversuch jederzeit mit dem `Cancelable`-Objekt stoppen.
1. Wenn sich das SDK wieder erfolgreich verbunden hat, nachdem [`onReaderReconnectSucceeded`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-succeeded.html) gesendet wurde, zeigen Sie eine Meldung an, die besagt, dass die Verbindung wiederhergestellt wurde und der Betrieb normal fortgesetzt werden kann.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann und sowohl [`onReaderReconnectFailed`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-failed.html) als auch `onDisconnect` sendet, zeigen Sie eine Meldung an, die besagt, dass die Verbindung unerwartet getrennt wurde.

#### Kotlin

```kotlin
class CustomMobileReaderListener : MobileReaderListener {
    // ...

    override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    override fun onReaderReconnectSucceeded(reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }

    override fun onReaderReconnectFailed(reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }

    // ...
}
```

#### Automatische Wiederverbindung beim Anwendungsstart

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie dessen Seriennummer an einem dauerhaften Datenspeicherort wie beispielsweise der [Shared Preferences API](https://developer.android.com/training/data-storage/shared-preferences) (Android).

1. Wenn Ihre App gestartet wird, überprüfen Sie den dauerhaften Datenspeicherort auf eine gespeicherte Seriennummer. Wenn eines gefunden wird, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, dieses Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Benutzeroberfläche an, um darauf hinzuweisen, dass eine automatische Wiederverbindung stattfindet.

## Lesegerät-Software aktualisieren [Client-seitig]



- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)

Ihre Anwendung muss mobile Lesegeräte aktualisieren, damit Folgendes angewendet wird:

- Regionale Konfigurationen, die Sie über die Anforderungen des Kartennetzwerks und des Ausstellers auf dem Laufenden halten
- Sicherheitsupdates

Erforderliche Updates werden installiert, wenn eine Verbindung mit dem Lesegerät aufgebaut wurde. Sie können das Lesegerät erst verwenden, wenn die Aktualisierung abgeschlossen ist.

> Um Updates installieren zu können, muss der Akkustand des Lesegeräts höher als 50&nbsp;% sein.

### Erforderliche Aktualisierungen

Wenn für das Lesegerät sofort erforderliche Updates verfügbar sind, erhält der `MobileReaderListener` der Integration `onStartInstallingUpdate` mit einem `ReaderSoftwareUpdate`.

Das `ReaderSoftwareUpdate` enthält die notwendigen Details des Updates, einschließlich einer Schätzung der Gesamtdauer des Updates, die von `durationEstimate` angegeben wird.

Während des Installationsvorgangs geht der `connectionStatus` des Terminal in `ConnectionStatus.CONNECTING` über, während das Update auf dem Lesegerät installiert wird.

Ihre Anwendung muss Nutzer/innen darüber benachrichtigen, dass ein Update installiert wird, und den Fortschritt auf Ihrer Nutzeroberfläche anzeigen. Machen Sie deutlich, warum der Verbindungsaufbau länger als gewöhnlich dauern kann.

Wenn der erforderliche Aktualisierungsprozess fehlschlägt, teilt Stripe den Fehler dem `MobileReaderListener` mit `onFinishInstallingUpdate` mit. Sie können sich nach einem fehlgeschlagenen erforderlichen Update nicht wieder mit dem Lesegerät verbinden, es sei denn, die folgenden Bedingungen sind erfüllt:

- Das Lesegerät führt innerhalb der letzten 30 Tage die neueste Softwareversion für den Standort aus.
- Die Android SDK-Version ist neuer als oder gleich `3.5.0`.

Wenn die Bedingungen erfüllt sind, ist der Verbindungsvorgang trotz unvollständiger Aktualisierung erfolgreich. Stripe wiederholt die erforderliche Aktualisierung, wenn Sie das nächste Mal eine Verbindung zu diesem Lesegerät herstellen, bis es erfolgreich installiert wurde.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onStartInstallingUpdate(update: ReaderSoftwareUpdate, cancelable: Cancelable) {
        // Show UI communicating that a required update has started installing
    }

    override fun onReportReaderSoftwareUpdateProgress(progress: Float) {
        // Update the progress of the installation
    }

    override fun onFinishInstallingUpdate(update: ReaderSoftwareUpdate?, e: TerminalException?) {
        // Report success or failure of the update
    }

    // ...
}
```

Sie können erforderliche Aktualisierungen mithilfe des Objekts `Cancelable` abbrechen, was ebenfalls zu einer fehlgeschlagenen Verbindung zum Lesegerät führt. Laufende inkrementelle Aktualisierungen können nicht abgebrochen werden.

### Optionale Updates

Sie können optionale Aktualisierungen bis zu dem Datum verschieben, an dem sie erforderlich werden. Das SDK benachrichtigt Sie über den `MobileReaderListener` jedes Mal über optionale Aktualisierungen, wenn das Lesegerät verbunden ist, aber keine Transaktion durchführt. Wenn eine optionale Aktualisierung verfügbar ist, empfängt der `MobileReaderListener` Ihrer Anwendung den Rückruf `onReportAvailableUpdate` mit dem `ReaderSoftwareUpdate`-Objekt, das die Aktualisierungsdetails enthält, darunter:

- Geschätzte Zeit für den Abschluss der Aktualisierung (`durationEstimate`)
- Datum, nach dem die Aktualisierung erforderlich wird (`requiredAt`)

Benachrichtigen Sie die Nutzer/innen in Ihrer Anwendung, wenn eine Aktualisierung verfügbar ist, und zeigen Sie eine Aufforderung an, optional mit der Aktualisierung fortzufahren.

Um mit der zuvor mit `onReportAvailableUpdate` gemeldeten Aktualisierung fortzufahren, rufen Sie `Terminal.getInstance().installAvailableUpdate` auf.

Das verfügbare Update wird auch als `reader.availableUpdate` im Reader-Objekt gespeichert.

Verhindern Sie während der Aktualisierung, dass die Nutzer/innen die Seite in Ihrer App verlassen, und weisen Sie die Nutzer/innen an, die Verbindung zum Lesegerät aufrechtzuerhalten, bis die Aktualisierung abgeschlossen ist. Wir empfehlen, Ihren Nutzern/Nutzerinnen auch eine visuelle Anzeige des Aktualisierungsfortschritts zur Verfügung zu stellen. Der `MobileReaderListener` meldet den Fortschritt der Aktualisierung in der Methode `onReportReaderSoftwareUpdateProgress`.

Wenn das `requiredAt`-Datum einer optionalen Aktualisierung verstrichen ist, wird die Aktualisierung erst installiert, wenn das Lesegerät verbunden wird.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onReportAvailableUpdate(update: ReaderSoftwareUpdate) {
        // An update is available for the connected reader. Show this update in your application.
        // Install this update using `Terminal.getInstance().installAvailableUpdate`.
    }

    // ...
}
```

Unter [Aktualisierungen für Lesegeräte testen](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates) erfahren Sie, wie Sie sicherstellen können, dass Ihre Anwendung die verschiedenen Aktualisierungstypen für ein Lesegerät verarbeiten kann.


# USB-Lesegeräte

> This is a USB-Lesegeräte for when terminal-sdk-platform is react-native and reader-type is usb. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=usb.

> #### Plattform-Support
> 
> Die Unterstützung für die Verbindung mit mobilen Lesegeräten über das React Native SDK ist derzeit auf die Android-Plattform beschränkt.

Verwenden Sie Stripe Terminal  React Native SDK beta.13  (oder höher), um USB-Verbindungen für den [Stripe Reader M2](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) und die [BBPOS WisePad&nbsp;3](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepad3.md)-Lesegeräte zu unterstützen.

Sie müssen ein USB-Kabel verwenden, das sowohl Datenübertragung als auch Aufladen unterstützt, wie das USB&nbsp;2.0-Kabel, das im Lieferumfang des Stripe Reader&nbsp;M2 und des BBPOS WisePad&nbsp;3 enthalten ist. Wenn das mit Ihrem Terminal-Lesegerät gelieferte Kabel nur zum Aufladen geeignet ist, verwenden Sie ein USB 2.0-Kabel eines Drittanbieters, das Daten übertragen kann.

So verbinden Sie Ihre App per USB-Kabel mit einem Datenterminal:

1. [Lesegeräte erkennen](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

## Lesegeräte entdecken [Client-seitig]

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverreaders-1)
- [DiscoveryReaderParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/types/DiscoverReadersParams.html)

Stellen Sie sicher, dass das Lesegerät eingeschaltet und über ein USB&nbsp;2.0-Kabel mit dem Gerät verbunden ist, auf dem Ihre App ausgeführt wird, und dass die Berechtigung zum Zugriff auf das über USB verbundene Lesegerät erteilt wurde.

Wenn Sie das Lesegerät zum ersten Mal anschließen, wird eine Aufforderung des Android-Systems angezeigt, eine Verbindung zum Lesegerät herzustellen. Sie können das Kontrollkästchen „Immer geöffnet“ aktivieren, um Ihre App ohne Nachfrage zu öffnen, wenn sie mit einem Lesegerät verbunden ist.

Suchen Sie dann in Ihrer App mit der Methode `discoverReaders` nach dem verbundenen Lesegerät, indem Sie  `usb` als `DiscoveryMethod`  verwenden.

```js
function DiscoverReadersScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
      },
    });

  useEffect(() => {
    handleDiscoverReaders();
  }, []);

  const handleDiscoverReaders = async () => {
    // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method
    // within the `useStripeTerminal` hook.
    const { error } = await discoverReaders({
      discoveryMethod: 'usb',
    });

    if (error) {
      Alert.alert(
        'Discover readers error: ',
        `${error.code}, ${error.message}`
      );
    }
  };

  return <View />;
}
```

## Mit einem Lesegerät verbinden [Client-seitig]

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)
- [ConnectUsbReaderParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/ConnectUsbReaderParams.html)

Um eine Verbindung zu einem erkannten Lesegerät herzustellen, rufen Sie die Methode `connectReader` in Ihrer App auf.

Sie müssen Ihr [Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei der Herstellung der Verbindung bei einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Übergeben Sie dazu  die relevante `locationId` an `ConnectUsbReaderParams`  festgelegt wird.

```js
const handleConnectUsbReader = async (id) => {
  const { reader, error } = await connectReader(
    {
      reader: selectedReader,
      locationId: {{LOCATION_ID}},
    },
    'usb'
  );

  if (error) {
    console.log('connectReader error', error);
    return;
  }

  console.log('Reader connected successfully', reader);
};
```

> #### Standby-Modus verwenden
> 
> Programmieren Sie Ihre App nicht so, dass sie `disconnectReader` aufruft, um Strom zu sparen. Das Lesegerät verwaltet den Strom effizient über seinen Standby-Modus.

## Umgang mit Verbindungsabbrüchen von Lesegeräten

- [REPORT_UNEXPECTED_READER_DISCONNECT (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT)
- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)
- [DisconnectReason (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.html#DisconnectReason)

Zwischen Ihrer App und dem Lesegerät kann es manchmal zu Verbindungsabbrüchen kommen. Dies kann zum Beispiel passieren, wenn das USB-Kabel, das es mit Ihrem Gerät verbindet, getrennt wird. Sie können eine unerwartete Unterbrechung während des Tests simulieren, indem Sie das Lesegerät ausschalten.

`UserCallbacks` enthält die Information `onDidDisconnect`, die Ihrer Anwendung den `DisconnectReason` mitteilt, um herauszufinden, warum das Lesegerät getrennt wurde.

Gehen Sie wie folgt vor, um Verbindungsabbrüche selbst zu handhaben:

1. Setzen Sie `autoReconnectOnUnexpectedDisconnect` während der Verbindungsherstellung auf `false`.
1. Bearbeiten Sie den Rückruf bei Trennung son, dass nur eine Meldung in der App angezeigt wird. Diese weist die Nutzer/innen darauf hin, dass das Lesegerät unerwartet getrennt wurde, und mit der Erkennung und erneuten Verbindung des Lesegeräts begonnen werden kann.

```js
const terminal = useStripeTerminal({
  onDidDisconnect: (result) => {
    // Consider displaying a UI to notify the user and start rediscovering readers
  },
});
```

### Verbundenes Lesegerät neu starten

- [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader)

Die Lesegeräte Stripe&nbsp;Reader&nbsp;M2 und BBPOS&nbsp;WisePad&nbsp;3 werden automatisch neugestartet, nachdem sie 24&nbsp;Stunden lang in Betrieb waren. Sie können das Lesegerät jedoch mithilfe der `rebootReader` API zum Neustart zwingen und so diesen 24-Stunden-Rhythmus zurücksetzen. Dabei trennt sich das Lesegerät vom SDK und führt einen Neustart durch. Wenn Sie die automatische Wiederverbindung verwenden, versucht das SDK anschließend, die Verbindung mit dem Lesegerät wiederherzustellen.

```js
const { error } = await rebootReader();

if (error) {
  console.log('rebootReader error:', error);
  return;
}

console.log('rebootReader succeeded');
```

#### Automatisch versuchen, die Verbindung wiederherzustellen

Wenn die Verbindung zu einem Lesegerät getrennt wird, versuchen wir standardmäßig automatisch, die Verbindung wiederherzustellen. Wir empfehlen, während des gesamten Vorgangs Benachrichtigungen über den Status des Lesegeräts in Ihrer App anzuzeigen.

Gehen Sie wie folgt vor, um bei der automatischen Wiederverbindung Benachrichtigungen in Ihrer App anzuzeigen:

1. Legen Sie `autoReconnectOnUnexpectedDisconnect` für `ConnectUsbReaderParams` auf „true“ fest.
1. Implementieren Sie die Rückrufe für die automatische Wiederverbindung, die in den `UserCallbacks` gefunden wurden.
1. Wenn das SDK `onDidStartReaderReconnect` an Ihre App sendet, zeigen Sie eine Meldung an, dass die Verbindung zum Lesegerät unterbrochen wurde und eine erneute Verbindung durchgeführt wird.
   - Sie können den Verbindungsversuch jederzeit mit `cancelReaderReconnection` stoppen.
1. Wenn sich das SDK wieder erfolgreich verbunden hat, nachdem `onDidSucceedReaderReconnect` gesendet wurde, zeigen Sie eine Meldung an, dass die Verbindung wiederhergestellt wurde und der Betrieb normal fortgesetzt werden kann.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann und und `onDidFailReaderReconnect` sendet, zeigen Sie eine Meldung an, dass die Verbindung unerwartet getrennt wurde.

#### Automatische Wiederverbindung beim Anwendungsstart

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie dessen Seriennummer an einem dauerhaften Datenspeicherort wie beispielsweise [Async Storage](https://github.com/react-native-async-storage/async-storage) (React Native).

1. Wenn Ihre App gestartet wird, überprüfen Sie den dauerhaften Datenspeicherort auf eine gespeicherte Seriennummer. Wenn eines gefunden wird, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, dieses Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Benutzeroberfläche an, um darauf hinzuweisen, dass eine automatische Wiederverbindung stattfindet.

## Lesegerät-Software aktualisieren [Client-seitig]



- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)

Ihre Anwendung muss mobile Lesegeräte aktualisieren, damit Folgendes angewendet wird:

- Regionale Konfigurationen, die Sie über die Anforderungen des Kartennetzwerks und des Ausstellers auf dem Laufenden halten
- Sicherheitsupdates

Erforderliche Updates werden installiert, wenn eine Verbindung mit dem Lesegerät aufgebaut wurde. Sie können das Lesegerät erst verwenden, wenn die Aktualisierung abgeschlossen ist.

> Um Updates installieren zu können, muss der Akkustand des Lesegeräts höher als 50&nbsp;% sein.

### Erforderliche Aktualisierungen

Wenn für das Lesegerät sofort erforderliche Updates verfügbar sind, erhält die Integration `onDidStartInstallingUpdate` vom `useStripeTerminal`-Hook mit einem `Reader.SoftwareUpdate`.

Das `Reader.SoftwareUpdate` enthält die erforderlichen Details des Updates, einschließlich einer Schätzung der Gesamtdauer des Updates, die von `estimatedUpdateTime` angegeben wird.

Während des Installationsvorgangs geht der `connectionStatus` des Terminal auf `"connecting"` über, während das Update auf dem Lesegerät installiert wird.

Ihre Anwendung muss Nutzer/innen darüber benachrichtigen, dass ein Update installiert wird, und den Fortschritt auf Ihrer Nutzeroberfläche anzeigen. Machen Sie deutlich, warum der Verbindungsaufbau länger als gewöhnlich dauern kann.

Wenn der erforderliche Aktualisierungsprozess fehlschlägt, teilt Stripe den Fehler dem `useStripeTerminal`-Hook mit `onDidFinishInstallingUpdate` mit. Sie können sich nach einem fehlgeschlagenen erforderlichen Update nicht wieder mit dem Lesegerät verbinden, es sei denn, die folgenden Bedingungen sind erfüllt:

- Das Lesegerät führt innerhalb der letzten 30 Tage die neueste Softwareversion für den Standort aus.
- Die React Native SDK-Version ist neuer als oder gleich `0.0.1-beta.18`.

Wenn die Bedingungen erfüllt sind, ist der Verbindungsvorgang trotz unvollständiger Aktualisierung erfolgreich. Stripe wiederholt die erforderliche Aktualisierung, wenn Sie das nächste Mal eine Verbindung zu diesem Lesegerät herstellen, bis es erfolgreich installiert wurde.

```js
const terminal = useStripeTerminal({
  onDidReportReaderSoftwareUpdateProgress: (progress) => {
    setCurrentProgress((Number(progress) * 100).toFixed(0).toString());
  },
  onDidFinishInstallingUpdate: ({ error }) => {
  },
  onDidStartInstallingUpdate: (update) => {
  },
});
```

Sie können erforderliche Updates mithilfe der API `cancelInstallingUpdate` abbrechen, was ebenfalls zu einer fehlgeschlagenen Verbindung zum Lesegerät führt. Laufende inkrementelle Updates können nicht abgebrochen werden.

### Optionale Updates

Sie können optionale Aktualisierungen bis zu dem Datum verschieben, an dem sie erforderlich werden. Das SDK benachrichtigt Sie immer über den Rückruf `onDidReportAvailableUpdate` des `useStripeTerminal`-Hooks über optionale Aktualisierungen, wenn das Lesegerät verbunden ist, aber keine Transaktion durchführt. Wenn eine optionale Aktualisierung verfügbar ist, empfängt der `useStripeTerminal`-Hook Ihrer Anwendung den Rückruf `onDidReportAvailableUpdate` mit dem `SoftwareUpdate`-Objekt, das die Aktualisierungsdetails enthält, einschließlich:

- Geschätzte Zeit für den Abschluss der Aktualisierung (`estimatedUpdateTime`)
- Datum, nach dem die Aktualisierung erforderlich wird (`requiredAt`)

Benachrichtigen Sie die Nutzer/innen in Ihrer Anwendung, wenn eine Aktualisierung verfügbar ist, und zeigen Sie eine Aufforderung an, optional mit der Aktualisierung fortzufahren.

Um mit der zuvor mit `onDidReportAvailableUpdate` gemeldeten Aktualisierung fortzufahren, rufen Sie `installAvailableUpdate` über den `useStripeTerminal`-Hook auf.

Das verfügbare Update wird auch als `reader.availableUpdate` im Reader-Objekt gespeichert.

Verhindern Sie während der Aktualisierung, dass die Nutzer/innen die Seite in Ihrer App verlassen, und weisen Sie die Nutzer/innen an, das Lesegerät in Reichweite und eingeschaltet zu lassen, bis die Aktualisierung abgeschlossen ist. Wir empfehlen, Ihren Nutzern/Nutzerinnen auch eine visuelle Anzeige des Aktualisierungsfortschritts zur Verfügung zu stellen. Der Hook `useStripeTerminal` meldet den Aktualisierungsfortschritt in der Methode `onDidReportReaderSoftwareUpdateProgress`.

Wenn das `requiredAt`-Datum einer optionalen Aktualisierung verstrichen ist, wird die Aktualisierung erst installiert, wenn das Lesegerät verbunden wird.

```js
const terminal = useStripeTerminal({
  onDidReportAvailableUpdate: (update) => {
    // An update is available for the connected reader. Show this update in your application.
    // Install this update using the `installAvailableUpdate` method from the `useStripeTerminal` hook.
  },
});
```

Unter [Aktualisierungen für Lesegeräte testen](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates) erfahren Sie, wie Sie sicherstellen können, dass Ihre Anwendung die verschiedenen Aktualisierungstypen für ein Lesegerät verarbeiten kann.


# Internet-Lesegeräte

> This is a Internet-Lesegeräte for when terminal-sdk-platform is server-driven and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=server-driven&reader-type=internet.

Auf intelligenten Lesegeräten wird die Stripe-Lesegerätesoftware ausgeführt, um direkt über das Internet zu kommunizieren. Bevor Sie Ihre Anwendung mit einem intelligenten Lesegerät verbinden können, müssen Sie das Lesegerät bei Ihrem Stripe-Konto registrieren.

#### Dashboard

Sie können Ihre Lesegerät direkt im [Dashboard](https://dashboard.stripe.com/terminal) registrieren.

#### Mit Registrierungscode registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Geben Sie den Registrierungscode ein und klicken Sie auf **Weiter**.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Mit Seriennummer registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Suchen Sie auf dem Gerät nach der Seriennummer und geben Sie diese ein. Um mehrere Geräte gleichzeitig zu registrieren, können Sie mehrere, durch Kommas getrennte Seriennummern eingeben.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen. Sie können nur Lesegeräte registrieren, die Sie oder Ihre Plattform bestellt haben.

#### Nach Hardware-Bestellung registrieren

1. Suchen Sie auf der Seite [Hardware-Bestellungen](https://dashboard.stripe.com/terminal/hardware_orders) nach einer Bestellung mit dem Status „Versendet“ oder „Geliefert“. Klicken Sie auf das Überlaufmenü (⋯) am Ende der Zeile und klicken Sie dann auf **Registrieren**.
1. Wählen Sie auf der Seite **Lesegerät registrieren** ein oder mehrere Lesegerät aus der Hardware-Reihenfolge aus, die Sie registrieren möchten, und klicken Sie dann auf **Registrieren**.
1. Wählen Sie optional einen Namen für das Lesegerät. Wenn Sie mehrere Lesegeräte ausgewählt haben, dient der Name als Präfix und wir benennen die Lesegeräte der Reihe nach (zum Beispiel legen wir für eine bestimmte Eingabe von „Testlesegerät“ die Bezeichnungen „Testlesegerät&nbsp;1“, „Testlesegerät&nbsp;2“ usw. fest).
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihrer Lesegeräte abzuschließen.

#### API

Bei größeren Bereitstellungen sollten Sie es den Nutzerinnen/Nutzern vor Ort ermöglichen, neue Lesegeräte selbst zu empfangen und einzurichten. Erstellen Sie in Ihrer Anwendung einen Ablauf zum [Registrieren](https://docs.stripe.com/api/terminal/readers/create.md) eines Lesegeräts mit der Stripe API.

1. Gehen Sie zu den [Einstellungen des Lesegeräts](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie dann auf **Kopplungscode generieren**.
1. Der/die Nutzer/in gibt den Code in Ihre Anwendung ein.
1. Ihre Anwendung sendet den Code an Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode label="Alice's reader" \
  -d location="{{TERMINALLOCATION_ID}}"
```

Um zu prüfen, ob Sie ein Lesegerät korrekt registriert haben, lassen Sie alle an diesem Standort registrierten Lesegeräte auflisten:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

Nachdem Sie Ihr Lesegerät registriert haben, kann es mit der servergestützten Integration verwendet werden. Wir empfehlen, die Lesegerät-ID (`tmr_xxx`) in Ihrer Anwendung zu speichern, damit Sie wissen, an welches Lesegerät Sie Transaktionen von Ihrer Verkaufsstelle senden müssen. Sie können die Lesegerät-IDs über den Endpoint [Lesegeräte auflisten](https://docs.stripe.com/api/terminal/readers/list.md) abrufen.


# Internet-Lesegeräte

> This is a Internet-Lesegeräte for when terminal-sdk-platform is js and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=js&reader-type=internet.

> #### Empfehlung für intelligente Lesegeräte
> 
> Für intelligente Lesegeräte wie das Lesegerät [BBPOS WisePOS E](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md), [Stripe Reader S700/S710](https://docs.stripe.com/terminal/readers/stripe-reader-s700-s710.md) und [Verifone-Lesegeräte](https://docs.stripe.com/terminal/payments/setup-reader/verifone.md) empfehlen wir die Verwendung der [servergestützten Integration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=server-driven) anstelle des JavaScript-SDK.
> 
> Das JavaScript-SDK erfordert Ihr POS und Lesegerät im selben lokalen Netzwerk mit funktionierendem lokalen DNS. Die Server-gestützte Integration verwendet stattdessen die Stripe API, was in komplexen Netzwerkumgebungen einfacher sein kann. Lesen Sie unseren [Plattformvergleich](https://docs.stripe.com/terminal/payments/setup-reader.md#sdk), um die beste Plattform für Ihre Anforderungen auszuwählen.

Auf intelligenten Lesegeräten wird die Stripe-Lesegerätesoftware ausgeführt, um direkt mit Stripe über das Internet zu kommunizieren. Das Verbinden Ihrer App mit einem intelligenten Lesegerät erfordert drei Schritte:

1. Lesegerät im Stripe-Konto [registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader)
1. [Lesegeräte finden](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) mit dem SDK

## Lesegerät registrieren [Serverseitig]

Bevor Sie Ihre Anwendung mit einem intelligenten Lesegerät verbinden können, müssen Sie das Lesegerät in Ihrem Konto registrieren.

#### Dashboard

### Im Dashboard registrieren

Sie können Ihr Lesegerät direkt im [Dashboard](https://dashboard.stripe.com/test/terminal) hinzufügen.

#### Mit Registrierungscode registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Geben Sie den Registrierungscode ein und klicken Sie auf **Weiter**.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Mit Seriennummer registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Suchen Sie auf dem Gerät nach der Seriennummer und geben Sie diese ein. Um mehrere Geräte gleichzeitig zu registrieren, können Sie mehrere, durch Kommas getrennte Seriennummern eingeben.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Nach Hardware-Bestellung registrieren

1. Suchen Sie auf der Seite [Hardware-Bestellungen](https://dashboard.stripe.com/terminal/hardware_orders) nach einer Bestellung mit dem Status „Versendet“ oder „Geliefert“. Klicken Sie auf das Überlaufmenü (⋯) am Ende der Zeile und klicken Sie dann auf **Registrieren**.
1. Wählen Sie auf der Seite **Lesegerät registrieren** ein oder mehrere Lesegerät aus der Hardware-Reihenfolge aus, die Sie registrieren möchten, und klicken Sie dann auf **Registrieren**.
1. Wählen Sie optional einen Namen für das Lesegerät. Wenn Sie mehrere Lesegeräte ausgewählt haben, dient der Name als Präfix und wir benennen die Lesegeräte der Reihe nach (zum Beispiel legen wir für eine bestimmte Eingabe von „Testlesegerät“ die Bezeichnungen „Testlesegerät&nbsp;1“, „Testlesegerät&nbsp;2“ usw. fest).
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihrer Lesegeräte abzuschließen.

#### API

Bei größeren Bereitstellungen sollten Sie es den Nutzerinnen/Nutzern vor Ort ermöglichen, neue Lesegeräte selbst zu empfangen und einzurichten. Erstellen Sie in Ihrer App einen Ablauf zum [Registrieren](https://docs.stripe.com/api/terminal/readers/create.md) eines Lesegeräts mit der Stripe API.

1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Der/die Nutzer/in gibt den Code in Ihre Anwendung ein.
1. Ihre Anwendung sendet den Code an Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode label="Alice's reader" \
  -d location="{{TERMINALLOCATION_ID}}"
```

Um zu prüfen, ob Sie ein Lesegerät korrekt registriert haben, lassen Sie alle an diesem Standort registrierten Lesegeräte auflisten:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#discover-readers)

Nachdem Sie das Lesegerät in Ihrem Konto registriert haben, können Sie mit der Methode `discoverReaders` nach bereits registrierten Lesegeräten suchen, die Sie mit Ihrer Point-of-Sale-Anwendung verbinden können, und setzen Sie `discoveryMethod` auf `Internet`.

Sie können Ihre Erkennung anhand des `location` eingrenzen, bei dem Sie das Lesegerät im vorherigen Schritt registriert haben.

```javascript
async function discoverReaders() {
  const config = {simulated: false, location: "{{LOCATION_ID}}"}
  const discoverResult = await terminal.discoverReaders(config);
  if (discoverResult.error) {
    console.log('Failed to discover: ', discoverResult.error);
  } else if (discoverResult.discoveredReaders.length === 0) {
    console.log('No available readers.');
  } else {
    // You should show the list of discoveredReaders to the
    // cashier here and let them select which to connect to (see below).
    connectReader(discoverResult);
  }
}
```

## Mit einem Lesegerät verbinden [Clientseitig]

> Chrome 142 (veröffentlicht am 28. Oktober 2025) und neuere Versionen erfordern eine ausdrückliche Genehmigung, bevor Websites auf lokale Netzwerkgeräte (wie Datenterminal Reader) zugreifen können, wenn sie das JavaScript-SDK des Stripe-Datenterminals verwenden. Informationen zu Einrichtungsschritten und Fehlerbehebung finden Sie in der [Anleitung zu Chrome 142+](https://support.stripe.com/questions/ensuring-stripe-terminal-javascript-sdk-functionality-on-chrome-142).

Um Ihre Point-of-Sale-Anwendung mit einem Lesegerät zu verbinden, rufen Sie mit dem ausgewählten Lesegerät [connectReader](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) auf.

```javascript
async function connectReader(discoverResult) {
  // Just select the first reader here.
  const selectedReader = discoverResult.discoveredReaders[0];

  const connectResult = await terminal.connectReader(selectedReader);
  if (connectResult.error) {
    console.log('Failed to connect:', connectResult.error);
  } else {
    console.log('Connected to reader:', connectResult.reader.label);
  }
}
```

- [connectReader (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader)

### Mehrere Verbindungen

Es kann immer nur eine Instanz des Stripe Terminal SDK mit einem Lesegerät verbunden werden. Wenn Sie `connectReader` von einer anderen Anwendung aus aufrufen, ersetzt die eingehende Verbindung standardmäßig die bestehende Verbindung zwischen SDK und Lesegerät, und das zuvor verbundene SDK wird vom Lesegerät getrennt. Die Methode `connectReader` verwendet ein Konfigurationsobjekt mit der Eigenschaft `fail_if_in_use`, deren Standardwert `false` ist. Wenn Ihre Anwendung `fail_if_in_use` auf „true“ festlegt, weist der `connectReader`-Aufruf ein alternatives Verhalten auf, bei dem die eingehende Verbindung fehlschlägt, wenn sich das Lesegerät mitten in einem `collectPaymentMethod`- oder `processPayment`-Aufruf befindet, der von einem anderen SDK initiiert wurde. Wenn das Lesegerät mit einem anderen SDK verbunden ist, sich aber im Ruhezustand befindet (der Begrüßungsbildschirm wird angezeigt, bevor `collectPaymentMethod` aufgerufen wird), bewirkt die Einstellung von `fail_if_in_use` keine Änderung am Verbindungsverhalten und die eingehende Verbindungsanfrage kann die bestehende Verbindung vom SDK zum Lesegerät immer unterbrechen.

```javascript
const connectResult = await terminal.connectReader(reader, {fail_if_in_use: true});
```

|                                                                                                                  | fail_if_in_use ist „false“ (Standard)                                                                                                                                                                                                                                                       | fail_if_in_use ist „true“                                                                                                                                                                                                                                                                   |
| ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn das Lesegerät inaktiv ist.                             | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn sich das Lesegerät mitten in der Transaktion befindet. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. | Die eingehende Verbindung schlägt mit einem Lesegerätfehler fehl. Die bestehende Verbindung vom SDK zum Lesegerät wird nicht unterbrochen, und der laufende Befehl wird fortgesetzt.                                                                                                        |

Für eine möglichst unterbrechungsfreie Verbindung in Umgebungen mit mehreren Lesegeräten empfehlen wir, `fail_if_in_use` beim ersten Verbindungsversuch Ihrer Anwendung auf `true` festzulegen. Erlauben Sie Ihren Nutzer/innen dann, den Verbindungsaufbau zu wiederholen, wobei `fail_if_in_use` auf `false` gesetzt wird, falls die Verbindung beim ersten Mal fehlschlägt.

Mit dieser Konfiguration kann eine/r Ihrer Nutzer/innen eine Transaktion nicht versehentlich durch eine versehentliche Verbindung zu einem verwendeten Lesegerät unterbrechen, kann aber bei Bedarf trotzdem eine Verbindung herstellen.

### Mit Verbindungsabbrüchen umgehen

- [StripeTerminal.create (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-create)

Ihre App muss den Rückruf `onUnexpectedReaderDisconnect` für Verbindungsabbrüche bei Lesegeräten implementieren. Wenn Sie diesen Rückruf implementieren, zeigen Sie eine Nutzeroberfläche an, die Ihre Nutzer/innen über das getrennte Lesegerät informiert. Sie können `discoverReaders` aufrufen, um nach Lesegeräten zu suchen und die erneute Verbindung zu initiieren.

Ihre App kann versuchen, die Verbindung zum getrennten Lesegerät automatisch wiederherzustellen, oder eine Nutzeroberfläche anzeigen, die Ihre Nutzer/innen auffordert, die Verbindung zu einem anderen Lesegerät wiederherzustellen.

Das Lesegerät kann die Verbindung zu Ihrer App trennen, wenn die Verbindung zum Netzwerk unterbrochen wird. Schalten Sie das Lesegerät aus, um eine unerwartete Unterbrechung zu simulieren.

```javascript
const terminal = StripeTerminal.create({
  onFetchConnectionToken: fetchConnectionToken,
  onUnexpectedReaderDisconnect: unexpectedDisconnect,
});

function unexpectedDisconnect() {
  // Consider displaying a UI to notify the user and start rediscovering readers
}
```

### Automatische Wiederverbindung

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie dessen Seriennummer an einem dauerhaften Datenspeicherort wie beispielsweise der [localStorage API](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage).
1. Wenn Ihre App gestartet wird, suchen Sie an diesem dauerhaften Speicherort nach einer gespeicherten Seriennummer. Wird eine solche gefunden, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, das Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Nutzeroberfläche an, um darauf hinzuweisen, dass eine automatische erneute Verbindung erfolgt.


# Internet-Lesegeräte

> This is a Internet-Lesegeräte for when terminal-sdk-platform is ios and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=internet.

Auf intelligenten Lesegeräten wird die Stripe-Lesegerätesoftware ausgeführt, um direkt mit Stripe über das Internet zu kommunizieren. Das Verbinden Ihrer App mit einem intelligenten Lesegerät erfordert drei Schritte:

1. Lesegerät im Stripe-Konto [registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader)
1. [Lesegeräte finden](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) mit dem SDK

## Lesegerät registrieren [Serverseitig]

Bevor Sie Ihre Anwendung mit einem intelligenten Lesegerät verbinden können, müssen Sie das Lesegerät in Ihrem Konto registrieren.

#### Dashboard

### Im Dashboard registrieren

Sie können Ihr Lesegerät direkt im [Dashboard](https://dashboard.stripe.com/test/terminal) hinzufügen.

#### Mit Registrierungscode registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Geben Sie den Registrierungscode ein und klicken Sie auf **Weiter**.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Mit Seriennummer registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Suchen Sie auf dem Gerät nach der Seriennummer und geben Sie diese ein. Um mehrere Geräte gleichzeitig zu registrieren, können Sie mehrere, durch Kommas getrennte Seriennummern eingeben.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Nach Hardware-Bestellung registrieren

1. Suchen Sie auf der Seite [Hardware-Bestellungen](https://dashboard.stripe.com/terminal/hardware_orders) nach einer Bestellung mit dem Status „Versendet“ oder „Geliefert“. Klicken Sie auf das Überlaufmenü (⋯) am Ende der Zeile und klicken Sie dann auf **Registrieren**.
1. Wählen Sie auf der Seite **Lesegerät registrieren** ein oder mehrere Lesegerät aus der Hardware-Reihenfolge aus, die Sie registrieren möchten, und klicken Sie dann auf **Registrieren**.
1. Wählen Sie optional einen Namen für das Lesegerät. Wenn Sie mehrere Lesegeräte ausgewählt haben, dient der Name als Präfix und wir benennen die Lesegeräte der Reihe nach (zum Beispiel legen wir für eine bestimmte Eingabe von „Testlesegerät“ die Bezeichnungen „Testlesegerät&nbsp;1“, „Testlesegerät&nbsp;2“ usw. fest).
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihrer Lesegeräte abzuschließen.

#### API

Bei größeren Bereitstellungen sollten Sie es den Nutzerinnen/Nutzern vor Ort ermöglichen, neue Lesegeräte selbst zu empfangen und einzurichten. Erstellen Sie in Ihrer App einen Ablauf zum [Registrieren](https://docs.stripe.com/api/terminal/readers/create.md) eines Lesegeräts mit der Stripe API.

1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Der/die Nutzer/in gibt den Code in Ihre Anwendung ein.
1. Ihre Anwendung sendet den Code an Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode label="Alice's reader" \
  -d location="{{TERMINALLOCATION_ID}}"
```

Um zu prüfen, ob Sie ein Lesegerät korrekt registriert haben, lassen Sie alle an diesem Standort registrierten Lesegeräte auflisten:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:)
- [InternetDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPInternetDiscoveryConfiguration.html)

Nachdem Sie das Lesegerät in Ihrem Konto registriert haben, können Sie mit der Methode `discoverReaders` unter Verwendung der `InternetDiscoveryConfiguration` nach bereits registrierten Lesegeräten suchen, die Sie mit Ihrer Point-of-Sale-Anwendung verbinden können.

Sie können Ihre Erkennung anhand des `location` eingrenzen, bei dem Sie das Lesegerät im vorherigen Schritt registriert haben.

#### Swift

```swift
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {
  func discoverReadersAction() throws {
      let config = try InternetDiscoveryConfigurationBuilder()
                          .setLocationId(""{{LOCATION_ID}}"")
                          .build()
      // In addition to Terminal's completion block methods, Swift async alternatives are available.
      // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example
      self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
          if let error = error {
              print("discoverReaders failed: \(error)")
          } else {
              print("discoverReaders succeeded")
          }
      }
  }
}
```

Bei der Suche nach intelligenten Lesegeräten wird die Methode `DiscoveryDelegate.didUpdateDiscoveredReaders` nur einmal pro Aufruf von `discoverReaders` aufgerufen. Wenn keine Lesegeräte beim angegebenen Standort registriert oder ihm zugewiesen sind, gibt `didUpdateDiscoveredReaders` eine leere Lesegeräte-Liste zurück. Wenn Sie einen nachfolgenden Aufruf von `discoverReaders` ausführen, um die Liste zu aktualisieren, müssen Sie zuerst den vorherigen Aufruf mit dem von `discoverReaders` zurückgegebenen `Cancelable` abbrechen.

Die `InternetDiscoveryConfiguration` unterstützt einen optionalen `timeout`-Wert für die Online-Erkennung von Lesegeräten. Dadurch wird ein schnellerer Rückgriff auf die Offline-Lesegeräterkennung gewährleistet, wenn der Online-Versuch fehlschlägt.

## Mit einem Lesegerät verbinden [Clientseitig]

> In Version `5.1.0` des iOS-SDK können Sie die `easyConnect`-Methode verwenden, um Erkennung und Verbindung des Lesegeräts in einem einzigen API-Aufruf zu kombinieren, um die Integration zu vereinfachen. Weitere Informationen finden Sie im [Migrationsleitfaden zum SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios).

Um Ihre Point-of-Sale-Anwendung mit einem Lesegerät zu verbinden, rufen Sie `connectReader` mit dem ausgewählten Lesegerät unter Verwendung der `InternetConnectionConfiguration` auf.

#### Swift

```swift
let config: InternetConnectionConfiguration
do {
    config = try InternetConnectionConfigurationBuilder(delegate: yourInternetReaderDelegate)
        .build()
} catch {
    // Handle error building the connection configuration
    return
}

Terminal.shared.connectReader(selectedReader, connectionConfig: config) { reader, error in
    if let reader = reader {
        print("Successfully connected to reader: \(reader)")
    } else if let error = error {
        print("connectReader failed: \(error)")
    }
}
```

- [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:)
- [InternetConnectionConfiguration](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPInternetConnectionConfiguration.html)

### Mehrere Verbindungen

Es kann immer nur eine Instanz des Stripe Terminal SDK mit einem Lesegerät verbunden werden. Wenn Sie `connectReader` von einer anderen Anwendung aus aufrufen, ersetzt die eingehende Verbindung standardmäßig die bestehende Verbindung zwischen SDK und Lesegerät, und das zuvor verbundene SDK wird vom Lesegerät getrennt. Die Methode `connectReader` verwendet ein Konfigurationsobjekt mit der Eigenschaft `failIfInUse`, deren Standardwert `false` ist. Wenn Ihre Anwendung `failIfInUse` auf „true“ festlegt, weist der `connectReader`-Aufruf ein alternatives Verhalten auf, bei dem die eingehende Verbindung fehlschlägt, wenn sich das Lesegerät mitten in einem `collectPaymentMethod`- oder `confirmPaymentIntent`-Aufruf befindet, der von einem anderen SDK initiiert wurde. Wenn das Lesegerät mit einem anderen SDK verbunden ist, sich aber im Ruhezustand befindet (der Begrüßungsbildschirm wird angezeigt, bevor `collectPaymentMethod` aufgerufen wird), bewirkt die Einstellung von `failIfInUse` keine Änderung am Verbindungsverhalten und die eingehende Verbindungsanfrage kann die bestehende Verbindung vom SDK zum Lesegerät immer unterbrechen.

#### Swift

```swift
let internetReaderDelegate = yourInternetReaderDelegate // implement your internetReaderDelegate

let config: InternetConnectionConfiguration
do {
    config = try InternetConnectionConfigurationBuilder(delegate: internetReaderDelegate)
          .setFailIfInUse(true)
          .build()
} catch {
    // Handle error building the connection configuration
    return
}
Terminal.shared.connectReader(selectedReader, connectionConfig: config, completion: { reader, error in
    // ...
})
```

|                                                                                                                  | failIfInUse ist „false“ (Standard)                                                                                                                                                                                                                                                           | failIfInUse ist „true“                                                                                                                                                                                                                                                                       |
| ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn das Lesegerät inaktiv ist.                             | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `didDisconnect` wird aufgerufen. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `didDisconnect` wird aufgerufen. |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn sich das Lesegerät mitten in der Transaktion befindet. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `didDisconnect` wird aufgerufen. | Die eingehende Verbindung schlägt mit einem Lesegerätfehler fehl. Die bestehende Verbindung vom SDK zum Lesegerät wird nicht unterbrochen, und der laufende Befehl wird fortgesetzt.                                                                                                         |

Für eine möglichst unterbrechungsfreie Verbindung in Umgebungen mit mehreren Lesegeräten empfehlen wir, `failIfInUse` beim ersten Verbindungsversuch Ihrer Anwendung auf `true` festzulegen. Erlauben Sie Ihren Nutzer/innen dann, den Verbindungsaufbau zu wiederholen, wobei `failIfInUse` auf `false` gesetzt wird, falls die Verbindung beim ersten Mal fehlschlägt.

Mit dieser Konfiguration kann eine/r Ihrer Nutzer/innen eine Transaktion nicht versehentlich durch eine versehentliche Verbindung zu einem verwendeten Lesegerät unterbrechen, kann aber bei Bedarf trotzdem eine Verbindung herstellen.

### Mit Verbindungsabbrüchen umgehen

- [didDisconnect (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didDisconnect:)

Ihre App muss den Rückruf `reader(_, didDisconnect:)` implementieren, um damit umzugehen, wenn ein Lesegerät die Verbindung trennt. Wenn Sie diesen Rückruf implementieren, zeigen Sie eine Nutzeroberfläche an, die Ihre Nutzer/innen über das getrennte Lesegerät informiert. Sie können `discoverReaders` aufrufen, um nach Lesegeräten zu suchen und die erneute Verbindung zu initiieren.

Ihre App kann versuchen, die Verbindung zum getrennten Lesegerät automatisch wiederherzustellen, oder eine Nutzeroberfläche anzeigen, die Ihre Nutzer/innen auffordert, die Verbindung zu einem anderen Lesegerät wiederherzustellen.

Das Lesegerät kann die Verbindung zu Ihrer App trennen, wenn die Verbindung zum Netzwerk unterbrochen wird. Schalten Sie das Lesegerät aus, um eine unerwartete Unterbrechung zu simulieren.

#### Swift

```swift
import StripeTerminal

class ReaderViewController: UIViewController, InternetReaderDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set the reader delegate when connecting to a reader
    }

    // ...



    func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }
}
```

### Automatische Wiederverbindung

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie dessen Seriennummer an einem dauerhaften Datenspeicherort wie beispielsweise der [UserDefaults API](https://developer.apple.com/documentation/foundation/userdefaults) (iOS).
1. Wenn Ihre App gestartet wird, suchen Sie an diesem dauerhaften Speicherort nach einer gespeicherten Seriennummer. Wird eine solche gefunden, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, das Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Nutzeroberfläche an, um darauf hinzuweisen, dass eine automatische erneute Verbindung erfolgt.


# Internet-Lesegeräte

> This is a Internet-Lesegeräte for when terminal-sdk-platform is android and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=internet.

Auf intelligenten Lesegeräten wird die Stripe-Lesegerätesoftware ausgeführt, um direkt mit Stripe über das Internet zu kommunizieren. Das Verbinden Ihrer App mit einem intelligenten Lesegerät erfordert drei Schritte:

1. Lesegerät im Stripe-Konto [registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader)
1. [Lesegeräte finden](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) mit dem SDK

## Lesegerät registrieren [Serverseitig]

Bevor Sie Ihre Anwendung mit einem intelligenten Lesegerät verbinden können, müssen Sie das Lesegerät in Ihrem Konto registrieren.

#### Dashboard

### Im Dashboard registrieren

Sie können Ihr Lesegerät direkt im [Dashboard](https://dashboard.stripe.com/test/terminal) hinzufügen.

#### Mit Registrierungscode registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Geben Sie den Registrierungscode ein und klicken Sie auf **Weiter**.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Mit Seriennummer registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Suchen Sie auf dem Gerät nach der Seriennummer und geben Sie diese ein. Um mehrere Geräte gleichzeitig zu registrieren, können Sie mehrere, durch Kommas getrennte Seriennummern eingeben.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Nach Hardware-Bestellung registrieren

1. Suchen Sie auf der Seite [Hardware-Bestellungen](https://dashboard.stripe.com/terminal/hardware_orders) nach einer Bestellung mit dem Status „Versendet“ oder „Geliefert“. Klicken Sie auf das Überlaufmenü (⋯) am Ende der Zeile und klicken Sie dann auf **Registrieren**.
1. Wählen Sie auf der Seite **Lesegerät registrieren** ein oder mehrere Lesegerät aus der Hardware-Reihenfolge aus, die Sie registrieren möchten, und klicken Sie dann auf **Registrieren**.
1. Wählen Sie optional einen Namen für das Lesegerät. Wenn Sie mehrere Lesegeräte ausgewählt haben, dient der Name als Präfix und wir benennen die Lesegeräte der Reihe nach (zum Beispiel legen wir für eine bestimmte Eingabe von „Testlesegerät“ die Bezeichnungen „Testlesegerät&nbsp;1“, „Testlesegerät&nbsp;2“ usw. fest).
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihrer Lesegeräte abzuschließen.

#### API

Bei größeren Bereitstellungen sollten Sie es den Nutzerinnen/Nutzern vor Ort ermöglichen, neue Lesegeräte selbst zu empfangen und einzurichten. Erstellen Sie in Ihrer App einen Ablauf zum [Registrieren](https://docs.stripe.com/api/terminal/readers/create.md) eines Lesegeräts mit der Stripe API.

1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Der/die Nutzer/in gibt den Code in Ihre Anwendung ein.
1. Ihre Anwendung sendet den Code an Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode label="Alice's reader" \
  -d location="{{TERMINALLOCATION_ID}}"
```

Um zu prüfen, ob Sie ein Lesegerät korrekt registriert haben, lassen Sie alle an diesem Standort registrierten Lesegeräte auflisten:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [InternetDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-internet-discovery-configuration/index.html)

Nachdem Sie das Lesegerät in Ihrem Konto registriert haben, können Sie mit der Methode `discoverReaders` unter Verwendung der `InternetDiscoveryConfiguration` nach bereits registrierten Lesegeräten suchen, die Sie mit Ihrer Point-of-Sale-Anwendung verbinden können.

Sie können Ihre Erkennung anhand des `location` eingrenzen, bei dem Sie das Lesegerät im vorherigen Schritt registriert haben.

#### Kotlin

```kotlin
var discoveryCancelable: Cancelable? = null

fun onDiscoverReaders() {
    val timeout = 0
    val isSimulated = false

    val config = InternetDiscoveryConfiguration(
        timeout = timeout,
        isSimulated = isSimulated,
        location = ""{{LOCATION_ID}}""
    )

    // Save this cancelable to an instance variable
    discoveryCancelable = Terminal.getInstance().discoverReaders(
        config,
        object : DiscoveryListener {
            override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
                // Display the discovered readers to the user
            }
        },
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}

override fun onStop() {
    super.onStop()

    // If you're leaving the activity or fragment without selecting a reader,
    // make sure you cancel the discovery process or the SDK will be stuck in
    // a discover readers phase.
    discoveryCancelable?.cancel(
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}
```

## Mit einem Lesegerät verbinden [Clientseitig]

> In der Version `5.0.0` des Android-SDK können Sie die Methode `easyConnect` verwenden, um Erkennung und Verbindung des Lesegeräts in einem einzigen API-Aufruf zu kombinieren, um die Integration zu vereinfachen. Weitere Informationen finden Sie im [Migrationsleitfaden zum SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage).

Um Ihre Point-of-Sale-Anwendung mit einem Lesegerät zu verbinden, rufen Sie `connectReader` mit dem ausgewählten Lesegerät unter Verwendung der `InternetConnectionConfiguration` auf.

#### Kotlin

```kotlin
val internetReaderListener = yourInternetReaderListener

val config = InternetConnectionConfiguration(internetReaderListener)
Terminal.getInstance().connectReader(
    firstReader,
    config,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [InternetConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-internet-connection-configuration/index.html)

### Mehrere Verbindungen

Es kann immer nur eine Instanz des Stripe Terminal SDK mit einem Lesegerät verbunden werden. Wenn Sie `connectReader` von einer anderen Anwendung aus aufrufen, ersetzt die eingehende Verbindung standardmäßig die bestehende Verbindung zwischen SDK und Lesegerät, und das zuvor verbundene SDK wird vom Lesegerät getrennt. Die Methode `connectReader` verwendet ein Konfigurationsobjekt mit der Eigenschaft `failIfInUse`, deren Standardwert `false` ist. Wenn Ihre Anwendung `failIfInUse` auf „true“ festlegt, weist der `connectReader`-Aufruf ein alternatives Verhalten auf, bei dem die eingehende Verbindung fehlschlägt, wenn sich das Lesegerät mitten in einem `collectPaymentMethod`- oder `confirmPaymentIntent`-Aufruf befindet, der von einem anderen SDK initiiert wurde. Wenn das Lesegerät mit einem anderen SDK verbunden ist, sich aber im Ruhezustand befindet (der Begrüßungsbildschirm wird angezeigt, bevor `collectPaymentMethod` aufgerufen wird), bewirkt die Einstellung von `failIfInUse` keine Änderung am Verbindungsverhalten und die eingehende Verbindungsanfrage kann die bestehende Verbindung vom SDK zum Lesegerät immer unterbrechen.

#### Kotlin

```kotlin
val failIfInUse = true
val internetReaderListener = yourInternetReaderListener

val config = InternetConnectionConfiguration(internetReaderListener, failIfInUse)
Terminal.getInstance().connectReader(
    reader,
    config,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

|                                                                                                                  | failIfInUse ist „false“ (Standard)                                                                                                                                                                                                                                                          | failIfInUse ist „true“                                                                                                                                                                                                                                                                      |
| ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn das Lesegerät inaktiv ist.                             | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn sich das Lesegerät mitten in der Transaktion befindet. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. | Die eingehende Verbindung schlägt mit einem Lesegerätfehler fehl. Die bestehende Verbindung vom SDK zum Lesegerät wird nicht unterbrochen, und der laufende Befehl wird fortgesetzt.                                                                                                        |

Für eine möglichst unterbrechungsfreie Verbindung in Umgebungen mit mehreren Lesegeräten empfehlen wir, `failIfInUse` beim ersten Verbindungsversuch Ihrer Anwendung auf `true` festzulegen. Erlauben Sie Ihren Nutzer/innen dann, den Verbindungsaufbau zu wiederholen, wobei `failIfInUse` auf `false` gesetzt wird, falls die Verbindung beim ersten Mal fehlschlägt.

Mit dieser Konfiguration kann eine/r Ihrer Nutzer/innen eine Transaktion nicht versehentlich durch eine versehentliche Verbindung zu einem verwendeten Lesegerät unterbrechen, kann aber bei Bedarf trotzdem eine Verbindung herstellen.

### Mit Verbindungsabbrüchen umgehen

- [onDisconnect (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-disconnect-listener/on-disconnect.html)

Ihre App muss den Rückruf `onDisconnect` für Verbindungsabbrüche bei Lesegeräten implementieren. Wenn Sie diesen Rückruf implementieren, zeigen Sie eine Nutzeroberfläche an, die Ihre Nutzer/innen über das getrennte Lesegerät informiert. Sie können `discoverReaders` aufrufen, um nach Lesegeräten zu suchen und die erneute Verbindung zu initiieren.

Ihre App kann versuchen, die Verbindung zum getrennten Lesegerät automatisch wiederherzustellen, oder eine Nutzeroberfläche anzeigen, die Ihre Nutzer/innen auffordert, die Verbindung zu einem anderen Lesegerät wiederherzustellen.

Das Lesegerät kann die Verbindung zu Ihrer App trennen, wenn die Verbindung zum Netzwerk unterbrochen wird. Schalten Sie das Lesegerät aus, um eine unerwartete Unterbrechung zu simulieren.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), InternetReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Automatische Wiederverbindung

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie dessen Seriennummer an einem dauerhaften Datenspeicherort wie beispielsweise der [Shared Preferences API](https://developer.android.com/training/data-storage/shared-preferences) (Android).
1. Wenn Ihre App gestartet wird, suchen Sie an diesem dauerhaften Speicherort nach einer gespeicherten Seriennummer. Wird eine solche gefunden, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, das Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Nutzeroberfläche an, um darauf hinzuweisen, dass eine automatische erneute Verbindung erfolgt.


# Internet-Lesegeräte

> This is a Internet-Lesegeräte for when terminal-sdk-platform is react-native and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=internet.

Auf intelligenten Lesegeräten wird die Stripe-Lesegerätesoftware ausgeführt, um direkt mit Stripe über das Internet zu kommunizieren. Das Verbinden Ihrer App mit einem intelligenten Lesegerät erfordert drei Schritte:

1. Lesegerät im Stripe-Konto [registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader)
1. [Lesegeräte finden](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) mit dem SDK

## Lesegerät registrieren [Serverseitig]

Bevor Sie Ihre Anwendung mit einem intelligenten Lesegerät verbinden können, müssen Sie das Lesegerät in Ihrem Konto registrieren.

#### Dashboard

### Im Dashboard registrieren

Sie können Ihr Lesegerät direkt im [Dashboard](https://dashboard.stripe.com/test/terminal) hinzufügen.

#### Mit Registrierungscode registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Geben Sie den Registrierungscode ein und klicken Sie auf **Weiter**.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Mit Seriennummer registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Suchen Sie auf dem Gerät nach der Seriennummer und geben Sie diese ein. Um mehrere Geräte gleichzeitig zu registrieren, können Sie mehrere, durch Kommas getrennte Seriennummern eingeben.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Nach Hardware-Bestellung registrieren

1. Suchen Sie auf der Seite [Hardware-Bestellungen](https://dashboard.stripe.com/terminal/hardware_orders) nach einer Bestellung mit dem Status „Versendet“ oder „Geliefert“. Klicken Sie auf das Überlaufmenü (⋯) am Ende der Zeile und klicken Sie dann auf **Registrieren**.
1. Wählen Sie auf der Seite **Lesegerät registrieren** ein oder mehrere Lesegerät aus der Hardware-Reihenfolge aus, die Sie registrieren möchten, und klicken Sie dann auf **Registrieren**.
1. Wählen Sie optional einen Namen für das Lesegerät. Wenn Sie mehrere Lesegeräte ausgewählt haben, dient der Name als Präfix und wir benennen die Lesegeräte der Reihe nach (zum Beispiel legen wir für eine bestimmte Eingabe von „Testlesegerät“ die Bezeichnungen „Testlesegerät&nbsp;1“, „Testlesegerät&nbsp;2“ usw. fest).
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihrer Lesegeräte abzuschließen.

#### API

Bei größeren Bereitstellungen sollten Sie es den Nutzerinnen/Nutzern vor Ort ermöglichen, neue Lesegeräte selbst zu empfangen und einzurichten. Erstellen Sie in Ihrer App einen Ablauf zum [Registrieren](https://docs.stripe.com/api/terminal/readers/create.md) eines Lesegeräts mit der Stripe API.

1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Der/die Nutzer/in gibt den Code in Ihre Anwendung ein.
1. Ihre Anwendung sendet den Code an Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode label="Alice's reader" \
  -d location="{{TERMINALLOCATION_ID}}"
```

Um zu prüfen, ob Sie ein Lesegerät korrekt registriert haben, lassen Sie alle an diesem Standort registrierten Lesegeräte auflisten:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders)

Nachdem Sie das Lesegerät in Ihrem Konto registriert haben, können Sie mit der Methode `discoverReaders` nach bereits registrierten Lesegeräten suchen, die Sie mit Ihrer Point-of-Sale-Anwendung verbinden können, und setzen Sie `discoveryMethod` auf `Internet`.

Sie können Ihre Erkennung anhand des `location` eingrenzen, bei dem Sie das Lesegerät im vorherigen Schritt registriert haben.

```js
export default function DiscoverScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
      },
    });

  useEffect(() => {
    const fetchReaders = async () => {
      const { error } = await discoverReaders({
        discoveryMethod: 'internet',
      });
    }

    fetchReaders();
  }, [discoverReaders]);

  return <View />;
}
```

## Mit einem Lesegerät verbinden [Clientseitig]

Um Ihre Point-of-Sale-Anwendung mit einem Lesegerät zu verbinden, rufen Sie mit dem ausgewählten Lesegerät `connectReader` auf.

```js
const { reader, error } = await connectReader({
    reader,
  },
  'internet'
);

if (error) {
  console.log('connectReader error:', error);
  return;
}

console.log('Reader connected successfully', reader);
```

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)

### Mehrere Verbindungen

Es kann immer nur eine Instanz des Stripe Terminal SDK mit einem Lesegerät verbunden werden. Wenn Sie `connectReader` von einer anderen Anwendung aus aufrufen, ersetzt die eingehende Verbindung standardmäßig die bestehende Verbindung zwischen SDK und Lesegerät, und das zuvor verbundene SDK wird vom Lesegerät getrennt. Die Methode `connectReader` verwendet ein Konfigurationsobjekt mit der Eigenschaft `failIfInUse`, deren Standardwert `false` ist. Wenn Ihre Anwendung `failIfInUse` auf „true“ festlegt, weist der `connectReader`-Aufruf ein alternatives Verhalten auf, bei dem die eingehende Verbindung fehlschlägt, wenn sich das Lesegerät mitten in einem `collectPaymentMethod`- oder `confirmPaymentIntent`-Aufruf befindet, der von einem anderen SDK initiiert wurde. Wenn das Lesegerät mit einem anderen SDK verbunden ist, sich aber im Ruhezustand befindet (der Begrüßungsbildschirm wird angezeigt, bevor `collectPaymentMethod` aufgerufen wird), bewirkt die Einstellung von `failIfInUse` keine Änderung am Verbindungsverhalten und die eingehende Verbindungsanfrage kann die bestehende Verbindung vom SDK zum Lesegerät immer unterbrechen.

```js
const connectResult = await terminal.connectReader({reader, failIfInUse: true}, 'internet');
```

|                                                                                                                          | failIfInUse ist „false“ (Standard)                                                                                                                                                                                                                                                             | failIfInUse ist „true“                                                                                                                                                                                                                                                                         |
| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectInternetReader` wird von einem neuen SDK aufgerufen, wenn das Lesegerät inaktiv ist.                             | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDidDisconnect` wird aufgerufen. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDidDisconnect` wird aufgerufen. |
| `connectInternetReader` wird von einem neuen SDK aufgerufen, wenn sich das Lesegerät mitten in der Transaktion befindet. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDidDisconnect` wird aufgerufen. | Die eingehende Verbindung schlägt mit einem Lesegerätfehler fehl. Die bestehende Verbindung vom SDK zum Lesegerät wird nicht unterbrochen, und der laufende Befehl wird fortgesetzt.                                                                                                           |

Für eine möglichst unterbrechungsfreie Verbindung in Umgebungen mit mehreren Lesegeräten empfehlen wir, `failIfInUse` beim ersten Verbindungsversuch Ihrer Anwendung auf `true` festzulegen. Erlauben Sie Ihren Nutzer/innen dann, den Verbindungsaufbau zu wiederholen, wobei `failIfInUse` auf `false` gesetzt wird, falls die Verbindung beim ersten Mal fehlschlägt.

Mit dieser Konfiguration kann eine/r Ihrer Nutzer/innen eine Transaktion nicht versehentlich durch eine versehentliche Verbindung zu einem verwendeten Lesegerät unterbrechen, kann aber bei Bedarf trotzdem eine Verbindung herstellen.

### Mit Verbindungsabbrüchen umgehen

- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)

Ihre App muss den `onDidDisconnect`-Rückruf implementieren, um reagieren zu können, wenn ein die Verbindung eines Lesegeräts unterbrochen wird. Wenn Sie diesen Rückruf implementieren, zeigen Sie eine Nutzeroberfläche an, die Ihre Nutzer/innen über das getrennte Lesegerät benachrichtigt. Sie können `discoverReaders` aufrufen, um nach Lesegeräten zu suchen und die Wiederherstellung der Verbindung zu initiieren.

Ihre App kann versuchen, die Verbindung zum getrennten Lesegerät automatisch wiederherzustellen, oder eine Nutzeroberfläche anzeigen, die Ihre Nutzer/innen auffordert, die Verbindung zu einem anderen Lesegerät wiederherzustellen.

Das Lesegerät kann die Verbindung zu Ihrer App trennen, wenn die Verbindung zum Netzwerk unterbrochen wird. Schalten Sie das Lesegerät aus, um eine unerwartete Unterbrechung zu simulieren.

```js
const terminal = useStripeTerminal({
  onDidDisconnect: (result) => {
    // Consider displaying a UI to notify the user and start rediscovering readers
  },
});
```

### Automatische Wiederverbindung

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Nutzeroberfläche an, um darauf hinzuweisen, dass eine automatische erneute Verbindung erfolgt.


# Internet-Lesegeräte

> This is a Internet-Lesegeräte for when terminal-sdk-platform is java and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=java&reader-type=internet.

Auf intelligenten Lesegeräten wird die Stripe-Lesegerätesoftware ausgeführt, um direkt mit Stripe über das Internet zu kommunizieren. Das Verbinden Ihrer App mit einem intelligenten Lesegerät erfordert drei Schritte:

1. Lesegerät im Stripe-Konto [registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader)
1. [Lesegeräte finden](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) mit dem SDK

## Lesegerät registrieren [Serverseitig]

Bevor Sie Ihre Anwendung mit einem intelligenten Lesegerät verbinden können, müssen Sie das Lesegerät in Ihrem Konto registrieren.

#### Dashboard

### Im Dashboard registrieren

Sie können Ihr Lesegerät direkt im [Dashboard](https://dashboard.stripe.com/test/terminal) hinzufügen.

#### Mit Registrierungscode registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Geben Sie den Registrierungscode ein und klicken Sie auf **Weiter**.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Mit Seriennummer registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Suchen Sie auf dem Gerät nach der Seriennummer und geben Sie diese ein. Um mehrere Geräte gleichzeitig zu registrieren, können Sie mehrere, durch Kommas getrennte Seriennummern eingeben.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Nach Hardware-Bestellung registrieren

1. Suchen Sie auf der Seite [Hardware-Bestellungen](https://dashboard.stripe.com/terminal/hardware_orders) nach einer Bestellung mit dem Status „Versendet“ oder „Geliefert“. Klicken Sie auf das Überlaufmenü (⋯) am Ende der Zeile und klicken Sie dann auf **Registrieren**.
1. Wählen Sie auf der Seite **Lesegerät registrieren** ein oder mehrere Lesegerät aus der Hardware-Reihenfolge aus, die Sie registrieren möchten, und klicken Sie dann auf **Registrieren**.
1. Wählen Sie optional einen Namen für das Lesegerät. Wenn Sie mehrere Lesegeräte ausgewählt haben, dient der Name als Präfix und wir benennen die Lesegeräte der Reihe nach (zum Beispiel legen wir für eine bestimmte Eingabe von „Testlesegerät“ die Bezeichnungen „Testlesegerät&nbsp;1“, „Testlesegerät&nbsp;2“ usw. fest).
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihrer Lesegeräte abzuschließen.

#### API

Bei größeren Bereitstellungen sollten Sie es den Nutzerinnen/Nutzern vor Ort ermöglichen, neue Lesegeräte selbst zu empfangen und einzurichten. Erstellen Sie in Ihrer App einen Ablauf zum [Registrieren](https://docs.stripe.com/api/terminal/readers/create.md) eines Lesegeräts mit der Stripe API.

1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Der/die Nutzer/in gibt den Code in Ihre Anwendung ein.
1. Ihre Anwendung sendet den Code an Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode label="Alice's reader" \
  -d location="{{TERMINALLOCATION_ID}}"
```

Um zu prüfen, ob Sie ein Lesegerät korrekt registriert haben, lassen Sie alle an diesem Standort registrierten Lesegeräte auflisten:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Lesegeräte suchen [Clientseitig]

- [discoverReaders (Java)](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [InternetDiscoveryConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-internet-discovery-configuration/index.html)

Nachdem Sie das Lesegerät in Ihrem Konto registriert haben, können Sie mit der Methode `discoverReaders` unter Verwendung der `InternetDiscoveryConfiguration` nach bereits registrierten Lesegeräten suchen, die Sie mit Ihrer Point-of-Sale-Anwendung verbinden können.

Sie können Ihre Erkennung anhand des `location` eingrenzen, bei dem Sie das Lesegerät im vorherigen Schritt registriert haben.

```java
private Cancelable discoveryCancelable;

public void onDiscoverReaders() {
    int timeout = 0;
    boolean isSimulated = false;

    InternetDiscoveryConfiguration config = new InternetDiscoveryConfiguration(
        timeout,
        ""{{LOCATION_ID}}"",
        isSimulated,
        DiscoveryFilter.None.INSTANCE
    );

    // Save this cancelable to an instance variable
    discoveryCancelable = Terminal.getInstance().discoverReaders(
        config,
        readers -> {
            // Display the discovered readers to the user
        },
        new Callback() {
            @Override
            public void onSuccess() {
                // Placeholder for handling successful operation
            }

            @Override
            public void onFailure(@NotNull TerminalException e) {
                // Placeholder for handling exception
            }
        }
    );
}
```

## Mit einem Lesegerät verbinden [Clientseitig]

> In der Version `1.0.0-b15` des Java-SDK können Sie die Methode [easyConnect](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/easy-connect.html) verwenden, um Erkennung und Verbindung des Lesegeräts in einem einzigen API-Aufruf zu kombinieren, um die Integration zu vereinfachen.

Um Ihre Point-of-Sale-Anwendung mit einem Lesegerät zu verbinden, rufen Sie `connectReader` mit dem ausgewählten Lesegerät unter Verwendung der `InternetConnectionConfiguration` auf.

```java
InternetReaderListener internetReaderListener = yourInternetReaderListener;

InternetConnectionConfiguration config = new InternetConnectionConfiguration(internetReaderListener);

Terminal.getInstance().connectReader(
    reader,
    config,
    new ReaderCallback() {
        @Override
        public void onSuccess(@NotNull Reader reader) {
            // Placeholder for handling successful operation
        }

        @Override
        public void onFailure(@NotNull TerminalException e) {
            // Placeholder for handling exception
        }
    }
);
```

- [connectReader (Java)](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [InternetConnectionConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-connection-configuration/-internet-connection-configuration/index.html)

### Mehrere Verbindungen

Es kann immer nur eine Instanz des Stripe Terminal SDK mit einem Lesegerät verbunden werden. Wenn Sie `connectReader` von einer anderen Anwendung aus aufrufen, ersetzt die eingehende Verbindung standardmäßig die bestehende Verbindung zwischen SDK und Lesegerät, und das zuvor verbundene SDK wird vom Lesegerät getrennt. Die Methode `connectReader` verwendet ein Konfigurationsobjekt mit der Eigenschaft `failIfInUse`, deren Standardwert `false` ist. Wenn Ihre Anwendung `failIfInUse` auf „true“ festlegt, weist der `connectReader`-Aufruf ein alternatives Verhalten auf, bei dem die eingehende Verbindung fehlschlägt, wenn sich das Lesegerät mitten in einem `collectPaymentMethod`- oder `confirmPaymentIntent`-Aufruf befindet, der von einem anderen SDK initiiert wurde. Wenn das Lesegerät mit einem anderen SDK verbunden ist, sich aber im Ruhezustand befindet (der Begrüßungsbildschirm wird angezeigt, bevor `collectPaymentMethod` aufgerufen wird), bewirkt die Einstellung von `failIfInUse` keine Änderung am Verbindungsverhalten und die eingehende Verbindungsanfrage kann die bestehende Verbindung vom SDK zum Lesegerät immer unterbrechen.

```java
boolean failIfInUse = true;
InternetReaderListener internetReaderListener = yourInternetReaderListener;

InternetConnectionConfiguration config =
    new InternetConnectionConfiguration(internetReaderListener, failIfInUse);

Terminal.getInstance().connectReader(
    reader,
    config,
    new ReaderCallback() {
        @Override
        public void onSuccess(@NotNull Reader reader) {
            // Placeholder for handling successful operation
        }

        @Override
        public void onFailure(@NotNull TerminalException e) {
            // Placeholder for handling exception
        }
    }
);
```

|                                                                                                                  | failIfInUse ist „false“ (Standard)                                                                                                                                                                                                                                                          | failIfInUse ist „true“                                                                                                                                                                                                                                                                      |
| ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn das Lesegerät inaktiv ist.                             | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. |
| `connectReader` wird von einem neuen SDK aufgerufen, wenn sich das Lesegerät mitten in der Transaktion befindet. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `onDisconnect` wird aufgerufen. | Die eingehende Verbindung schlägt mit einem Lesegerätfehler fehl. Die bestehende Verbindung vom SDK zum Lesegerät wird nicht unterbrochen, und der laufende Befehl wird fortgesetzt.                                                                                                        |

Für eine möglichst unterbrechungsfreie Verbindung in Umgebungen mit mehreren Lesegeräten empfehlen wir, `failIfInUse` beim ersten Verbindungsversuch Ihrer Anwendung auf `true` festzulegen. Erlauben Sie Ihren Nutzer/innen dann, den Verbindungsaufbau zu wiederholen, wobei `failIfInUse` auf `false` gesetzt wird, falls die Verbindung beim ersten Mal fehlschlägt.

Mit dieser Konfiguration kann eine/r Ihrer Nutzer/innen eine Transaktion nicht versehentlich durch eine versehentliche Verbindung zu einem verwendeten Lesegerät unterbrechen, kann aber bei Bedarf trotzdem eine Verbindung herstellen.

### Mit Verbindungsabbrüchen umgehen

- [onDisconnect (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.callable/-reader-disconnect-listener/on-disconnect.html)

Ihre App muss den Rückruf `onDisconnect` für Verbindungsabbrüche bei Lesegeräten implementieren. Wenn Sie diesen Rückruf implementieren, zeigen Sie eine Nutzeroberfläche an, die Ihre Nutzer/innen über das getrennte Lesegerät informiert. Sie können `discoverReaders` aufrufen, um nach Lesegeräten zu suchen und die erneute Verbindung zu initiieren.

Ihre App kann versuchen, die Verbindung zum getrennten Lesegerät automatisch wiederherzustellen, oder eine Nutzeroberfläche anzeigen, die Ihre Nutzer/innen auffordert, die Verbindung zu einem anderen Lesegerät wiederherzustellen.

Das Lesegerät kann die Verbindung zu Ihrer App trennen, wenn die Verbindung zum Netzwerk unterbrochen wird. Schalten Sie das Lesegerät aus, um eine unerwartete Unterbrechung zu simulieren.

```java
public class CustomReaderListener implements InternetReaderListener {
    // ...

    @Override
    public void onDisconnect(@NotNull DisconnectReason reason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Automatische Wiederverbindung

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

1. Wenn Sie erfolgreich eine Verbindung zu einem Lesegerät hergestellt haben, speichern Sie seine Seriennummer an einem dauerhaften Datenspeicherort, zum Beispiel in der [Preferences API](https://docs.oracle.com/javase/8/docs/api/java/util/prefs/Preferences.html).
1. Wenn Ihre App gestartet wird, suchen Sie an diesem dauerhaften Speicherort nach einer gespeicherten Seriennummer. Wird eine solche gefunden, rufen Sie die Methode `discoverReaders` auf, damit Ihre Anwendung erneut versuchen kann, das Lesegerät zu finden.
1. Wenn die gespeicherte Seriennummer einem der erkannten Lesegeräte entspricht, versuchen Sie, eine Verbindung zu diesem Lesegerät herzustellen, wobei Sie das übereinstimmende reader-Objekt aus dem Aufruf von `discoverReaders` verwenden. Wenn das zuvor verbundene Lesegerät nicht gefunden wird, brechen Sie den Erkennungsvorgang ab.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Nutzeroberfläche an, um darauf hinzuweisen, dass eine automatische erneute Verbindung erfolgt.


# Internet-Lesegeräte

> This is a Internet-Lesegeräte for when terminal-sdk-platform is dotnet and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=dotnet&reader-type=internet.

Auf intelligenten Lesegeräten wird die Stripe-Lesegerätesoftware ausgeführt, um direkt mit Stripe über das Internet zu kommunizieren. Das Verbinden Ihrer App mit einem intelligenten Lesegerät erfordert drei Schritte:

1. Lesegerät im Stripe-Konto [registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader)
1. [Lesegeräte finden](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK
1. [Mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) mit dem SDK

## Lesegerät registrieren [Serverseitig]

Bevor Sie Ihre Anwendung mit einem intelligenten Lesegerät verbinden können, müssen Sie das Lesegerät in Ihrem Konto registrieren.

#### Dashboard

### Im Dashboard registrieren

Sie können Ihr Lesegerät direkt im [Dashboard](https://dashboard.stripe.com/test/terminal) hinzufügen.

#### Mit Registrierungscode registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Geben Sie den Registrierungscode ein und klicken Sie auf **Weiter**.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Mit Seriennummer registrieren

1. Klicken Sie auf der Seite [Lesegeräte](https://dashboard.stripe.com/terminal/readers) auf **Lesegerät registrieren**.
1. Suchen Sie auf dem Gerät nach der Seriennummer und geben Sie diese ein. Um mehrere Geräte gleichzeitig zu registrieren, können Sie mehrere, durch Kommas getrennte Seriennummern eingeben.
1. Wählen Sie optional einen Namen für das Lesegerät aus.
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihres Lesegeräts abzuschließen.

#### Nach Hardware-Bestellung registrieren

1. Suchen Sie auf der Seite [Hardware-Bestellungen](https://dashboard.stripe.com/terminal/hardware_orders) nach einer Bestellung mit dem Status „Versendet“ oder „Geliefert“. Klicken Sie auf das Überlaufmenü (⋯) am Ende der Zeile und klicken Sie dann auf **Registrieren**.
1. Wählen Sie auf der Seite **Lesegerät registrieren** ein oder mehrere Lesegerät aus der Hardware-Reihenfolge aus, die Sie registrieren möchten, und klicken Sie dann auf **Registrieren**.
1. Wählen Sie optional einen Namen für das Lesegerät. Wenn Sie mehrere Lesegeräte ausgewählt haben, dient der Name als Präfix und wir benennen die Lesegeräte der Reihe nach (zum Beispiel legen wir für eine bestimmte Eingabe von „Testlesegerät“ die Bezeichnungen „Testlesegerät&nbsp;1“, „Testlesegerät&nbsp;2“ usw. fest).
1. Wenn Sie bereits einen Standort erstellt haben, wählen Sie den neuen Standort des Lesegeräts aus. Andernfalls erstellen Sie einen Standort, indem Sie auf **+ Neu hinzufügen** klicken.
1. Klicken Sie auf **Registrieren**, um die Registrierung Ihrer Lesegeräte abzuschließen.

#### API

Bei größeren Bereitstellungen sollten Sie es den Nutzerinnen/Nutzern vor Ort ermöglichen, neue Lesegeräte selbst zu empfangen und einzurichten. Erstellen Sie in Ihrer App einen Ablauf zum [Registrieren](https://docs.stripe.com/api/terminal/readers/create.md) eines Lesegeräts mit der Stripe API.

1. Wenn Sie über ein [intelligentes Lesegerät](https://docs.stripe.com/terminal/smart-readers.md) verfügen, geben Sie bitte die Tastenkombination `0-7-1-3-9` ein, um einen eindeutigen Registrierungscode anzuzeigen. Wenn Sie ein BBPOS&nbsp;WisePOS&nbsp;E oder einen Stripe Reader&nbsp;S700/S710 besitzen, gehen Sie bitte zu den [Lesegeräteeinstellungen](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) und tippen Sie auf **Pairing-Code generieren**.
1. Der/die Nutzer/in gibt den Code in Ihre Anwendung ein.
1. Ihre Anwendung sendet den Code an Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode label="Alice's reader" \
  -d location="{{TERMINALLOCATION_ID}}"
```

Um zu prüfen, ob Sie ein Lesegerät korrekt registriert haben, lassen Sie alle an diesem Standort registrierten Lesegeräte auflisten:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Lesegeräte suchen [Clientseitig]

- [DiscoverReadersAsync (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME)

Nachdem Sie das Lesegerät in Ihrem Konto registriert haben, können Sie mit der Methode `DiscoverReadersAsync` nach bereits registrierten Lesegeräten suchen, die Sie mit Ihrer Point-of-Sale-Anwendung verbinden können.

Sie können Ihre Erkennung anhand des `location` eingrenzen, bei dem Sie das Lesegerät im vorherigen Schritt registriert haben.

```csharp
public async Task<IImmutableList<Reader>> DiscoverReadersAsync()
{

    try
    {
        var config = new DiscoveryConfiguration.Builder()
          .SetIsSimulated(false)
          .SetLocation("{{LOCATION_ID}}")
          .Build();

        Console.WriteLine("Discovered readers");
        return await Terminal.Instance.DiscoverReadersAsync(config);
    }
    catch (TerminalException ex)
    {
        // Placeholder for handling exception
        throw;
    }

}
```

## Mit einem Lesegerät verbinden [Clientseitig]

Um Ihre Point-of-Sale-Anwendung mit einem Lesegerät zu verbinden, rufen Sie `ConnectInternetReaderAsync` mit dem ausgewählten Lesegerät auf.

```csharp
// after selecting a reader to connect to
Reader connectedReader;
try
{
    var config = new InternetConnectionConfiguration.Builder()
        .Build();
    connectedReader = await Terminal.Instance.ConnectInternetReaderAsync(selectedReader, config);
    Console.WriteLine("Connected to reader");
}
catch (TerminalException ex)
{
    // Placeholder for handling exception
    throw;
}
```

- [ConnectInternetReaderAsync (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME)

### Mehrere Verbindungen

Es kann immer nur eine Instanz des Stripe Terminal SDK mit einem Lesegerät verbunden werden. Wenn Sie `ConnectInternetReaderAsync` von einer anderen Anwendung aus aufrufen, ersetzt die eingehende Verbindung standardmäßig die bestehende Verbindung zwischen SDK und Lesegerät, und das zuvor verbundene SDK wird vom Lesegerät getrennt. Die Methode `ConnectInternetReaderAsync` verwendet ein Konfigurationsobjekt mit der Eigenschaft `failIfInUse`, deren Standardwert `false` ist. Wenn Ihre Anwendung `failIfInUse` auf „true“ festlegt, weist der `ConnectInternetReaderAsync`-Aufruf ein alternatives Verhalten auf, bei dem die eingehende Verbindung fehlschlägt, wenn sich das Lesegerät mitten in einem `CollectPaymentMethodAsync`- oder `ConfirmPaymentIntentAsymc`-Aufruf befindet, der von einem anderen SDK initiiert wurde. Wenn das Lesegerät mit einem anderen SDK verbunden ist, sich aber im Ruhezustand befindet (der Begrüßungsbildschirm wird angezeigt, bevor `CollectPaymentMethodAsync` aufgerufen wird), bewirkt die Einstellung von `failIfInUse` keine Änderung am Verbindungsverhalten und die eingehende Verbindungsanfrage kann die bestehende Verbindung vom SDK zum Lesegerät immer unterbrechen.

```csharp
// after selecting a reader to connect to
Reader connectedReader;
try
{
    var config = new InternetConnectionConfiguration.Builder()
        .SetFailIfInUse(true)
        .Build();
    connectedReader = await Terminal.Instance.ConnectInternetReaderAsync(selectedReader, config);
    Console.WriteLine("Connected to reader");
}
catch (TerminalException ex)
{
    // Placeholder for handling exception
    throw;
}
```

|                                                                                                                               | FailIfInUse ist „false“ (Standard)                                                                                                                                                                                                                                                                          | FailIfInUse ist „true“                                                                                                                                                                                                                                                                                      |
| ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ConnectInternetReaderAsync` wird von einem neuen SDK aufgerufen, wenn das Lesegerät inaktiv ist.                             | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `OnUnexpectedReaderDisconnect` wird aufgerufen. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `OnUnexpectedReaderDisconnect` wird aufgerufen. |
| `ConnectInternetReaderAsync` wird von einem neuen SDK aufgerufen, wenn sich das Lesegerät mitten in der Transaktion befindet. | Die vorhandene Verbindung zwischen SDK und Lesegerät wird unterbrochen, und das neue SDK stellt eine Verbindung mit dem Lesegerät her. Der nächste Befehl aus dem zuvor verbundenen SDK schlägt mit einem Lesegerät-Fehler fehl, und die Methode dieser App `OnUnexpectedReaderDisconnect` wird aufgerufen. | Die eingehende Verbindung schlägt mit einem Lesegerätfehler fehl. Die bestehende Verbindung vom SDK zum Lesegerät wird nicht unterbrochen, und der laufende Befehl wird fortgesetzt.                                                                                                                        |

Für eine möglichst unterbrechungsfreie Verbindung in Umgebungen mit mehreren Lesegeräten empfehlen wir, `failIfInUse` beim ersten Verbindungsversuch Ihrer Anwendung auf `true` festzulegen. Erlauben Sie Ihren Nutzer/innen dann, den Verbindungsaufbau zu wiederholen, wobei `failIfInUse` auf `false` gesetzt wird, falls die Verbindung beim ersten Mal fehlschlägt.

Mit dieser Konfiguration kann eine/r Ihrer Nutzer/innen eine Transaktion nicht versehentlich durch eine versehentliche Verbindung zu einem verwendeten Lesegerät unterbrechen, kann aber bei Bedarf trotzdem eine Verbindung herstellen.

### Mit Verbindungsabbrüchen umgehen

- [TerminalListener (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME)

Ihre App muss den Rückruf `OnUnexpectedReaderDisconnect` für Verbindungsabbrüche bei Lesegeräten implementieren. Wenn Sie diesen Rückruf implementieren, zeigen Sie eine Nutzeroberfläche an, die Ihre Nutzer/innen über das getrennte Lesegerät informiert. Sie können `DiscoverReadersAsync` aufrufen, um nach Lesegeräten zu suchen und die erneute Verbindung zu initiieren.

Ihre App kann versuchen, die Verbindung zum getrennten Lesegerät automatisch wiederherzustellen, oder eine Nutzeroberfläche anzeigen, die Ihre Nutzer/innen auffordert, die Verbindung zu einem anderen Lesegerät wiederherzustellen.

Das Lesegerät kann die Verbindung zu Ihrer App trennen, wenn die Verbindung zum Netzwerk unterbrochen wird. Schalten Sie das Lesegerät aus, um eine unerwartete Unterbrechung zu simulieren.

```csharp
public class TerminalListener : ITerminalListener
{

    // ...

    Terminal.InitTerminal(
        connectionTokenProvider: connectionTokenProvider,
        terminalListener: this,
        offlineListener: offlineListener,
        applicationInformation: applicationInformation
    );

    // ITerminalListener
    public void OnUnexpectedReaderDisconnect(Reader reader)
    {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

}
```

### Automatische Wiederverbindung

Stripe Terminal verbindet sich nicht automatisch erneut mit einem Lesegerät, wenn Ihre Anwendung gestartet wird. Stattdessen können Sie einen Wiederverbindungsablauf erstellen, indem Sie Lesegerät-IDs speichern und versuchen, beim Start eine Verbindung zu einem bekannten Lesegerät herzustellen.

Zeigen Sie während des Erkennungs- und Verbindungsvorgangs eine Nutzeroberfläche an, um darauf hinzuweisen, dass eine automatische erneute Verbindung erfolgt.


# Tap to Pay auf dem iPhone

> This is a Tap to Pay auf dem iPhone for when terminal-sdk-platform is ios and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=tap-to-pay.

Mit Tap to Pay auf dem iPhone können Nutzer/innen mit einem [kompatiblen iPhone](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices) und dem [Stripe Terminal SDK](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=ios) persönlich kontaktlose Zahlungen akzeptieren. Tap to Pay auf dem iPhone bietet Unterstützung für kontaktlose Karten von Visa, Mastercard, American Express und Discover sowie für NFC-basierte mobile Wallets (Apple Pay, Google Pay und Samsung Pay). Tap to Pay auf dem iPhone ist im Terminal iOS SDK enthalten und ermöglicht Zahlungen direkt in Ihrer mobilen iOS-App.

## Lesegeräte entdecken

- [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:)
- [TapToPayDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Reader%20Discovery%20%26%20Connection.html#/c:objc\(cs\)SCPTapToPayDiscoveryConfiguration)

Verwenden Sie die [discoverReaders](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:)-Methode, um festzustellen, ob Tap to Pay auf Ihrem iPhone unterstützt wird.

Der `completion`-Handler wird mit einem Fehler aufgerufen, wenn Ihre Anwendung auf einem Gerät ausgeführt wird, das die [unterstützten Gerätekriterien](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices) nicht erfüllt.

#### Swift

```swift
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {

    var discoverCancelable: Cancelable?

    // ...

    // Action for a "Discover Readers" button
    func discoverReadersAction() throws {
        let config = try TapToPayDiscoveryConfigurationBuilder().build()
        // In addition to Terminal's completion block methods, Swift async alternatives are available.
        // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example
        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
            if let error = error {
                print("discoverReaders failed: \(error)")
            } else {
                print("discoverReaders succeeded")
            }
        }
    }

    // ...

    // MARK: DiscoveryDelegate

    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {
        // In your app, display the ability to use your phone as a reader
        // Call `connectReader` to initiate a session with the phone
    }
}
```

## Mit einem Lesegerät verbinden

> In Version `5.1.0` des iOS-SDK können Sie die `easyConnect`-Methode verwenden, um Erkennung und Verbindung des Lesegeräts in einem einzigen API-Aufruf zu kombinieren, um die Integration zu vereinfachen. Weitere Informationen finden Sie im [Migrationsleitfaden zum SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios).

- [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:)
- [TapToPayConnectionConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTapToPayConnectionConfiguration.html)

Um Zahlungen über Tap to Pay auf dem iPhone-anzunehmen, stellen Sie der Methode `connectReader` das erkannte Lesegerät bereit. Sie müssen außerdem [einen Delegaten erstellen](https://docs.stripe.com/terminal/payments/connect-reader.md#device-setup), damit eventuell erforderliche Aktualisierungen auf das Lesegerät aufgespielt werden können.

Sie müssen [Ihr Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei Einrichtung der Verbindung bei einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Erstellen Sie dazu eine `SCPTapToPayConnectionConfiguration` und verwenden Sie diese, wobei Sie beim Herstellen der Verbindung `locationId` auf die entsprechende Standort-ID festlegen.

Legen Sie die `display_name` fest, um den Namen des Unternehmens beim Erstellen eines Standorts darzustellen. Ihre Kundinnen/Kunden sehen den `display_name` des Standorts auf dem Bildschirm des Geräts, es sei denn, Sie geben beim Verbinden mit einem Lesegerät explizit den Namen eines Unternehmens an. Sie können vorhandene Standorte nach Bedarf bearbeiten, um diesen Text anzupassen.

Wenn Sie [Destination Charges mit on_behalf_of](https://docs.stripe.com/terminal/features/connect.md#destination-payment-intents) verwenden, müssen Sie auch die ID des verbundenen Kontos in `SCPTapToPayConnectionConfiguration` angeben.

#### Swift

```swift
// Call `connectReader` with the selected reader and a connection config
// to register to a location as set by your app.
let connectionConfig = try TapToPayConnectionConfigurationBuilder.init(locationId: ""{{LOCATION_ID}}"")
.delegate(yourTapToPayReaderDelegate)
.build()
Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in
    if let reader = reader {
        print("Successfully connected to reader: \(reader)")
    } else if let error = error {
        print("connectReader failed: \(error)")
    }
}
```

### Umgang mit Geräteeinrichtung

Wenn Sie eine Verbindung zu einem kompatiblen Tap to Pay auf dem iPhone-Lesegerät herstellen, ist möglicherweise eine Konfigurationsaktualisierung erforderlich, die einige Minuten in Anspruch nehmen kann. Wir empfehlen, sich vorab im Hintergrund mit dem Lesegerät zu verbinden, um die Wartezeit für Unternehmen zu reduzieren.

Stellen Sie sicher, dass Ihre Anwendung `SCPTapToPayReaderDelegate` implementiert, um die Konfigurationsschritte abzuwickeln und Benachrichtigungen an Ihr Unternehmen in den Standby-Modus zu bringen. Die Konfigurationsschritte werden Ihnen als Software-Update angezeigt, sodass Sie Ihren Unternehmen den Fortschritt entsprechend anzeigen können.

#### Swift

```swift
class APPReaderViewController: TapToPayReaderDelegate {

    // MARK: TapToPayReaderDelegate

    // ...

    func tapToPayReader(_ reader: Reader, didStartInstallingUpdate update: ReaderSoftwareUpdate, cancelable: Cancelable?) {
        // In your app, let the user know that an update is being installed on the reader
    }

    func tapToPayReader(_ reader: Reader, didReportReaderSoftwareUpdateProgress progress: Float) {
        // The update or configuration process has reached the specified progress (0.0 to 1.0)
        // If you are displaying a progress bar or percentage, this can be updated here
    }

    func tapToPayReader(_ reader: Reader, didFinishInstallingUpdate update: ReaderSoftwareUpdate?, error: Error?) {
        // The reader has finished installing an update
        // If `error` is nil, it is safe to proceed and start collecting payments
        // Otherwise, check the value of `error` for more information on what went wrong
    }

    func tapToPayReader(_ reader: Reader, didRequestReaderDisplayMesage displayMessage: ReaderDisplayMessage) {
        // This is called to request that a prompt be displayed in your app.
        // Use Terminal.stringFromReaderDisplayMessage(:) to get a user-facing string for the prompt
    }

    func tapToPayReader(_ reader: Reader, didRequestReaderInput inputOptions: ReaderInputOptions = []) {
        // This is called when the reader begins waiting for input
        // Use Terminal.stringFromReaderInputOptions(:) to get a user-facing string for the input options
    }

    // ...
}
```

### Kontoverknüpfung und Allgemeine Geschäftsbedingungen von Apple

Alle Benutzer müssen die Allgemeinen Geschäftsbedingungen für Tap to Pay auf dem iPhone von Apple akzeptieren, bevor sie zum ersten Mal Zahlungen akzeptieren. Für Connect-Benutzer muss jedes verbundene Konto die Allgemeinen Geschäftsbedingungen einzeln akzeptieren, wenn:

- Ein/e Connect-Nutzer/in erstellt Direct Charges
- Ein/e Connect-Nutzer/in erstellt eine Destination Charge und gibt ein `on_behalf_of`-Konto an

Benutzer können die Allgemeinen Geschäftsbedingungen von Apple für Tap to Pay auf dem iPhone im Web akzeptieren, bevor sie sich zum ersten Mal mit dem Lesegerät verbinden, indem sie [Onboarding-Links](https://docs.stripe.com/api/terminal/onboarding-link.md?api-version=2025-07-30.preview) verwenden. Alternativ werden den Benutzern die Allgemeinen Geschäftsbedingungen von Apple für Tap to Pay auf dem iPhone angezeigt, wenn sie sich zum ersten Mal in einer Mobilanwendung mit dem Lesegerät verbinden. Um die Allgemeinen Geschäftsbedingungen von Apple zu akzeptieren, muss die/der Nutzer/in eine gültige Apple-ID angeben, die das Unternehmen repräsentiert. Nachdem die Nutzer die Nutzungsbedingungen für “Tap to Pay” auf dem iPhone von Apple akzeptiert haben, werden sie bei nachfolgenden Verbindungen mit demselben Stripe-Konto nicht erneut aufgefordert, auch nicht auf anderen Mobilgeräten.
![Dreistufiger Ablauf, der die Anmeldung mit Apple ID, die Zustimmung zu den Konditionen und die Erfolgsmeldung für Tap to Pay auf dem iPhone zeigt](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png)

Verknüpfen Sie Ihr Apple-ID-Konto, um Tap to Pay-Zahlungen zu akzeptieren

Jedes iPhone kann innerhalb eines Zeitraums von 24&nbsp;Stunden bis zu 3 eindeutige Stripe-Konten in verschiedenen Apps verwenden, wenn `connectReader` für Tap to Pay auf dem iPhone aufgerufen wird. Wenn innerhalb desselben 24-Stunden-Zeitraums weitere Konten für das Gerät verwendet werden, löst die Methode `connectReader` den Fehler [SCPErrorTapToPayReaderMerchantBlocked](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPError.html#/c:@E@SCPError@SCPErrorTapToPayReaderMerchantBlocked) aus.

Weitere Informationen zur Kontoverknüpfung erhalten Sie im Abschnitt mit den Tap to Pay auf dem iPhone-Unternehmensinformationen der [Apple Tap to Pay auf dem iPhone FAQ](https://register.apple.com/tap-to-pay-on-iphone/faq.html).

## Umgang mit Verbindungsabbrüchen

Die Verbindung zum Lesegerät wird getrennt, wenn Ihre Anwendung in den Hintergrund geschaltet wird oder wenn die Verbindung zu Ihrem iPhone unterbrochen wird. Es gibt zwei Möglichkeiten, dies zu handhaben:

- [TapToPayReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPTapToPayReaderDelegate.html)

#### Trennen Sie die Verbindung manuell

Ihre Anwendung muss die Delegatmethode [SCPTapToPayReaderDelegate reader:didDisconnect:](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didDisconnect:) implementieren, um diesen Verbindungsabbruch zu handhaben. Sie können diesen Rückruf als Gelegenheit nutzen, um den/die Nutzer/in darüber zu informieren, dass etwas schiefgegangen ist und dass Sie eine Internetverbindung benötigen, um fortzufahren. Zusätzlich können Sie die Verbindung zum Lesegerät manuell wiederherstellen, wenn Ihre Anwendung wieder in den Vordergrund tritt.

#### Swift

```swift
import StripeTerminal

class ReaderViewController: UIViewController, TapToPayReaderDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set the reader delegate when connecting to a reader
    }

    // ...



    func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }
}
```

#### Automatisch versuchen, die Verbindung wiederherzustellen

Implementieren Sie die automatischen Wiederverbindungsmethoden im `SCPTapToPayReaderDelegate`. Anschließend müssen Sie `SCPTapToPayReaderDelegate` an Ihre `SCPTapToPayConnectionConfiguration` übergeben.

#### Swift

```swift
let connectionConfig = try TapToPayConnectionConfigurationBuilder(locationId: locationId)
  .delegate(yourTapToPayReaderDelegate)
  .build()

Terminal.shared.connectReader(
  reader,
  connectionConfig: connectionConfig,
  completion: connectCompletion
)
```

Wenn Sie automatisch versuchen, die Verbindung wiederherzustellen, geschieht Folgendes:

1. Wenn die Verbindung getrennt wird, versucht das SDK automatisch, die Verbindung wiederherzustellen, und benachrichtigt Sie über `onReaderReconnectStarted`. Stellen Sie sicher, dass Ihre App meldet, dass die Verbindung unterbrochen wurde und eine erneute Verbindung durchgeführt wird.
   - Sie können den Verbindungsversuch jederzeit mit dem `Cancelable`-Objekt stoppen.
1. Wenn das SDK erfolgreich erneut mit dem Lesegerät verbunden ist, benachrichtigt Stripe Sie über `onReaderReconnectSucceeded`. Stellen Sie sicher, dass Ihre App meldet, dass die Verbindung wiederhergestellt wurde, und um den normalen Betrieb fortzusetzen.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann, benachrichtigt Stripe Sie über `onReaderReconnectFailed` und `reader:didDisconnect:`. Stellen Sie sicher, dass Ihre App eine unerwartete Trennung der Verbindung meldet.

#### Swift

```swift
import StripeTerminal

extension ReaderViewController: TapToPayReaderDelegate {
    // MARK: ReconnectionDelegate

    func reader(_ reader: Reader, didStartReaderReconnect cancelable: Cancelable) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    func readerDidSucceedReaderReconnect(_ reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }
    func readerDidFailReaderReconnect(_ reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }
}
```


# Tap to Pay auf Android

> This is a Tap to Pay auf Android for when terminal-sdk-platform is android and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=tap-to-pay.

Mit Tap to Pay auf Android (TTPA) können Nutzer/innen kontaktlose Vor-Ort-Zahlungen mit [kompatiblen NFC-fähigen Android-Geräten](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices) annehmen. TTPA benötigt die neueste Version des [Terminal-Android-SDK](https://stripe.dev/stripe-terminal-android/). TTPA unterstützt kontaktlose Karten von Visa, Mastercard und American Express sowie NFC-basierte mobile Wallets (Apple Pay, Google Pay und Samsung Pay). TTPA ist eine Erweiterung des Terminal-Android-SDK und ermöglicht Zahlungen direkt in Ihrer Android-App.

Befolgen Sie diese Schritte, um Ihre App mit dem Tap to Pay-Lesegerät auf einem unterstützten Android-Gerät zu verbinden:

1. [Initialisieren Sie das SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) für TTPA.
1. [Erkennen Sie Lesegeräte](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK, um die Gerätekompatibilität zu bestätigen.
1. Stellen Sie mit dem SDK eine [Verbindung mit einem Lesegerät her](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader), um Zahlungen anzunehmen.
1. [Handhaben Sie unerwartete Verbindungsabbrüche](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects), um sicherzustellen, dass Ihre Nutzer/innen weiterhin Zahlungen annehmen können, wenn das Lesegerät unerwartet getrennt wird.

Wenn Ihre Anwendung auf einem Gerät ausgeführt wird, das die [Kriterien für unterstützte Geräte](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices) nicht erfüllt, gibt das SDK eine `TerminalException` zurück, die zusätzlichen Kontext in einem `onFailure`-Rückruf bereitstellt.

## SDK initialisieren

- [TapToPay (Android)](https://stripe.dev/stripe-terminal-android/cots/com.stripe.stripeterminal.taptopay/-tap-to-pay/-companion/is-in-tap-to-pay-process.html)

TTPA arbeitet in einem speziellen Prozess, um Transaktionen sicherer zu machen. Bei diesem Vorgang wird eine zweite Instanz Ihrer `Application` erstellt. Um unerwartete Fehler zu vermeiden, die durch die Ausführung Ihres Codes in diesem Prozess verursacht werden, können Sie die Initialisierung in Ihrer `Application` in diesem Prozess überspringen, indem Sie `TapToPay.isInTapToPayProcess()` aktivieren.

```kotlin
// Substitute with your application name, and remember to keep it the same as your AndroidManifest.xml
class StripeTerminalApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // Skip initialization if running in the TTPA process.
        if (TapToPay.isInTapToPayProcess()) return

        // For example, this will be skipped.
        TerminalApplicationDelegate.onCreate(this)
    }
}
```

## Lesegeräte entdecken

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [TapToPayDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-tap-to-pay-discovery-configuration/index.html)

Verwenden Sie die `discoverReaders`-Methode, um die Hardware-Unterstützung für das Tap to Pay auf dem Android-Gerät zu ermitteln. `discoverReaders` verifiziert die folgenden Anforderungen an das Android-Gerät:

- Verfügt über einen funktionierenden, integrierten NFC-Sensor und einen ARM-basierten Prozessor
- Führt Android 13 oder höher aus
- Hat einen Keystore mit Hardware-Support für ECDH ([`FEATURE_HARDWARE_KEYSTORE`](https://developer.android.com/reference/android/content/pm/PackageManager#FEATURE_HARDWARE_KEYSTORE) Version muss 100 oder höher sein)
- Bei der nicht simulierten Version des Tap to Pay-Lesegeräts kann die Anwendung nicht debuggt werden.

Ihre Anwendung *muss* im Vordergrund stehen, damit der Tap-to-Pay-Lesegerätedienst erfolgreich gestartet werden kann.

Wenn Ihre Anwendung auf einem Gerät ausgeführt wird, das die obigen Anforderungen nicht erfüllt, wird der Rückruf `onFailure` mit einer `TerminalException` zurückgegeben, die einen [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) und weiteren Kontext enthält. Die Fehler in dieser Phase können von den Endnutzer/innen nicht behoben werden.

Die Verwendung der nicht simulierten Produktionsversion des Tap-to-Pay-Lesegeräts mit debuggbaren Anwendungen oder mit aktivierten Entwickler-Optionen des Geräts ist nicht möglich. Um Ihre Integration mit dem Lesegerät Tap to Pay auf Android zu testen, setzen Sie `TapToPayDiscoveryConfiguration.isSimulated` während der Lesegeräterkennung auf `true`. Sie müssen diesen Wert in der Release-Version Ihrer Anwendung auf `false` festlegen.

#### Kotlin

```kotlin
var discoverCancelable: Cancelable? = null

fun onDiscoverReaders() {
    val isApplicationDebuggable = 0 != applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE
    val config = TapToPayDiscoveryConfiguration(isSimulated = isApplicationDebuggable)

    // Save this cancelable to an instance variable
    discoverCancelable = Terminal.getInstance().discoverReaders(
        config,
        object : DiscoveryListener {
            override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
                // Automatically connect to supported mobile readers
            }
        },
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}

override fun onStop() {
    super.onStop()

    // If you're leaving the activity or fragment without selecting a reader,
    // make sure you cancel the discovery process or the SDK will be stuck in
    // a discover readers phase
    discoverCancelable?.cancel(
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}
```

Um zu prüfen, ob ein Gerät zur Laufzeit die Tap to Pay-Hardware- und Betriebssystemanforderungen erfüllt, verwenden Sie die [Terminal.supportsReadersOfType](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/supports-readers-of-type.html)-Funktion. Als Teil der Initialisierung des Terminal SDK erfordert diese Funktion, dass Ihr/e Endnutzer/in Berechtigungsanfragen für den Zugriff auf den Standort und Bluetooth akzeptiert. Die Ausführung dieser Funktion dauert bei den meisten Geräten etwa 10&nbsp;Millisekunden.

## Mit einem Lesegerät verbinden

> In Version `5.0.0` des Android-SDK können Sie die `easyConnect`-Methode verwenden, um Erkennung und Verbindung des Lesegeräts in einem einzigen API-Aufruf zu kombinieren, um die Integration zu vereinfachen. Weitere Informationen finden Sie im [Migrationsleitfaden zum SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage).

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [TapToPayConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-tap-to-pay-connection-configuration/index.html)

Um Tap to Pay-Zahlungen anzunehmen, geben Sie das erkannte Lesegerät aus dem vorherigen Schritt für die Methode `connectReader` an.

`connectReader` überprüft, ob das Android-Gerät die folgenden Anforderungen erfüllt:

- Ist nicht gerootet und der Bootloader des Geräts ist gesperrt und unverändert
- Es wurde ein Sicherheitsupdate aus den letzten 12&nbsp;Monaten installiert
- Nutzt Google Mobil Services und hat die Google Play Store-App installiert
- Es besteht eine stabile Internetverbindung
- Es wird das unveränderte vom Hersteller bereitgestellte Betriebssystem ausgeführt
- Die Anwendung verwendet die Tap to Pay-SDK-Version 2.20.0 oder höher
- Entwickleroptionen sind für die nicht simulierte Version des Tap to Pay Lesegeräts deaktiviert

Wenn Ihre Anwendung auf einem Gerät ausgeführt wird, das die obigen Anforderungen nicht erfüllt, wird der Rückruf `onFailure` mit einer `TerminalException` zurückgegeben, die einen [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) und zusätzlichen Kontext enthält. Der/die Endnutzer/in kann bei einigen der [Fehlerursachen](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) Maßnahmen ergreifen. Beispiel:

- `STRIPE_API_CONNECTION_ERROR`: Der/die Nutzer/in kann eine Verbindung zu einer stabilen Internetquelle herstellen.
- `TAP_TO_PAY_UNSUPPORTED_ANDROID_VERSION`: Der/die Nutzer/in kann ein Upgrade seines/ihres Betriebssystems durchführen, wenn ein Update vom Gerätehersteller verfügbar ist.

Sie müssen [Ihr Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei Einrichtung der Verbindung bei einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Erstellen Sie dazu eine `TapToPayConnectionConfiguration` und verwenden Sie diese, wobei Sie beim Herstellen der Verbindung `locationId` auf die entsprechende Standort-ID festlegen.

#### Kotlin

```kotlin
val tapToPayReaderListener = yourTapToPayReaderListener
val autoReconnectOnUnexpectedDisconnect = true

val config = TapToPayConnectionConfiguration(
  ""{{LOCATION_ID}}"",
  autoReconnectOnUnexpectedDisconnect,
  tapToPayReaderListener
),
Terminal.getInstance().connectReader(
  firstReader,
  config,
  object : ReaderCallback {
      override fun onSuccess(reader: Reader) {
          // Placeholder for handling successful operation
      }

      override fun onFailure(e: TerminalException) {
          // Placeholder for handling exception
      }
  }
)
```

## Umgang mit unerwarteten Verbindungsabbrüchen

- [TapToPayReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-tap-to-pay-reader-listener/index.html)

Zwischen Ihrer App und dem Lesegerät kann es zu unerwarteten Verbindungsabbrüchen kommen. Zum Beispiel kann die Verbindung des Tap to Pay-Lesegeräts aus folgenden Gründen unerwartet getrennt werden:

- Das Android-Betriebssystem beendet den Tap to Pay-Lesegerätdienst aufgrund von Speicherbeschränkungen.
- Die Internetverbindung des Geräts wird getrennt.

Es gibt zwei Möglichkeiten, dies zu handhaben:

#### Automatisch versuchen, die Verbindung wiederherzustellen

Sie können `autoReconnectOnUnexpectedDisconnect` auf `wahr` setzen, damit das SDK bei einer unerwarteten Trennung automatisch eine erneute Verbindung versucht. Standardmäßig ist dieses Verhalten aktiv, wenn diese Einstellung weggelassen wird. Optional können Sie auch `TapToPayReaderListener` für automatische Wiederverbindungs-Rückrufe in Ihrer App implementieren.

#### Kotlin

```kotlin
val tapToPayReaderListener = yourTapToPayReaderListener
val autoReconnectOnUnexpectedDisconnect = true

Terminal.getInstance().connectReader(
    reader,
    TapToPayConnectionConfiguration(
        ""{{LOCATION_ID}}"",
        autoReconnectOnUnexpectedDisconnect,
        tapToPayReaderListener
    ),
    readerCallback,
)
```

Wenn das SDK automatisch versucht, die Verbindung wiederherzustellen, geschieht Folgendes:

1. Wenn die Verbindung getrennt wird, versucht das SDK automatisch, die Verbindung wiederherzustellen, und benachrichtigt Sie über `onReaderReconnectStarted`. Stellen Sie sicher, dass Ihre App meldet, dass die Verbindung unterbrochen wurde und eine erneute Verbindung durchgeführt wird.
   - Sie können den Verbindungsversuch jederzeit mit dem `Cancelable`-Objekt stoppen.
1. Wenn das SDK erfolgreich erneut mit dem Lesegerät verbunden ist, benachrichtigt Stripe Sie über `onReaderReconnectSucceeded`. Stellen Sie sicher, dass Ihre App meldet, dass die Verbindung wiederhergestellt wurde, und um den normalen Betrieb fortzusetzen.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann, benachrichtigt Stripe Sie über `onReaderReconnectFailed` und `TapToPayReaderListener.onDisconnect`. Stellen Sie sicher, dass Ihre App eine unerwartete Trennung der Verbindung meldet.

#### Kotlin

```kotlin
class CustomTapToPayReaderListener : TapToPayReaderListener {
    override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    override fun onReaderReconnectSucceeded(reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }

    override fun onReaderReconnectFailed(reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }
}
```

#### Trennen Sie die Verbindung manuell

Um die Trennung selbst zu handhaben, müssen Sie Folgendes tun:

1. Setzen Sie `autoReconnectOnUnexpectedDisconnect` auf `falsch`, um die automatische Wiederverbindung standardmäßig zu deaktivieren.
1. Implementieren Sie `TapToPayReaderListener` für den `onDisconnect`-Rückruf.

Dies ermöglicht Ihrer App, die Verbindung zum Tap to Pay-Lesegerät wiederherzustellen und gegebenenfalls die Nutzerin oder den Nutzer darüber zu informieren, was schiefgelaufen ist und wie der Zugriff auf Tap to Pay aktiviert werden kann. Endkundinnen und -kunden können bestimmte Fehler, wie etwa Probleme mit der Internetverbindung, selbst beheben.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), TapToPayReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

> Wenn Sie die Trennung manuell handhaben, ohne die automatische Wiederverbindung zu deaktivieren, kann dies zu Konflikten führen, die die Lesegerätesitzung unterbrechen.


# Tap to Pay on React Native

> This is a Tap to Pay on React Native for when terminal-sdk-platform is react-native and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=tap-to-pay.

Mit Tap to Pay können Nutzer/innen persönliche kontaktlose Zahlungen mit [kompatiblen NFC-fähigen Android-Geräten](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices) oder [kompatiblen iPhones](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices) annehmen. Tap to Pay unterstützt kontaktlose Karten von Visa, Mastercard und American Express sowie mobile NFC-basierte Wallets (Apple Pay, Google Pay und Samsung Pay). Die Unterstützung für Tap to Pay auf dem iPhone und auf Android ist in den nativen Terminal SDKs enthalten und ermöglicht Zahlungen direkt über Ihre mobile App.

Befolgen Sie diese Schritte, um Ihre App mit dem Tap to Pay-Lesegerät auf einem unterstützten Gerät zu verbinden:

- [Initialisieren Sie das SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) für TTPA, falls Sie das SDK auf einem Android-Gerät verwenden.
- [Erkennen Sie Lesegeräte](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) mit dem SDK, um die Gerätekompatibilität zu bestätigen.
- Stellen Sie mit dem SDK eine [Verbindung mit einem Lesegerät her](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader), um Zahlungen anzunehmen.
- [Handhaben Sie unerwartete Verbindungsabbrüche](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects), um sicherzustellen, dass Ihre Nutzer/innen weiterhin Zahlungen annehmen können, wenn das Lesegerät unerwartet getrennt wird.

## SDK initialisieren

Tap to Pay auf Android wird in einem dedizierten Verfahren ausgeführt, um Transaktionen sicherer zu machen. In diesem Verfahren wird eine zweite Instanz Ihrer `Anwendung` erstellt. Um unerwartete Fehler zu vermeiden, die durch die Ausführung Ihres Codes auf einem Android-Gerät verursacht werden können, können Sie die Initialisierung in Ihrer `Anwendung` in diesem Verfahren überspringen, indem Sie `TapToPay.isInTapToPayProcess()` überprüfen.

```kotlin
class MainApplication : Application(), ReactApplication {
    override fun onCreate() {
        super.onCreate()

        // Skip initialization if running in the TTPA process.
        if (TapToPay.isInTapToPayProcess()) return

        // For example, this will be skipped.
        TerminalApplicationDelegate.onCreate(this)
    }
}
```

## Lesegeräte entdecken

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders)

Verwenden Sie die `discoverReaders`-Methode, um die Hardware-Unterstützung für Tap to Pay auf Ihrem Gerät zu ermitteln.

Wenn Ihre Anwendung auf einem Gerät ausgeführt wird, das die obigen Anforderungen nicht erfüllt, gibt die `discoverReaders`-Methode einen Fehler zurück.

```js
export default function DiscoverReadersScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // The `readers` variable will contain an array of all the discovered readers.
      },
    });

  useEffect(() => {
    const { error } = await discoverReaders({
      discoveryMethod: 'tapToPay',
    });
  }, [discoverReaders]);

  return <View />;
}
```

## Mit einem Lesegerät verbinden

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)

Um Tap to Pay-Zahlungen anzunehmen, geben Sie das erkannte Lesegerät aus dem vorherigen Schritt für die Methode `connectReader` an.

Sie müssen Ihr [Lesegerät](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) bei der Herstellung der Verbindung bei einem [Standort](https://docs.stripe.com/api/terminal/locations.md) registrieren. Dazu müssen Sie die entsprechende Standort-ID an `connectReader` übergeben.

Bei der Verwendung von [Destination Charges mit „on_behalf_of”](https://docs.stripe.com/terminal/features/connect.md?connect-charge-type=destination) auf iPhones ist es erforderlich, die ID des verbundenen Kontos anzugeben.

```js
const { reader, error } = await connectReader({
    reader: selectedReader,
    locationId: "{{LOCATION_ID}}"
  },
  'tapToPay'
);

if (error) {
  console.log('connectTapToPayReader error:', error);
  return;
}

console.log('Reader connected successfully', reader);
```

### Kontoverknüpfung und Allgemeine Geschäftsbedingungen von Apple

Wenn Sie sich das erste Mal mit dem Lesegerät verbinden, sehen Sie die Nutzungsbedingungen von Apple für Tap to Pay auf dem iPhone. Um sich bei Apple zu registrieren, müssen Sie eine gültige Apple-ID angeben, die ihr Unternehmen repräsentiert, bevor Sie die von Apple vorgelegten Bedingungen akzeptieren. Sie müssen dies nur einmal pro Stripe-Konto durchführen. Der Account muss diesen Vorgang bei späteren Verbindungen, auch auf anderen Mobilgeräten, nicht wiederholen.

Jedes verbundene Konto muss die allgemeinen Geschäftsbedingungen akzeptieren, wenn:

- Ein/e Connect-Nutzer/in erstellt Direct Charges
- Ein/e Connect-Nutzer/in erstellt eine Destination Charge und gibt ein `on_behalf_of`-Konto an
![Dreistufiger Ablauf, der die Anmeldung mit Apple ID, die Zustimmung zu den Konditionen und die Erfolgsmeldung für Tap to Pay auf dem iPhone zeigt](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png)

Verknüpfen Sie Ihr Apple-ID-Konto, um Tap to Pay-Zahlungen zu akzeptieren

Jedes iPhone kann innerhalb eines Zeitraums von 24&nbsp;Stunden bis zu 3 eindeutige Stripe-Konten in verschiedenen Apps verwenden, wenn `connectReader` für Tap to Pay auf dem iPhone aufgerufen wird. Wenn innerhalb desselben 24-Stunden-Zeitraums weitere Konten für das Gerät verwendet werden, löst die Methode `connectReader` den Fehler [SCPErrorTapToPayReaderMerchantBlocked](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPError.html#/c:@E@SCPError@SCPErrorTapToPayReaderMerchantBlocked) aus.

Weitere Informationen zur Kontoverknüpfung erhalten Sie im Abschnitt mit den Tap to Pay auf dem iPhone-Unternehmensinformationen der [Apple Tap to Pay auf dem iPhone FAQ](https://register.apple.com/tap-to-pay-on-iphone/faq.html).

## Umgang mit unerwarteten Verbindungsabbrüchen

- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT)

Zwischen Ihrer App und dem Lesegerät kann es zu unerwarteten Verbindungsabbrüchen kommen. Beispielsweise kann die Verbindung des Tap to Pay-Lesegeräts unerwartet getrennt werden, weil das Gerät die Internetverbindung verliert und wenn das Android-Betriebssystem den Tap to Pay to Pay-Lesegerätdienst aufgrund von Speicherbeschränkungen beendet.

Während des Tests können Sie einen unerwarteten Verbindungsabbruch simulieren, indem Sie den Internetzugang für Ihr Gerät deaktivieren.

#### Automatisch versuchen, die Verbindung wiederherzustellen

Sie können `autoReconnectOnUnexpectedDisconnect` auf `wahr` setzen, damit das SDK bei einer unerwarteten Trennung automatisch eine erneute Verbindung versucht. Standardmäßig verwendet das SDK dieses Verhalten, wenn diese Einstellung weggelassen wird.

```js
const { reader, error } = await connectReader({
    reader,
    autoReconnectOnUnexpectedDisconnect: true, // default setting
  },
  'tapToPay'
);

if (error) {
  console.log('connectReader error:', error);
  return;
}

console.log('Reader connected successfully', reader);
```

Wenn das SDK automatisch versucht, die Verbindung wiederherzustellen, geschieht Folgendes:

1. Das SDK benachrichtigt Sie über `onDidStartReaderReconnect`. Stellen Sie sicher, dass Ihre App meldet, dass die Verbindung unterbrochen wurde und eine erneute Verbindung durchgeführt wird.
   - Sie können den Verbindungsversuch jederzeit mit der Methode `cancelReaderReconnection` stoppen.
1. Wenn sich das SDK erfolgreich mit dem Lesegerät verbindet, benachrichtigt Stripe Sie über `onDidSucceedReaderReconnect`. Stellen Sie sicher, dass Ihre App meldet, dass die Verbindung wiederhergestellt wurde, und dass der normale Betrieb fortgesetzt wird.
1. Wenn sich das SDK nicht erneut mit dem Lesegerät verbinden kann, benachrichtigt Stripe Sie über `onDidFailReaderReconnect` und `onDidDisconnect`. Stellen Sie sicher, dass Ihre App eine unerwartete Trennung der Verbindung meldet.

```js
const { discoverReaders, connectedReader, discoveredReaders } =
    useStripeTerminal({
      onDidStartReaderReconnect: (disconnectReason) => {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
      },
      onDidSucceedReaderReconnect: () => {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
      },
      onDidFailReaderReconnect: () => {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
      }
    });
```

#### Trennen Sie die Verbindung manuell

Um die Trennung selbst zu handhaben, müssen Sie Folgendes tun:

1. Setzen Sie `autoReconnectOnUnexpectedDisconnect` auf `falsch`, um die automatische Wiederverbindung standardmäßig zu deaktivieren.
1. Implementieren Sie den Rückruf `onDidReportUnexpectedReaderDisconnect`.

Dies ermöglicht Ihrer App, die Verbindung zum Tap to Pay-Lesegerät wiederherzustellen und gegebenenfalls die Nutzerin oder den Nutzer darüber zu informieren, was schiefgelaufen ist und wie der Zugriff auf Tap to Pay aktiviert werden kann. Endkundinnen und -kunden können bestimmte Fehler, wie etwa Probleme mit der Internetverbindung, selbst beheben.

```js
const { discoverReaders, connectedReader, discoveredReaders } =
    useStripeTerminal({
      onDidReportUnexpectedReaderDisconnect: (readers) => {
        // Consider displaying a UI to notify the user and start rediscovering readers
      },
    });
```

> Wenn Sie die Trennung manuell handhaben, ohne die automatische Wiederverbindung zu deaktivieren, kann dies zu Konflikten führen, die die Lesegerätesitzung unterbrechen.


## Nächste Schritte

Sie haben Ihre Anwendung mit dem Lesegerät verbunden. Als Nächstes [ziehen Sie Ihre erste Stripe Terminal-Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md) ein.

Der Name und das Logo von BBPOS und Chipper™ sind Marken oder eingetragene Marken von BBPOS Limited in den Vereinigten Staaten oder anderen Ländern. Der Name und das Logo von Verifone® sind entweder Marken oder eingetragene Marken von Verifone in den Vereinigten Staaten und/oder anderen Ländern. Die Verwendung der Marken stellt keine Billigung durch BBPOS oder Verifone dar.