# Ihre App erstellen und testen Erfahren Sie, wie Sie Ihre App mit einem DevKit erstellen und testen. Greifen Sie auf das Beispiel-Integrations-Repository für „Apps auf Geräten“ auf [GitHub](https://github.com/stripe-samples/terminal-apps-on-devices) zu. Verwenden Sie Ihr SmartPOS DevKit-Gerät, um Ihre Anwendung zu testen und zu überarbeiten, ohne den Prozess der Bereitstellung, App-Überprüfung oder Unterzeichnung durchlaufen zu müssen. Wenn Sie ein DevKit-Gerät benötigen, können Sie [bis zu fünf pro Nutzer/in](https://docs.stripe.com/terminal/fleet/order-and-return-readers.md) im Abschnitt [Lesegeräte](https://dashboard.stripe.com/terminal) in Ihrem Dashboard bestellen. > #### Support für Verifone-Lesegeräte > > Verifone-Lesegeräte werden in der privaten Vorschau in den Vereinigten Staaten und in Kanada unterstützt. Einige Verifone-Lesegeräte werden in Irland und dem Vereinigten Königreich (V660p, UX700, P630) und in Singapur (V660p, P630) in der privaten Vorschau unterstützt. Um an der Vorschau teilzunehmen, müssen Sie das [Sales-Team kontaktieren und das entsprechende Lesegerät bestellen](https://stripe.com/contact/sales). ## DevKit einrichten Bevor Sie Ihr DevKit für die App-Entwicklung verwenden können, müssen Sie Folgendes tun: 1. Befolgen Sie die Anweisungen auf dem Bildschirm, um eine Verbindung zu einem Netzwerk herzustellen. 1. [Registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=android&reader-type=internet#register-reader) Sie das Gerät in Ihrem Stripe-Konto. 1. Installieren Sie alle verfügbaren Updates. Nach der Ersteinrichtung können Sie Ihr DevKit jederzeit bei einem anderen Konto oder Standort registrieren. Verbinden Sie hierfür das DevKit mit dem Internet und befolgen Sie die Schritte zum [Registrieren eines Lesegeräts](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=android&reader-type=internet#register-reader). DevKit-Geräte ähneln zwar Produktionsgeräten, aber: - Kann nur in [Sandboxes](https://docs.stripe.com/keys.md#test-live-modes) betrieben werden. - Sie werden mit standardmäßig aktivierten [Entwickleroptionen](https://developer.android.com/studio/debug/dev-options) und [Android Debug Bridge](https://developer.android.com/studio/command-line/adb) (`adb`) versandt. - Auf dem Bildschirm wird ein Wasserzeichen angezeigt, um darauf hinzuweisen, dass das Gerät nur zu Testzwecken verwendet wird. Das Wasserzeichen bewegt sich während der Nutzung des Geräts auf dem Bildschirm, sodass Sie alle Teile des Bildschirms sehen können. Die Terminal API unterstützt das Targeting registrierter DevKit-Geräte. ## Ihre App für Stripe-Geräte entwickeln Führen Sie die folgenden Schritte aus, um Ihre App für Stripe-Android-Geräte zu entwickeln, einschließlich der Einrichtung der App und der Übergabe an die Stripe Reader-App. ## App einrichten [Clientseitig] #### Android [Richten Sie zunächst Ihre Integration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=android) für persönliche Zahlungen ein. Befolgen Sie dann die nachstehenden Anweisungen für die Integration von „Apps auf Geräten“. ### Abhängigkeiten hinzufügen Fügen Sie dem Gradle-Build-Skript Ihres Projekts die folgenden Abhängigkeiten hinzu. Integrationen des Typs „Apps auf Geräten“ benötigen das [Terminal Android SDK](https://github.com/stripe/stripe-terminal-android), Version `2.22.0` oder höher. Wir empfehlen, die Integration mit der [neuesten Version](https://github.com/stripe/stripe-terminal-android/releases) durchzuführen. #### Kotlin ```kotlin dependencies { implementation("com.stripe:stripeterminal-core:5.4.1") implementation("com.stripe:stripeterminal-appsondevices:5.4.1") } ``` Stellen Sie sicher, dass Sie keine anderen Stripe Terminal SDK-Abhängigkeiten verwenden. Wenn Sie beispielsweise zuvor das Terminal Android SDK integriert haben, verwenden Sie nicht die übergeordnete Abhängigkeit `com.stripe:stripeterminal` (zum Beispiel `com.stripe:stripeterminal:5.4.1`). Hier finden Sie ein Beispiel für die [Einbeziehung von Abhängigkeiten in das Build-Skript Ihrer App](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/build.gradle.kts#L66). ### Ihre Anwendung konfigurieren Um das Stripe SDK über Lebenszyklusereignisse zu informieren, fügen Sie den Aufruf [TerminalApplicationDelegate.onCreate()](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal-application-delegate/on-create.html) zur Methode [onCreate()](https://developer.android.com/reference/android/app/Application#onCreate\(\)) für die Unterklasse Ihrer Anwendung hinzu. #### Kotlin ```kotlin class MyApplication : Application() { override fun onCreate() { super.onCreate() TerminalApplicationDelegate.onCreate(this) } } ``` Geben Sie in Ihrem [App-Manifest](https://developer.android.com/guide/topics/manifest/manifest-intro) den Namen Ihrer `Application`-Unterklasse mit dem Attribut `android:name` an. > Um sicherzustellen, dass Ihre `Application` Geräte mit Android 15 unterstützt, setzen Sie die `targetSdkVersion` auf `24` oder höher. ```xml ``` Hier erfahren Sie mehr über die [Einrichtung Ihrer Integration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=android) oder sehen Sie sich im GitHub-Repository der Beispiel-App für den Typ „Apps auf Geräten“ ein Beispiel für die [Konfiguration der Unterklasse einer Anwendung](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/MyApp.kt#L10) an. #### React Native [Richten Sie zunächst Ihre Integration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=react-native) für persönliche Zahlungen ein. Befolgen Sie dann die nachstehenden Anweisungen für die Integration von „Apps auf Geräten“. ### Ihre Anwendung konfigurieren Um das Stripe SDK über Lebenszyklusereignisse zu informieren, fügen Sie den Aufruf `TerminalApplicationDelegate.onCreate()` zur Methode [onCreate()](https://developer.android.com/reference/android/app/Application#onCreate\(\)) für die Unterklasse Ihrer Anwendung hinzu. #### Kotlin ```kotlin import com.stripeterminalreactnative.TerminalApplicationDelegate class MyApplication : Application() { override fun onCreate() { super.onCreate() TerminalApplicationDelegate.onCreate(this) } } ``` Geben Sie in Ihrem [App-Manifest](https://developer.android.com/guide/topics/manifest/manifest-intro) den Namen Ihrer `Application`-Unterklasse mit dem Attribut `android:name` an. ```xml ``` Hier erfahren Sie mehr über die [Einrichtung Ihrer Integration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=react-native) oder sehen Sie sich im GitHub-Repository für React Native ein Beispiel zur [Konfiguration der Unterklasse einer Anwendung](https://github.com/stripe/stripe-terminal-react-native/blob/main/dev-app/android/app/src/main/java/com/dev/app/stripeterminalreactnative/MainApplication.java#L58) an. ### Serverlose Initialisierung Für Apps auf Geräten können Sie `AppsOnDevicesConnectionTokenProvider` anstelle eines Backend-Token-Providers verwenden. Dies ermöglicht die Initialisierung, ohne dass ein Backend-Server Verbindungstoken bereitstellen muss. ```js import { StripeTerminalProvider, AppsOnDevicesConnectionTokenProvider, } from '@stripe/stripe-terminal-react-native'; function Root() { return ( ); } ``` ## App erstellen [Clientseitig] Befolgen Sie die nachstehenden Anweisungen für Integrationen des Typ „Apps auf Geräten“. ### Lesegerät erkennen und verbinden #### Android > 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). Sie müssen ein neues Stripe-Gerät als neues [Reader-Objekt](https://docs.stripe.com/api/terminal/readers/object.md) bei Ihrem Konto registrieren. Verwenden Sie den in den Admin-Einstellungen des Geräts bereitgestellten Kopplungscode, um das [Reader-Objekt zu erstellen](https://docs.stripe.com/api/terminal/readers/create.md). Ihre App verwendet das Android SDK von Stripe Terminal, um Ihr Gerät zu erkennen und eine Verbindung zu ihm herzustellen: Hier finden Sie weitere Beispiele für die [Erkennung](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/model/MainViewModel.kt#L90) und die [Herstellung einer Verbindung](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/model/MainViewModel.kt#L106) unter Verwendung des Übergabemodus finden Sie im Beispielintegrations-Repository für „Apps auf Geräten“ auf [GitHub](https://github.com/stripe-samples/terminal-apps-on-devices). 1. Ihre App wird auf Ihrem registrierten Gerät ausgeführt. 1. Ihre App erkennt das Lesegerät, indem sie [discoverReaders](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) mit [AppsOnDevicesDiscoveryConfiguration](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-apps-on-devices-discovery-configuration/index.html) aufruft. 1. Ihre App stellt über [connectReader](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) eine Verbindung zum Lesegerät her. Das folgende Beispiel zeigt, wie ein Stripe-Lesegerät im Übergabemodus in einer Android-App erkannt und verbunden wird. #### Kotlin ```kotlin private fun discoverReaders() { Terminal.getInstance().discoverReaders(config = AppsOnDevicesDiscoveryConfiguration(), discoveryListener = object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { // In Apps on Devices discovery, the list will // contain a single reader. Connect to // the reader after it is discovered. readers.firstOrNull()?.let { reader -> connectReader(reader) } } }, callback = object : Callback { override fun onSuccess() { // Handle successfully discovering readers } override fun onFailure(e: TerminalException) { // Handle exception while discovering readers } } ) } private fun connectReader(reader: Reader) { Terminal.getInstance().connectReader( reader,AppsOnDevicesConnectionConfiguration( object : AppsOnDevicesReaderListener { override fun onDisconnect(reason: DisconnectReason) { // Optionally get notified about reader disconnects (for example, reader was rebooted) } override fun onReportReaderEvent(event: ReaderEvent) { // Optionally get notified about reader events (for example, a card was inserted) } } ), object : ReaderCallback { override fun onSuccess(reader: Reader) { // Handle successfully connecting to the reader } override fun onFailure(e: TerminalException) { // Handle exception when connecting to the reader } } ) } ``` #### React Native > In der Version `0.0.1-Beta.29` des React Native SDK können Sie die Methode [easyConnect](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#easyconnect) verwenden, um die Erkennung und Verbindung von Lesegeräten in einem einzigen API-Aufruf zu vereinen und so die Integration zu vereinfachen. Sie müssen ein neues Stripe-Gerät als neues [Reader-Objekt](https://docs.stripe.com/api/terminal/readers/object.md) bei Ihrem Konto registrieren. Verwenden Sie den in den Admin-Einstellungen des Geräts bereitgestellten Kopplungscode, um das [Reader-Objekt zu erstellen](https://docs.stripe.com/api/terminal/readers/create.md). Ihre App verwendet das React Native SDK von Stripe Terminal, um Ihr Gerät zu erkennen und eine Verbindung zu ihm herzustellen: 1. Ihre App wird auf Ihrem registrierten Gerät ausgeführt. 1. Ihre App erkennt das Lesegerät, indem sie die [Erkennungsmethode](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.Android.html#DiscoveryMethod) [discoverReaders](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) mit `appsOnDevices` aufruft. 1. Ihre App wird über [connectReader](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) mit dem Lesegerät verbunden. Das folgende Beispiel zeigt, wie Sie in einer React Native-App mithilfe des Modus „Apps auf Geräten“ ein Stripe-Lesegerät erkennen und eine Verbindung dazu herstellen können: ```js const { discoverReaders, connectReader, discoveredReaders } = useStripeTerminal({ onUpdateDiscoveredReaders: async (readers) => { // After the SDK discovers a reader, your app can connect to it. // The discoverReaders method doesn't resolve until discovery completes, // so use this callback to handle discovered readers. if (readers.length > 0) { const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: readers[0], }); if (error) { console.log('connectReader error:', error); return; } console.log('Reader connected successfully', reader); } }, }); const handleDiscoverReaders = async () => { const { error } = await discoverReaders({ discoveryMethod: 'appsOnDevices', }); if (error) { console.log('discoverReaders error:', error); } }; useEffect(() => { handleDiscoverReaders(); }, [discoverReaders]); ``` ### Einzug von Zahlungen Nachdem Sie über den Handoff-Modus eine Verbindung zum Lesegerät hergestellt haben, können Sie mit dem [Einziehen von Zahlungen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=android#create-payment) beginnen. Die Stripe Reader-App übernimmt den Zahlungseinzug und andere Zahlungsvorgänge, wie beispielsweise das [Speichern von Zahlungsdetails](https://docs.stripe.com/terminal/features/saving-payment-details/overview.md). Beim Initiieren eines Zahlungsvorgangs wird die Stripe Reader-App zur primären App und wird im Vollbildmodus gestartet. Anschließend führt die Stripe Reader-App den Kunden/die Kundin durch den Ablauf und übergibt nach Abschluss (erfolgreich oder fehlgeschlagen) oder Stornierung durch den Kunden/die Kundin die Kontrolle an Ihre App zurück. Wenn die Kontrolle an Ihre App zurückgegeben wird, wird die Stripe Reader-App weiterhin im Hintergrund ausgeführt. Hier finden Sie ein Beispiel für den [Einzug von Zahlungen in einer App des Typs „Apps auf Geräten“](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/model/CheckoutViewModel.kt#L82). #### Zahlungen offline einziehen „Apps auf Geräten“ unterstützt den [Zahlungseinzug im Offline-Modus](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md?terminal-sdk-platform=android&reader-type=internet). ## Customize app transitions [Clientseitig] When a payment operation starts, the Stripe Reader app comes to the foreground and your app transitions to the background. Unless specified, the transition uses the Android system default animation, which slides from the right. You can customize the transition by passing an `appTransitionAnimation` parameter to `AppsOnDevicesConnectionConfiguration` when connecting to the reader. ### Use a preset animation The Terminal SDK bundles preset animations that require no additional setup. Use `AppTransitionAnimation.Preset` with an `AppTransitionPreset`: #### Kotlin ```kotlin private fun connectReader(reader: Reader) { val config = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = object : AppsOnDevicesReaderListener { override fun onDisconnect(reason: DisconnectReason) {} override fun onReportReaderEvent(event: ReaderEvent) {} },appTransitionAnimation = AppTransitionAnimation.Preset(AppTransitionPreset.SLIDE_FROM_BOTTOM) ) Terminal.getInstance().connectReader( reader, config, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Handle successfully connecting to the reader } override fun onFailure(e: TerminalException) { // Handle exception when connecting to the reader } } ) } ``` If you use the `SLIDE_FROM_BOTTOM` preset, the Stripe Reader app slides up from the bottom of the screen. ### Use a custom animation You can define custom Android animation resources in the `res/anim/` directory for your app. Then, pass the resource IDs to `AppTransitionAnimation.Custom`. The `enterAnim` controls how the Stripe Reader app enters the screen. The `exitAnim` controls how your app exits the screen. #### Kotlin ```kotlin val config = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = object : AppsOnDevicesReaderListener { override fun onDisconnect(reason: DisconnectReason) {} override fun onReportReaderEvent(event: ReaderEvent) {} },appTransitionAnimation = AppTransitionAnimation.Custom( enterAnim = R.anim.slide_in_up, exitAnim = R.anim.slide_out_down ) ) ``` ### Disable the transition animation You can disable the transition animation by passing `AppTransitionAnimation.Custom.NO_ANIMATION` for both parameters. To disable the animation in only one direction, pass `NO_ANIMATION` for either `enterAnim` or `exitAnim`. #### Kotlin ```kotlin val config = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = listener,appTransitionAnimation = AppTransitionAnimation.Custom( enterAnim = AppTransitionAnimation.Custom.NO_ANIMATION, exitAnim = AppTransitionAnimation.Custom.NO_ANIMATION ) ) ``` > If the animation resource IDs are invalid, the SDK throws an exception during connection in debug builds. In release builds, the SDK uses the system default transition. ## Geräteverwaltung [Clientseitig] Sie können auf die Administratoreinstellungen des Geräts zugreifen, indem Sie den Deep-Link-URI `stripe://settings/` aus Ihrer App starten. Hier finden Sie ein Beispiel für den [Aufruf des Deep-Link-URI für die Admin-Einstellungen](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/fragment/HomeFragment.kt#L30). #### Kotlin ```kotlin startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/")) ) ``` ## Die App instrumentieren [Clientseitig] Stripe bietet keine Lösung zur Instrumentierung auf Anwendungsebene. Um Abstürze und andere Logs Ihrer Anwendung zu verfolgen, können Sie eine Bibliothek eines Drittanbieters wie Sentry und Crashlytics verwenden. ## Gebietsschema des Geräts festlegen [Clientseitig] Der von [Locale.getDefault()](https://developer.android.com/reference/java/util/Locale#getDefault\(\)) zurückgegebene Wert wird von der Sprachauswahl des Nutzers/der Nutzerin bestimmt. Sie können die Gerätesprache in den Admin-Einstellungen ändern. ## Ausrichtung des Bildschirms [Clientseitig] Auf Stripe Android-Geräten ist die Einstellung zum *automatischen Drehen des Bildschirms* standardmäßig aktiviert. Ihre App kann diese Einstellung außer Kraft setzen, indem die Nutzeroberfläche bei einer bestimmten Bildschirmausrichtung gesperrt wird. Dies kann durch Festlegen des Attributs [screenOrientation](https://developer.android.com/guide/topics/manifest/activity-element#screen) für die entsprechenden ``-Tags im Manifest erreicht werden. ```xml ``` Alternativ kann dies auch programmgesteuert mit [Activity::setRequestedOrientation](https://developer.android.com/reference/android/app/Activity#setRequestedOrientation\(int\)) in Ihrer `Activity`-Klasse eingestellt werden. #### Kotlin ```kotlin class MainActivity : Activity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Lock to portrait orientation requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT // Or, lock to landscape orientation // requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE } } ``` ## Einschränkungen [Clientseitig] Android-Geräte von Stripe verfügen nicht über eine System-Nutzeroberfläche, einschließlich einer Zurück-Schaltfläche oder einer Statusleiste. Wenn Ihre App den Nutzer/innen Akkustand, Ladezustand und Verbindungsstatus mitteilen muss, finden Sie Informationen dazu in der folgenden Android API-Dokumentation: - [Akkustand und Ladezustand überwachen](https://developer.android.com/training/monitoring-device-state/battery-monitoring) - [Überwachen Sie den Verbindungsstatus und die Verbindungsmessung](https://developer.android.com/training/monitoring-device-state/connectivity-status-type) ## Funktionsweise mit Gerätezubehör [Clientseitig] Wenn das Stripe-Lesegerät eine Verbindung zu einer Dockingstation herstellt oder trennt, löst das Android-Betriebssystem eine [Konfigurationsänderung](https://developer.android.com/guide/topics/resources/runtime-changes) aus. Standardmäßig wird die Aktivität Ihrer App bei einer Konfigurationsänderung automatisch neu erstellt. Um die automatische Aktivitätswiederherstellung beim Herstellen oder Trennen einer Verbindung mit einer Dockingstation zu deaktivieren, fügen Sie `android:configChanges="uiMode"` im Eintrag `` in Ihrer Datei `AndroidManifest.xml` hinzu. ```xml ``` Ihre Aktivität kann über Konfigurationsänderungen informiert werden, indem Sie [Activity::onConfigurationChanged](https://developer.android.com/reference/android/app/Activity#onConfigurationChanged\(android.content.res.Configuration\)) implementieren. Diese Methode wird nur aufgerufen, wenn Sie Konfigurationen angegeben haben, die Sie mit dem Attribut `android:configChanges` in Ihrem Manifest behandeln möchten. ```kotlin class MainActivity : Activity() { override fun onConfigurationChanged(newConfig: Configuration) { super.onConfigurationChanged(newConfig) // implement custom configuration change handling logic } } ``` ## Ihre App testen Verwenden Sie Ihr S700 DevKit-Gerät, um Ihre App im Stripe-Dashboard oder mit der Android Debug Bridge (`adb`) zu testen. #### Android Debug Bridge (adb) Sie können Ihr DevKit-Gerät über ein USB-A/USB-C-Kabel an Ihren Computer anschließen. Verwenden Sie dann `adb`, um das zusammengestellte APK Ihrer App direkt auf dem DevKit-Gerät zu installieren. Bei den folgenden Beispielen wird davon ausgegangen, dass der [Paketname](https://developer.android.com/studio/build/configure-app-module) Ihrer Anwendung `com.example.myapp` lautet und die [Hauptaktivität](https://developer.android.com/reference/android/content/Intent.html#ACTION_MAIN) `MainActivity` ist. ``` $ adb install myapp.apk ``` Starten Sie nach Abschluss der Installation Ihre App: ``` $ adb shell am start com.example.myapp/.MainActivity ``` Rufen Sie die Admin-Einstellungen auf: ``` $ adb shell am start -d "stripe://settings/" ``` Deinstallieren Sie bei Bedarf Ihre App: ``` $ adb uninstall com.example.myapp ``` Die [Dokumentation zur Android Debug Bridge](https://developer.android.com/studio/command-line/adb) von Google enthält einen umfassenden Leitfaden für die Verwendung von `adb`. #### Dashboard Befolgen Sie diese Schritte, um Ihre App im Dashboard zu testen: 1. Öffnen Sie in einer Sandbox die Seite [Terminal-Lesegeräte](https://dashboard.stripe.com/test/terminal/readers). 1. Falls noch nicht geschehen, klicken Sie auf **Lesegerät registrieren** um das DevKit-Gerät bei Ihrem Konto zu [registrieren](https://docs.stripe.com/terminal/payments/connect-reader.md?reader-type=internet#register-reader). 1. Klicken Sie auf **Datenterminal** > **Software**. 1. Wählen Sie auf der Registerkarte [Software](https://dashboard.stripe.com/terminal/software) die App, die Sie bereitstellen möchten. Sie können auch eine neue App für die Bereitstellung erstellen. 1. Klicken Sie auf der Seite mit App-Details auf **Version bereitstellen**. 1. Wählen Sie die aktuelle Version Ihrer App aus und klicken Sie dann auf **Weiter**. 1. Wählen Sie die [Bereitstellungsgruppe](https://docs.stripe.com/terminal/features/apps-on-devices/deploy-in-Dashboard.md) für Ihr DevKit-Gerät aus und klicken Sie dann auf **Weiter**. 1. Wählen Sie Ihre bevorzugte Kiosk-App aus und klicken Sie dann auf **Weiter**. Dies ist die Standard-App, die beim Einschalten des Stripe-Lesegeräts gestartet wird. Wenn nur eine App bereitgestellt werden soll, wählen Sie stattdessen diese App aus. 1. Bestätigen Sie die Bereitstellungsdetails und klicken Sie dann auf **Bereitstellen**. 1. Starten Sie Ihr DevKit-Gerät neu, um Ihre App auf dem Gerät bereitzustellen. ### Fehlerbehebung Wenn Sie Ihre App zuvor per Sideloading installiert haben und erneut versuchen, sie bereitzustellen, wird möglicherweise die folgende Fehlermeldung angezeigt:`Failed to apply updates. Code: A9-com.example.posapp`. Sie müssen die per Sideloading installierte App deinstallieren, indem Sie den folgenden Befehl ausführen: ``` adb uninstall com.example.posapp ``` ## Testzahlungen DevKit-Geräte können Testzahlungen mit einer phyischen Stripe-Testkarte verarbeiten, die Sie im [Dashboard](https://dashboard.stripe.com/terminal/shop/thsku_FmpZaTqwezTFvS) bestellen können. Beim [Testen von Zahlungen](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards) können Sie Dezimalbeträge verwenden, um bestimmte Ergebnisse zu erzielen. > Verwenden Sie keine echten Karten für Testzahlungen auf DevKit-Geräten. ## Nächste Schritte - [App zur Überprüfung vorbereiten](https://docs.stripe.com/terminal/features/apps-on-devices/app-review.md) - [App übermitteln](https://docs.stripe.com/terminal/features/apps-on-devices/submit.md)