# 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 P630 und UX700 sind in den Vereinigten Staaten **allgemein verfügbar**. Verifone V660p und M425 befinden sich in den Vereinigten Staaten und Kanada in der **öffentlichen Vorschau**, während sich P630 und UX700 für Kanada, Belgien, Italien, die Niederlande, Norwegen, Spanien und Schweden ebenfalls in der **öffentlichen Vorschau** befinden. V660p, UX700 und P630 befinden sich für Irland und das Vereinigte Königreich, Frankreich, Singapur (V660p, P630) und Australien in der **privaten Vorschau**. > > Um ein Verifone-Lesegerät zu bestellen oder an einer Vorschau teilzunehmen, müssen Sie [das Sales-Team kontaktieren](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. 2. [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. 3. 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.7.0") implementation("com.stripe:stripeterminal-appsondevices:5.7.0") } ``` 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.7.0`). 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. Das 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. 2. 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. 3. 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. 2. 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. 3. 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). ## App-Übergänge anpassen [Clientseitig] Wenn ein Zahlungsvorgang startet, wechselt die Stripe Reader-App in den Vordergrund und Ihre App in den Hintergrund. Sofern nicht anders angegeben, verwendet der Übergang die Standardanimation des Android-Systems, die von rechts einblendet. > Nutzerdefinierte Übergangsanimationen erfordern die Lesegerät-Softwareversion 2.42 oder höher. #### Android Sie können den Übergang anpassen, indem Sie beim Verbinden mit dem Lesegerät einen `appTransitionAnimation`-Parameter an `AppsOnDevicesConnectionConfiguration` übergeben. ### Voreingestellte Animation verwenden Das Terminal-SDK enthält voreingestellte Animationen, die keine zusätzliche Konfiguration erfordern. Verwenden Sie `AppTransitionAnimation.Preset` mit einer `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 } } ) } ``` Wenn Sie die Voreinstellung `SLIDE_FROM_BOTTOM` verwenden, gleitet die Stripe Reader-App von der Unterseite des Bildschirms nach oben. ### Benutzerdefinierte Animation verwenden Sie können im Verzeichnis `res/anim/` benutzerdefinierte Android-Animationsressourcen für Ihre App festlegen. Übergeben Sie anschließend die Ressourcen-IDs an `AppTransitionAnimation.Custom`. Mit `enterAnim` steuern Sie, wie die Stripe Reader-App auf dem Bildschirm erscheint. Mit `exitAnim` steuern Sie, wie Ihre App den Bildschirm verlässt. #### 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 ) ) ``` ### Übergangsanimation deaktivieren Sie können die Übergangsanimation deaktivieren, indem Sie `AppTransitionAnimation.Custom.NO_ANIMATION` für beide Parameter übergeben. Um die Animation nur in eine Richtung zu deaktivieren, übergeben Sie `NO_ANIMATION` entweder für `enterAnim` oder für `exitAnim`. #### Kotlin ```kotlin val config = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = listener, appTransitionAnimation = AppTransitionAnimation.Custom( enterAnim = AppTransitionAnimation.Custom.NO_ANIMATION, exitAnim = AppTransitionAnimation.Custom.NO_ANIMATION ) ) ``` > Wenn die IDs der Animationsressourcen ungültig sind, löst das SDK in Fehlerbehebungs-Builds beim Verbinden eine Ausnahme aus. In Release-Builds verwendet das SDK den systemseitigen Standardübergang. #### React Native Sie können den Übergang anpassen, indem Sie beim Verbinden mit dem Lesegerät einen `appTransitionAnimation`-Parameter an `ConnectAppsOnDevicesParams` oder `EasyConnectAppsOnDevicesParams` übergeben. ### Voreingestellte Animation verwenden Das SDK enthält eine voreingestellte Animation, für die keine zusätzliche Einrichtung erforderlich ist. Übergeben Sie `{ type: 'preset', preset: AppTransitionPreset.SlideFromBottom }`: ```typescript import { useStripeTerminal, AppTransitionPreset, } from '@stripe/stripe-terminal-react-native'; const { connectReader } = useStripeTerminal(); const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: selectedReader, appTransitionAnimation: { type: 'preset', preset: AppTransitionPreset.SlideFromBottom }, }); ``` Wenn Sie die Voreinstellung `SlideFromBottom` verwenden, gleitet die Stripe Reader-App von der Unterseite des Bildschirms nach oben. ### Benutzerdefinierte Animation verwenden Sie können im Verzeichnis `res/anim/` benutzerdefinierte Android-Animationsressourcen für Ihre Android-App definieren. Übergeben Sie dann die Ressourcen-IDs als `enterAnim` und `exitAnim`. Der Parameter `enterAnim` steuert, wie die Stripe Reader-App auf dem Bildschirm erscheint. Der Parameter `exitAnim` steuert, wie Ihre App den Bildschirm verlässt. ```typescript // enterAnim and exitAnim are Android resource IDs (numbers) from your res/anim/ directory const enterAnim: number = /* your enter animation resource ID */; const exitAnim: number = /* your exit animation resource ID */; const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: selectedReader, appTransitionAnimation: { type: 'custom', enterAnim, exitAnim }, }); ``` ### Übergangsanimation deaktivieren Sie können die Übergangsanimation deaktivieren, indem Sie sowohl für `enterAnim` als auch für `exitAnim` `0` übergeben. Um die Animation nur in einer Richtung zu deaktivieren, übergeben Sie `0` entweder für `enterAnim` oder für `exitAnim`. ```typescript const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: selectedReader, appTransitionAnimation: { type: 'custom', enterAnim: 0, exitAnim: 0 }, }); ``` > Wenn die IDs der Animationsressourcen ungültig sind, löst das SDK in Fehlerbehebungs-Builds beim Verbinden eine Ausnahme aus. In Release-Builds verwendet das SDK den systemseitigen Standardübergang. ### Standardmäßige Systemanimation verwenden Lassen Sie `appTransitionAnimation` weg oder übergeben Sie `{ type: 'systemDefault' }`, um den Standardübergang des Android-Systems zu verwenden. ### Übergänge beim Öffnen der Geräteeinstellungen anpassen Ihre App kann den [Einstellungsbildschirm](https://docs.stripe.com/terminal/payments/setup-reader/stripe-reader-s700-s710.md#settings) des Lesegeräts öffnen, damit Unternehmen WLAN konfigurieren, nach Software-Updates suchen oder Geräteeinstellungen anpassen können. Hierfür wird der Deep-Link `stripe://settings/` verwendet, der einen standardmäßigen Android-Aktivitätsübergang auslöst. Der während der [Verbindung mit dem Lesegerät](https://docs.stripe.com/terminal/features/apps-on-devices/build.md#customize-transitions) konfigurierte Parameter `appTransitionAnimation` gilt nicht für diese Übergänge. Er steuert nur die Animationen, die das SDK während der Zahlungsvorgänge auslöst. Um einen einheitlichen Übergang beim Navigieren zu den Geräteeinstellungen zu erstellen, verwenden Sie `ActivityOptions.makeCustomAnimation` mit den integrierten Animationsvorgaben des SDK. Das Terminal-SDK enthält Animationsressourcendateien für jede Vorgabe. Sie können auf die Ressourcen-IDs für die Eingangs- und Ausgangsanimationen von `AppTransitionPreset.SLIDE_FROM_BOTTOM` über `.enterAnim` und `.exitAnim` zugreifen. Aktuell ist `SLIDE_FROM_BOTTOM` die einzige verfügbare Vorgabe: #### Kotlin ```kotlin import android.app.ActivityOptions import com.stripe.stripeterminal.appsondevices.extensions.enterAnim import com.stripe.stripeterminal.appsondevices.extensions.exitAnim import com.stripe.stripeterminal.external.models.AppTransitionPreset val options = ActivityOptions.makeCustomAnimation( this, AppTransitionPreset.SLIDE_FROM_BOTTOM.enterAnim, AppTransitionPreset.SLIDE_FROM_BOTTOM.exitAnim, ) startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/")), options.toBundle() ) ``` Um die Animation zu deaktivieren, übergeben Sie `0` für beide Animationsparameter: #### Kotlin ```kotlin val options = ActivityOptions.makeCustomAnimation(this, 0, 0) startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/")), options.toBundle() ) ``` ## Geräteverwaltung [Clientseitig] Ihre App kann Deep-Links direkt zu bestimmten Bildschirmen der Geräteeinstellungen setzen, sodass Nutzerinnen und Nutzer auf die genaue Konfiguration zugreifen können, die sie benötigen, ohne durch das gesamte Admin-Menü navigieren zu müssen. Fügen Sie beispielsweise eine Schaltfläche „WLAN-Einstellungen“ hinzu, die die Netzwerkkonfiguration öffnet, oder lassen Sie das Personal die Bildschirmhelligkeit anpassen, ohne durch das oberste Einstellungsmenü navigieren zu müssen. ### Verfügbare Deep-Links Starten Sie eine dieser URIs mit einem Android-`ACTION_VIEW`-Intent: | Ziel | URI | Admin-PIN erforderlich | | --- | --- | --- | | Alle Einstellungen | `stripe://settings/` | Immer | | Netzwerk | `stripe://settings/network/` | Immer | | Advanced | `stripe://settings/advanced/` | Immer | | Registrierungscode | `stripe://settings/registration_code/` | Immer | | Erscheinungsbild | `stripe://settings/appearance/` | Umgehbar | | Sprache | `stripe://settings/language/` | Umgehbar | | Fehlerbericht | `stripe://settings/bug_report/` | Umgehbar | Bildschirme, die als **Umgehbar** markiert sind, fordern standardmäßig zur Eingabe der Admin-PIN auf, aber Ihre App kann die Aufforderung überspringen. Weitere Informationen finden Sie unten unter [Admin-PIN umgehen](https://docs.stripe.com/terminal/features/apps-on-devices/build.md#bypass-the-admin-pin). - Unter **Netzwerk** können Nutzerinnen und Nutzer WLAN-Netzwerke auswählen und konfigurieren, einschließlich statischer IPs und benutzerdefinierter DNS-Einstellungen. - **Advanced** bietet Zugriff auf zusätzliche Einstellungen wie [Diagnosen](https://docs.stripe.com/terminal/readers/stripe-reader-s700-s710.md#diagnostics) und das Zurücksetzen auf die Werkseinstellungen. - Der **Registrierungscode** generiert einen Kopplungscode, um [das Lesegerät für ein Stripe-Konto zu registrieren](https://docs.stripe.com/terminal/fleet/register-readers.md#smart-readers). - **Erscheinungsbild** steuert die Bildschirmhelligkeit und das Design. - **Fehlerbericht** erfasst die Geräte-Logs und Diagnoseinformationen und sendet diese zur Fehlerbehebung an den Stripe-Support. - **Sprache** steuert die Anzeigesprache des Lesegeräts. ### Einen Einstellungsbildschirm starten Verwenden Sie einen Standard-Android-`ACTION_VIEW`-Intent, um einen Einstellungsbildschirm zu öffnen. Um die Übergangsanimation anzupassen, übergeben Sie ein `ActivityOptions`-Bundle, wie unter [Übergänge beim Öffnen von Geräteeinstellungen anpassen](https://docs.stripe.com/terminal/features/apps-on-devices/build.md#customize-transitions-when-opening-device-settings) beschrieben. Ein vollständiges, funktionierendes Beispiel finden Sie in der [Beispiel-App für Apps auf Geräten](https://github.com/stripe-samples/terminal-apps-on-devices). #### Kotlin ```kotlin startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/network/")) ) ``` ### Admin-PIN umgehen Bei den Bildschirmen für Erscheinungsbild, Sprache und Fehlerbericht fordert das Gerät standardmäßig die Admin-PIN an. Sie können diese Aufforderung überspringen, indem Sie dem Intent das Extra `bypass_admin_menu_passcode` hinzufügen. Dies ist nützlich für Bildschirme mit geringem Risiko, bei denen das Personal nicht jedes Mal eine PIN eingeben soll. #### Kotlin ```kotlin startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/appearance/")) .putExtra("bypass_admin_menu_passcode", true) ) ``` > Umgehen Sie die Admin-PIN nur bei nicht sensiblen Bildschirmen. Für alle Bildschirme zu den Einstellungen, zum Netzwerk, zu den erweiterten Optionen und zum Registrierungscode ist die PIN unabhängig von dieser Einstellung stets erforderlich. ## 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 Ihren Nutzerinnen und Nutzern 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. > #### Verhalten nach der Transaktion > > Wenn Sie Ihre benutzerdefinierte App direkt installieren, können Sie die bevorzugte Kiosk-App des DevKits nicht festlegen. Wenn eine Transaktion abgeschlossen ist, kehrt das DevKit immer zur standardmäßigen Stripe-Lesegerät-App zurück. Wenn Sie Ihre App zur bevorzugten Kiosk-App auf einem DevKit machen möchten, müssen Sie eine Bereitstellungsgruppe verwenden, wie in den Anweisungen im Dashboard beschrieben. 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). 2. 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). 3. Klicken Sie auf **Datenterminal** > **Software**. 4. 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. 5. Klicken Sie auf der Seite mit App-Details auf **Version bereitstellen**. 6. Wählen Sie die aktuelle Version Ihrer App aus und klicken Sie dann auf **Weiter**. 7. 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**. 8. Wählen Sie Ihre bevorzugte Kiosk-App aus und klicken Sie dann auf **Weiter**. Das Stripe-Lesegerät startet diese App beim Einschalten und nach jeder Transaktion. Wenn nur eine App zur Bereitstellung verfügbar ist, wählen Sie diese App aus. 9. Bestätigen Sie die Bereitstellungsdetails und klicken Sie dann auf **Bereitstellen**. 10. 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)