# Terminal SDK-Migrationsleitfaden Erfahren Sie, wie Sie zur Version 5.0.0 des Stripe-Terminal-SDK migrieren. Die iOS und Android SDKs für Stripe Terminal wurden mit einer Reihe wichtiger Änderungen an APIs und Verhalten aktualisiert, von denen einige erfordern, dass Sie Ihre Integration mit dem Stripe Terminal SDK aktualisieren. Um die Konsistenz zwischen unseren SDKs zu verbessern und Ihre Anwendungslogik und -integration zu vereinfachen, nehmen wir im Rahmen wichtiger Versionsaktualisierungen nderungen vor vor, die sich auf die Funktionsweise oder das Verhalten Ihrer Integration auswirken können. In diesem Leitfaden werden die neuesten Änderungen erläutert, um Sie bei der Aktualisierung Ihrer Integration zu unterstützen. > Erstellen Sie gerade eine neue Stripe Terminal-Integration? Auf unserer Seite zum [Entwerfen einer Integration](https://docs.stripe.com/terminal/designing-integration.md) erfahren Sie, wie Sie beginnen können. ## Migration zu Version 5.0.0 Hier erfahren Sie, was Sie über die SDKs für 5.0.0 Stripe Terminal iOS und Android wissen müssen: - Vereinfachte Integration von Zahlungen - Zahlungsabwicklung, Setup Intents und Rückerstattungen mit einem einzigen Methodenaufruf, bei die Schritte der Erfassung und der Bestätigung kombiniert werden. - Unterstützt moderne asynchrone Swift-Varianten und Kotlin Coroutines zur Vereinfachung komplexer asynchroner Abläufe - Swift Concurrency (async/await) für iOS und Kotlin Coroutines für Android. - Kundenstornierung standardmäßig aktiviert - Auf unterstützten Lesegeräten können Kundinnen und Kunden jetzt standardmäßig Transaktionen während der Zahlung, Einrichtung, Rückerstattung und der Datenerfassung stornieren. - Verbesserte Beobachtung der automatischen Wiederverbindung des mobilen Lesegeräts und des Tap-to-Pay-Lesegeräts - Verbesserte automatische Behandlung der Wiederverbindung von Lesegeräten mit mehr Verbindungsstatus für mobile Lesegeräte (Bluetooth und USB) und Tap-to-Pay-Lesegeräte. - Karten für Tap to Pay auf Android unterstützen (Öffentliche Vorschau) - Discover-Kartenzahlungen mit Tap to Pay auf Android annehmen. - Aktualisiert auf die unterstützten Mindestversionen der Plattformen von iOS 14.0 auf iOS 15.0 # iOS > This is a iOS for when terminal-sdk-platform is ios. View the full page at https://docs.stripe.com/terminal/references/sdk-migration-guide?terminal-sdk-platform=ios. Wenn Ihre Anwendung derzeit eine Terminal-iOS-SDK-Version vor 5.0.0 verwendet, müssen Sie mehrere Änderungen für ein Upgrade vornehmen. Eine detaillierte Liste der Änderungen von Version 4.x auf 5.0.0 finden Sie im [SDK-Änderungsprotokoll](https://github.com/stripe/stripe-terminal-ios/blob/master/CHANGELOG.md). ## Aktualisieren Sie Ihre unterstützte Mindestversion auf iOS 15 oder höher Wir aktualisieren regelmäßig die unterstützte Mindestversion unserer SDKs, um unseren Entwicklerinnen und Entwicklern die bestmögliche Erfahrung zu bieten. Vorhandene 4.X-Versionen des Terminal iOS SDK unterstützen weiterhin Geräte mit *iOS 14* und höher. ## Vereinfachte Integration von Zahlungen ### Aktualisierung auf einheitliche Zahlungsabwicklung Das v5 SDK enthält Methoden, die die Schritte der Erfassung und Bestätigung in einem einzigen Vorgang kombinieren. Während die bestehenden Methoden `collectPaymentMethod` und `confirmPaymentIntent` weiterhin funktionieren, empfehlen wir für einfachere Integrationen die Verwendung der einheitlichen Methoden. #### Zahlungen mit processPaymentIntent abwickeln Ersetzen Sie die zweistufige Erfassung und Bestätigung durch einen einzigen Aufruf der Methode `processPaymentIntent`. _Vorher _ #### Swift ```swift // Step 1: Collect payment method Terminal.shared.collectPaymentMethod(paymentIntent, collectConfig: collectConfig) { collectedPaymentIntent, collectError in guard let collectedPaymentIntent = collectedPaymentIntent else { // Payment method collection failed return } // Step 2: Confirm the payment Terminal.shared.confirmPaymentIntent(collectedPaymentIntent) { confirmedPaymentIntent, confirmError in if let confirmedPaymentIntent = confirmedPaymentIntent { // Payment successful } else { // Payment confirmation failed } } } ``` _Nachher _ #### Swift ```swift // Process and confirm the payment in one step Terminal.shared.processPaymentIntent(paymentIntent, collectConfig: collectConfig) { processedPaymentIntent, processError in if let processedPaymentIntent = processedPaymentIntent { // Payment successful } else { // Payment failed } } ``` #### Abwicklung von Rückerstattungen mit processRefund Die Methoden `collectRefundPaymentMethod` und `confirmRefund` sind jetzt veraltet. Verwenden Sie stattdessen `processRefund`. _Vorher _ #### Swift ```swift // Step 1: Collect refund payment method Terminal.shared.collectRefundPaymentMethod(refundParams) { collectError in guard collectError == nil else { // Refund collection failed return } // Step 2: Confirm the refund Terminal.shared.confirmRefund { refund, confirmError in if let refund = refund { // Refund successful } else { // Refund confirmation failed } } } ``` _Nachher _ #### Swift ```swift // Process the refund in one step Terminal.shared.processRefund(refundParams) { refund, refundError in if let refund = refund { // Refund successful } else { // Refund failed } } ``` #### SetupIntents mit processSetupIntent verarbeiten Zweistufige Lösung zum Erfassen und Bestätigen durch einen einzigen Aufruf der Methode `processSetupIntent` ersetzen. _Vorher _ #### Swift ```swift // Step 1: Collect setup intent payment method Terminal.shared.collectSetupIntentPaymentMethod(setupIntent, customerConsentCollected: true) { collectedSetupIntent, collectError in guard let collectedSetupIntent = collectedSetupIntent else { // Setup intent collection failed return } // Step 2: Confirm the setup intent Terminal.shared.confirmSetupIntent(collectedSetupIntent) { confirmedSetupIntent, confirmError in if let confirmedSetupIntent = confirmedSetupIntent { // Setup intent successful } else { // Setup intent confirmation failed } } } ``` _Nachher _ #### Swift ```swift // Configure with allowRedisplay let config = try CollectSetupIntentConfigurationBuilder() .setAllowRedisplay(.always) .build() // Process the setup intent in one step Terminal.shared.processSetupIntent(setupIntent, collectConfig: config) { processedSetupIntent, setupError in if let processedSetupIntent = processedSetupIntent { // Setup intent successful } else { // Setup intent failed } } ``` ### Support für Swift-async-Variante Das SDK bietet jetzt asynchrone Varianten für Terminal-Methoden. Sie können saubereren, sequentiellen Code schreiben, anstatt Abschluss-Handler zu verschachteln. _Vorher _ ```swift let cancelable = Terminal.shared.collectPaymentMethod(paymentIntent, collectConfig: collectConfig) { collectedPaymentIntent, collectError in guard let collectedPaymentIntent = collectedPaymentIntent else { // Payment method collection failed return } Terminal.shared.confirmPaymentIntent(collectedPaymentIntent) { confirmedPaymentIntent, confirmError in // Handle confirmation } } ``` _Nachher _ ```swift let collectTask = Task { do { let collectedIntent = try await Terminal.shared.collectPaymentMethod(paymentIntent, collectConfig: collectConfig) let confirmedIntent = try await Terminal.shared.confirmPaymentIntent(collectedIntent) // Payment successful } catch { // Handle error } } // Use collectTask.cancel() to cancel the operation when needed ``` ## Plattform und Initialisierung ### Terminal Initialisierung aktualisieren Die Methode `setTokenProvider` wurde entfernt. Sie müssen das SDK nun mit der statischen Methode `Datenterminal.initWithTokenProvider(_tokenProvider:)` initialisieren, bevor Sie auf das Singleton `Datenterminal.shared` zugreifen können. _Vorher _ #### Swift ```swift // In your AppDelegate or scene delegate Terminal.setTokenProvider(yourTokenProvider) ``` _Nachher _ #### Swift ```swift // In your AppDelegate or scene delegate, at app launch Terminal.initWithTokenProvider(yourTokenProvider) ``` ## Erkennung und Verbindung des Lesegeräts ### DiscoveryConfiguration-Initialisierung aktualisieren Sie können `DiscoveryConfiguration`-Objekte nicht mehr direkt mit `init` oder `new` initialisieren. Sie müssen jetzt die zugehörigen Builder-Klassen verwenden. _Vorher _ #### Swift ```swift let config = SCPInternetDiscoveryConfiguration(isSimulated: true) ``` _Nachher _ #### Swift ```swift let config = InternetDiscoveryConfiguration.Builder() .setSimulated(true) .build() ``` ### Umgang mit Änderungen des Wiederverbindungsstatus Ein neuer `.reconnecting`-Wert wurde zur `ConnectionStatus`-Enumeration hinzugefügt. Während einer erneuten Verbindung ist `Terminal.shared.connectedReader` jetzt `null`, bis die erneute Verbindung erfolgreich war. _Vorher _ #### Swift ```swift func terminal(_ terminal: Terminal, didChange connectionStatus: ConnectionStatus) { switch connectionStatus { case .notConnected: // Handle not connected case .connected: // Handle connected @unknown default: break } } ``` _Nachher _ #### Swift ```swift func terminal(_ terminal: Terminal, didChange connectionStatus: ConnectionStatus) { switch connectionStatus { case .notConnected: // Handle not connected case .connected: // Handle connected case .reconnecting: // Handle reconnection in progress @unknown default: break } } ``` ### Optimierte Verbindung mit easyConnect Für Smart Reader und Tap-to-Pay-Integrationen mit iOS SDK 5.1 oder neuer, können Sie jetzt `Terminal.shared.easyConnect`verwenden, das Entdeckung und Verbindung in einem einzigen Methodenaufruf vereint. _Vorher _ #### Swift ```swift // Step 1: Discover the reader Terminal.shared.discoverReaders(config, delegate: discoveryDelegate) { error in if let error = error { // Handle discovery error } } // In your DiscoveryDelegate func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) { guard let selectedReader = readers.first else { return } // Step 2: Connect to the reader Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in if let reader = reader { // Handle successful connection } else if let error = error { // Handle connection error } } } ``` _Nachher _ #### Swift ```swift // Discover and connect in one step by providing discovery filter let discoveryConfig = try InternetDiscoveryConfigurationBuilder() .setLocationId("tml_1234567890") // optional, specify your location ID .setDiscoveryFilter(.bySerial("YOUR-READER-SERIAL-NUMBER")) .build() let connectionConfig = try InternetConnectionConfigurationBuilder() .setFailIfInUse(false) .build() let easyConnectConfig = InternetEasyConnectConfiguration( discoveryConfiguration: discoveryConfig, connectionConfiguration: connectionConfig ) Terminal.shared.easyConnect( easyConnectConfig, delegate: internetReaderDelegate ) { reader, error in if let reader = reader { // Handle successful connection } else if let error = error { // Handle failure } } ``` ### Erkennungsfilterung für Internet-Lesegeräte Die Erkennung von Internet-Lesegeräten unterstützt jetzt die Filterung nach Lesegerät-ID oder Seriennummer. Legen Sie die Eigenschaft `discoveryFilter` in `InternetDiscoveryConfigurationBuilder` fest, um ein bestimmtes Lesegerät zu erkennen. _Vorher _ #### Swift ```swift let config = InternetDiscoveryConfigurationBuilder() .setLocationId("tml_1234567890") .build() ``` _Nachher _ #### Swift ```swift let config = try InternetDiscoveryConfigurationBuilder() .setLocationId("tml_1234567890") // optional .setDiscoveryFilter(.bySerial("READER-SERIAL-NUMBER")) // or .byReaderId("tmr_YOUR-READER-STRIPE-ID") to filter by reader id .build() ``` ## Annahme von Zahlungen und Datenerfassung ### Kundenstornierung ist jetzt standardmäßig aktiviert Auf unterstützten Lesegeräten ist die Möglichkeit für Kundinnen und Kunden, Transaktionen zu stornieren, jetzt *standardmäßig aktiviert*. Die Eigenschaft `customerCancellation` wurde von einem `Bool` in die neue Enumeration `SCPCustomerCancellation` geändert. _Vorher _ #### Swift ```swift let collectConfig = try CollectConfigurationBuilder() .setEnableCustomerCancellation(false) .build() ``` _Nachher _ #### Swift ```swift let collectConfig = try CollectPaymentIntentConfigurationBuilder() .setCustomerCancellation(.disableIfAvailable) .build() ``` ### Aktualisierungen der Interac-Rückerstattungsparameter Wenn Sie `SCPRefundParameters` für eine Interac-Rückerstattung mit einer PaymentIntent-ID erstellen, müssen Sie jetzt auch das `clientSecret` des PaymentIntents übergeben. Alternativ können Sie die ID der Zahlung weiter verwenden, für die kein `clientSecret` erforderlich ist. _Vorher _ #### Swift ```swift let refundParams = try RefundParametersBuilder( paymentIntentId: "pi_123", amount: 1000, currency: "cad" ).build() ``` _Nachher _ #### Swift ```swift let refundParams = try RefundParametersBuilder( paymentIntentId: "pi_123", clientSecret: "pi_123_secret_abc", amount: 1000, currency: "cad" ).build() ``` # Android > This is a Android for when terminal-sdk-platform is android. View the full page at https://docs.stripe.com/terminal/references/sdk-migration-guide?terminal-sdk-platform=android. Wenn Ihre Anwendung derzeit eine Terminal-Android-SDK-Version vor 5.0.0 verwendet, müssen Sie mehrere Änderungen für ein Upgrade vornehmen. Eine detaillierte Liste der Änderungen von Version 4.x auf 5.0.0 finden Sie im [SDK-Änderungsprotokoll](https://github.com/stripe/stripe-terminal-android/blob/master/CHANGELOG.md). ## Vereinfachte Integration von Zahlungen ### Aktualisierung auf einheitliche Zahlungsabwicklung Das v5 SDK führt optimierte Methoden ein, die die Schritte der Erfassung und Bestätigung in einem einzigen Vorgang kombinieren. Während die bestehenden Methoden `collectPaymentMethod` und `confirmPaymentIntent` weiterhin funktionieren, empfehlen wir die Verwendung der neuen einheitlichen Methoden für einfachere Integrationen. #### Zahlungen mit processPaymentIntent abwickeln Ersetzen Sie die zweistufige Erfassung und Bestätigung durch einen einzigen Aufruf der Methode `processPaymentIntent`. _Vorher _ #### Kotlin ```kotlin // Step 1: Collect payment method Terminal.getInstance().collectPaymentMethod( paymentIntent, collectConfig, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Step 2: Confirm the payment Terminal.getInstance().confirmPaymentIntent(paymentIntent, object : PaymentIntentCallback { override fun onSuccess(confirmedPaymentIntent: PaymentIntent) { // Payment successful } override fun onFailure(e: TerminalException) { // Payment confirmation failed } }) } override fun onFailure(e: TerminalException) { // Payment method collection failed } } ) ``` _Nachher _ #### Kotlin ```kotlin // Process and confirm the payment in one step Terminal.getInstance().processPaymentIntent( paymentIntent, collectConfig, confirmConfig, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Payment successful } override fun onFailure(e: TerminalException) { // Payment failed } } ) ``` #### Abwicklung von Rückerstattungen mit processRefund Die Methoden `collectRefundPaymentMethod` und `confirmRefund` sind jetzt veraltet. Verwenden Sie stattdessen `processRefund`. _Vorher _ #### Kotlin ```kotlin // Step 1: Collect refund payment method val refundParams = RefundParameters.ByChargeId( id = "ch_123", amount = 1000L, currency = "cad" ).build() Terminal.getInstance().collectRefundPaymentMethod( refundParams, object : Callback { override fun onSuccess() { // Step 2: Confirm the refund Terminal.getInstance().confirmRefund(object : RefundCallback { override fun onSuccess(refund: Refund) { // Refund successful } override fun onFailure(e: TerminalException) { // Refund confirmation failed } }) } override fun onFailure(e: TerminalException) { // Refund collection failed } } ) ``` _Nachher _ #### Kotlin ```kotlin val refundParams = RefundParameters.ByChargeId( id = "ch_123", amount = 1000, currency = "cad" ).build() // Process the refund in one step Terminal.getInstance().processRefund( refundParams, object : RefundCallback { override fun onSuccess(refund: Refund) { // Refund successful } override fun onFailure(e: TerminalException) { // Refund failed } } ) ``` #### SetupIntents mit processSetupIntent verarbeiten Zweistufige Lösung zum Erfassen und Bestätigen durch einen einzigen Aufruf der Methode `processSetupIntent` ersetzen. _Vorher _ #### Kotlin ```kotlin // Step 1: Collect setup intent payment method Terminal.getInstance().collectSetupIntentPaymentMethod( intent = setupIntent, allowRedisplay = AllowRedisplay.ALWAYS, callback = object : SetupIntentCallback { override fun onSuccess(setupIntent: SetupIntent) { // Step 2: Confirm the setup intent Terminal.getInstance().confirmSetupIntent(setupIntent, object : SetupIntentCallback { override fun onSuccess(confirmedSetupIntent: SetupIntent) { // Setup intent successful } override fun onFailure(e: TerminalException) { // Setup intent confirmation failed } }) } override fun onFailure(e: TerminalException) { // Setup intent collection failed } } ) ``` _Nachher _ #### Kotlin ```kotlin // Configure with allowRedisplay val config = CollectSetupIntentConfiguration.Builder() .build() // Process the setup intent in one step Terminal.getInstance().processSetupIntent( intent = setupIntent, allowRedisplay = AllowRedisplay.ALWAYS, collectConfig = config, callback = object : SetupIntentCallback { override fun onSuccess(setupIntent: SetupIntent) { // Setup intent successful } override fun onFailure(e: TerminalException) { // Setup intent failed } } ) ``` ### Support für Kotlin Coroutines Für Kotlin-Entwickler stellt ein neues optionales Modul `stripeterminal-ktx` `suspend`-Funktions-Wrapper für asynchrone Terminal-APIs bereit. > Fügen Sie diese Abhängigkeit hinzu: `Implementierung("com.tripe:stripeterminal-ktx:5.0.0")` _Vorher _ ```kotlin Terminal.getInstance().discoverReaders(config, object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { val selectedReader = readers[0] Terminal.getInstance().connectReader(selectedReader, connectionConfig, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Handle successful connection } override fun onFailure(e: TerminalException) { // Handle connection failure } }) } }) ``` _Nachher _ ```kotlin // Add dependency: implementation("com.stripe:stripeterminal-ktx:5.0.0") coroutineScope { try { val readers = Terminal.getInstance().discoverReaders(discoveryConfig) .filter { it.isNotEmpty() } .first() val selectedReader = readers.first() val reader = Terminal.getInstance().connectReader(selectedReader, connectConfig) // Handle successful connection } catch(e: TerminalException) { // Handle failures on discovery or connect } } ``` ## Plattform und Initialisierung ### Terminal Initialisierung aktualisieren Die Methode `Terminal.initTerminal` wurde in `Terminal.init` umbenannt. Sie erfordert jetzt einen annullierbaren `OfflineListener`-Parameter. _Vorher _ #### Kotlin ```kotlin Terminal.initTerminal(applicationContext, LogLevel.VERBOSE, tokenProvider, terminalListener) ``` _Nachher _ #### Kotlin ```kotlin Terminal.init(applicationContext, LogLevel.VERBOSE, tokenProvider, terminalListener, offlineListener) ``` ## Erkennung und Verbindung des Lesegeräts ### Umgang mit Änderungen des Wiederverbindungsstatus Ein neuer `RECONNECTING`-Wert wurde zur `ConnectionStatus`-Enumeration hinzugefügt. Während der ersten Verbindung ist `Terminal.getInstance().getConnectedReader()` jetzt `null`, bis der Verbindungsversuch erfolgreich ist. _Vorher _ #### Kotlin ```kotlin override fun onConnectionStatusChange(status: ConnectionStatus) { when (status) { ConnectionStatus.NOT_CONNECTED -> { // Handle not connected } ConnectionStatus.CONNECTED -> { // Handle connected } } } ``` _Nachher _ #### Kotlin ```kotlin override fun onConnectionStatusChange(status: ConnectionStatus) { when (status) { ConnectionStatus.NOT_CONNECTED -> { // Handle not connected } ConnectionStatus.CONNECTED -> { // Handle connected } ConnectionStatus.RECONNECTING -> { // Handle reconnection in progress } } } ``` ### Optimierte Verbindung mit easyConnect Für die Integration intelligenter Lesegeräte, Tap to Pay und Apps auf Geräten können Sie jetzt `Terminal.easyConnect` verwenden, das Erkennung und Verbindung in einem einzigen Methodenaufruf vereint. _Vorher _ #### Kotlin ```kotlin // Step 1: Discover the reader Terminal.getInstance().discoverReaders(config, object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { val selectedReader = readers[0] // Step 2: Connect to the reader Terminal.getInstance().connectReader(selectedReader, connectionConfig, readerCallback) } }) ``` _Nachher _ #### Kotlin ```kotlin // Discover and connect in one step by providing discovery filter val easyConnectConfig = InternetEasyConnectConfiguration( discoveryConfiguration = DiscoveryConfiguration.InternetDiscoveryConfiguration( location = "YOUR-LOCATION-ID", // optional discoveryFilter = DiscoveryFilter.BySerial("YOUR-READER-SERIAL-NUMBER"), ), connectionConfiguration = ConnectionConfiguration.InternetConnectionConfiguration( internetReaderListener = internetReaderListener, ) ) Terminal.getInstance().easyConnect( easyConnectConfig, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Handle successful connection } override fun onFailure(e: TerminalException) { // Handle failure } } ) ``` ### Erkennungsfilterung für Internet-Lesegeräte Die Erkennung von Internet-Lesegeräten unterstützt jetzt die Filterung nach Lesegerät-ID oder Seriennummer. Legen Sie die Eigenschaft `discoveryFilter` in `InternetDiscoveryConfiguration` fest, um ein bestimmtes Lesegerät zu erkennen. _Vorher _ #### Kotlin ```kotlin val config = InternetDiscoveryConfiguration(location = "tml_1234567890") ``` _Nachher _ #### Kotlin ```kotlin val config = InternetDiscoveryConfiguration( location = "tml_1234567890", // optional discoveryFilter = DiscoveryFilter.BySerial("READER-SERIAL-NUMBER"), // or DiscoveryFilter.ByReaderId("tmr_YOUR-READER-STRIPE-ID) to filter by reader id ) ``` ## Annahme von Zahlungen und Datenerfassung ### Kundenstornierung ist jetzt standardmäßig aktiviert Bei Android-basierten Lesegeräten ist die Möglichkeit für Kundinnen und Kunden, Transaktionen zu stornieren, jetzt *standardmäßig aktiviert*. Sie können diese Funktion deaktivieren, indem Sie `customerCancellation` auf `DISABLE_IF_AVAILABLE` festlegen. _Vorher _ #### Kotlin ```kotlin val config = CollectConfiguration.Builder() .setEnableCustomerCancellation(false) .build() ``` _Nachher _ #### Kotlin ```kotlin val config = CollectPaymentIntentConfiguration.Builder() .setCustomerCancellation(CustomerCancellation.DISABLE_IF_AVAILABLE) .build() ``` ### Aktualisierungen der Interac-Rückerstattungsparameter Wenn Sie `RefundParameter` für eine Interac-Rückerstattung mit einer PaymentIntent ID erstellen, müssen Sie jetzt auch das `clientSecret` des PaymentIntents übergeben. Alternativ können Sie auch die ID der Zahlung weiter verwenden, für die kein `clientSecret` erforderlich ist. _Vorher _ #### Kotlin ```kotlin val refundParams = RefundParameters.Builder( RefundParameters.Id.PaymentIntent("pi_123"), 1000, "cad" ).build() ``` _Nachher _ #### Kotlin ```kotlin val refundParams = RefundParameters.ByPaymentIntentId( paymentIntentId = "pi_123", clientSecret = "pi_123_secret_abc", amount = 1000, currency = "cad" ).build() ``` ## Aktualisieren Sie Ihre Apps on Devices-Integration Die Maven-Koordinaten für die Funktion „Apps on Devide“ wurden in `com.stripe:stripeterminal-appsondevices:5.0.0` geändert. Aktualisieren Sie Ihre Build-Abhängigkeiten, um auf den neuen Artefaktnamen zu verweisen. Stripe aktualisiert das alte Artefakt `handoffclient` nicht mehr. Wir haben alle `Handoff`-Klassennamen in `AppsOnDevices` umbenannt, um die Funktionalität der Funktion besser zu beschreiben. _Vorher _ #### Kotlin ```kotlin dependencies { implementation("com.stripe:stripeterminal-handoffclient:4.0.0") } ``` _Nachher _ #### Kotlin ```kotlin dependencies { implementation("com.stripe:stripeterminal-appsondevices:5.0.0") } ``` ### Benennen Sie Handoff-Klassen in AppsOnDevices um Wir haben alle `Handoff`-Klassennamen in `AppsOnDevices` umbenannt, und zwar in den Bereichen Discovery-Konfiguration, Verbindungskonfiguration, Listener und Token-Anbieter. _Vorher _ #### Kotlin ```kotlin val discoveryConfig = HandoffDiscoveryConfiguration() Terminal.getInstance().discoverReaders( discoveryConfig, object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { val reader = readers.first() val connectionConfig = HandoffConnectionConfiguration( handoffReaderListener = object : HandoffReaderListener { override fun onDisconnect(reason: DisconnectReason) { // Handle disconnect } } ) Terminal.getInstance().connectReader(reader, connectionConfig, readerCallback) } } ) val tokenProvider = HandoffConnectionTokenProvider() ``` _Nachher _ #### Kotlin ```kotlin val discoveryConfig = AppsOnDevicesDiscoveryConfiguration() Terminal.getInstance().discoverReaders( discoveryConfig, object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { val reader = readers.first() val connectionConfig = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = object : AppsOnDevicesListener { override fun onDisconnect(reason: DisconnectReason) { // Handle disconnect } } ) Terminal.getInstance().connectReader(reader, connectionConfig, readerCallback) } } ) val tokenProvider = AppsOnDevicesConnectionTokenProvider() ``` ## Integration von Tap to Pay auf Android aktualisieren ### Systemanforderungen Tap to Pay auf Android 5.0.0 und höher erfordert, dass auf Ihrem Android-Gerät Android 13 oder höher ausgeführt wird. Diese Version setzt auch voraus, dass der KeyStore Ihres Android-Geräts hardwaregestützte Schlüsselvereinbarungen unterstützt. Dies wird automatisch von `supportsReadersOfType()` für Sie überprüft, kann aber auch verifiziert werden, indem überprüft wird, ob die Version [`Funktion_HARDWARE_KEYSTORE`](https://developer.android.com/reference/android/content/pm/PackageManager#FEATURE_HARDWARE_KEYSTORE) Ihres Geräts 100 oder höher ist. Da diese Anforderung von den Hardware-Funktionen eines Geräts abhängt, wird sie möglicherweise von Geräten, die ursprünglich mit Android 12 oder niedriger veröffentlicht wurden, nicht erfüllt, selbst wenn sie aktualisiert wurden, um die Android 13-Laufzeitanforderung zu erfüllen. Diese neue Anforderung bedeutet, dass Geräte wie das Samsung Galaxy Tab Active4 Pro in den SDK-Versionen 5.0.0 und höher nicht mehr unterstützt werden. In Produktionsumgebungen schlägt die Erkennung des Lesegeräts mit einem `TAP_TO_PAY_INSECURE_ENVIRONMENT`-Fehler fehl, wenn Entwickler-Optionen, USB- oder die WLAN-Fehlerbehebung oder andere Fehlerbehebungsoptionen auf dem Gerät aktiviert sind. Dies gilt nicht für die Nutzung des simulierten Tap-to-Pay-Lesegeräts. ### TapZone-Konfigurations-Refactoring Die Klasse `TapToPayUxConfiguration.TapZone` wurde neu refaktoriert. Die Felder `indicator` und `position` werden durch ein einzelnes `TapZone`-Objekt ersetzt. _Vorher _ #### Kotlin ```kotlin val config = TapToPayUxConfiguration.Builder() .setTapZone( indicator = TapZoneIndicator.ABOVE, position = TapZonePosition.Manual(0.5f, 0.2f) ) .build() ``` _Nachher _ #### Kotlin ```kotlin // Position the tap zone above the reader UI val config = TapToPayUxConfiguration.Builder() .setTapZone(TapZone.Above(horizontalBias = 0.2f)) .build() // Or position it on the left side of the screen val config2 = TapToPayUxConfiguration.Builder() .setTapZone(TapZone.Left()) // Center vertically by default .build() ```