# Kartenzahlungen offline einziehen Ziehen Sie Kartenzahlungen ein, wenn Sie Probleme mit der Internetverbindung haben. # iOS > This is a iOS for when terminal-card-present-integration is terminal and terminal-sdk-platform is ios and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=ios&reader-type=bluetooth. Mit dem Terminal SDK kann Ihre Anwendung weiterhin Zahlungen über ein mobiles Lesegerät ohne Netzwerkverbindung einziehen. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Um den Offline-Modus zu verwenden, muss Ihre Anwendung Version `3.3.0` oder höher des Terminal iOS SDK nutzen. Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=bluetooth#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das SDK speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` und die Software Ihres Lesegeräts innerhalb dieser Zeit aktualisiert haben. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | Wenn Sie die Anwendung neu installieren oder einen Vorgang ausführen, der den Festplattenspeicher für das SDK löscht (z. B. das Löschen des Caches Ihrer POS-App in den Einstellungen des POS-Geräts), verlieren Sie alle Zahlungen, die im SDK gespeichert und noch nicht weitergeleitet wurden. Stellen Sie sicher, dass keine Zahlungen gespeichert sind, bevor Sie zerstörerische Aktionen durchführen. ## Offline-Ereignisse verarbeiten [Client-seitig] - [OfflineDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPOfflineDelegate.html) - [NetworkStatus (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPNetworkStatus.html) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie das `OfflineDelegate`-Protokoll und übergeben Sie es an das Terminal SDK. Sie müssen `OfflineDelegate` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. #### Swift ```swift import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { func terminal(_ terminal: Terminal, didChangeOfflineStatus offlineStatus: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal.shared.offlineStatus.sdk.networkStatus`. } func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent.stripeId` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent.stripeId` may still be nil if creating the // PaymentIntent in the backend failed. } func terminal(_ terminal: Terminal, didReportForwardingError error: Error) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` #### Swift ```swift import UIKit import StripeTerminal @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { Terminal.initWithTokenProvider(APIClient.shared) Terminal.shared.offlineDelegate = CustomOfflineDelegate() // ... return true } // ... } ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)createPaymentIntent:completion:) - [CreateConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCreateConfiguration.html) - [OfflineDetails (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPOfflineDetails.html) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `stripeId` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Nachdem der `PaymentIntent` in [Schritt 7](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) erfolgreich an Stripe weitergeleitet wurde, verwenden Sie Ihre individuelle Kennung, um sie im Aufruf `OfflineDelegate.didForwardPaymentIntent` abzugleichen. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // Populate the correct transaction amount from your application. let amount = UInt(10_00) // Build up parameters for creating a `PaymentIntent` let params = try PaymentIntentParametersBuilder( amount: amount, currency: "usd" ).setMetadata(["offlineId": UUID().uuidString]) .build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { // Handle errors in your application. print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded")// If the `PaymentIntent` was created offline, its `stripeId` field will be nil. if let onlineCreatedId = paymentIntent.stripeId { print("created online"); } else { print("created offline") } } } } } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.offlineStatus.sdk.offlinePaymentsCount` 1. `Terminal.offlineStatus.sdk.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `offlineBehavior`auf `FORCE_OFFLINE` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das SDK von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // ...build up parameters and callback for creating a `PaymentIntent` // Your app might want to prevent offline payments for too large an amount. // Here, we block the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.let offlineBehavior: SCPOfflineBehavior = { if amount > UInt(1_000_00) { return .requireOnline } else { return .preferOnline } }() let createConfiguration = try CreateConfigurationBuilder().setOfflineBehavior(offlineBehavior).build() Terminal.shared.createPaymentIntent(params, createConfig: createConfiguration) { createResult, createError in // handle success or failure } } } ``` ## Zahlungsmethode erfassen [Client-seitig] - [didRequestReaderInput (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDisplayDelegate.html#/c:objc\(pl\)SCPReaderDisplayDelegate\(im\)terminal:didRequestReaderInput:) - [CollectPaymentIntentConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCollectPaymentIntentConfiguration.html) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Verwenden Sie die Methode `didRequestReaderInput`, um Kundinnen/Kunden die gültigen Optionen zur Vorlage der Karte anzuzeigen. > Lesegeräte unterstützen die [Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=ios#collect-inspect-payment-method) nicht, während sie offline sind. Sie können zwar weiterhin den Parameter `initWithUpdatePaymentIntent` in `CollectPaymentIntentConfiguration` verwenden, aber das Feld `paymentMethod` im PaymentIntent fehlt, wenn das SDK offline betrieben wird. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.collectPaymentMethod(paymentIntent) { collectResult, collectError in if let error = collectError { print("collectPaymentMethod failed: \(error)") } else if let paymentIntent = collectResult { print("collectPaymentMethod succeeded") // ... Confirm the payment } } } } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. Wenn dies geschieht, hat der `PaymentIntent` möglicherweise eine `stripeId`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent= confirmResult {print("confirmPaymentIntent succeeded") if let offlineDetails = paymentIntent.offlineDetails { print("confirmed offline"); } else { print("confirmed online") } } } } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPOfflineCardPresentDetails.html) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPReceiptDetails.html) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Internet access wiederhergestellt wird, beginnt das SDK automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das SDK versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr POS-Gerät zu früh ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.offlineStatus.sdk.networkStatus` abfragen, um sicherzustellen, dass Ihr POS online ist und Zahlungen weiterleiten kann und `Terminal.offlineStatus.sdk.offlinePaymentsCount` , um zu überprüfen, wie viele Zahlungen an das Terminal-SDK weitergeleitet werden müssen. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `Succeeded` anstelle von `RequiresCapture`. Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineDelegate.didForwardPayment` für jeden PaymentIntent erhält, während das SDK diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `RequiresCapture` ist und `offlineDetails` null ist oder der Wert für `requiresUpload` gleich `NO` ist. #### Swift ```swift Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent = confirmResult { if intent.status == .requiresCapture {if let offlineDetails = confirmedPaymentIntent.offlineDetails(), offlineDetails.requiresUpload { // Offline payment, wait for `didForwardPaymentIntent` (see snippet below) } else { // Online payment, can be captured now } } // else, handle other intent.status results here } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das SDK dieses im `didForwardPaymentIntent` Ihres OfflineDelegate weitergeleitet hat: #### Swift ```swift import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { // ... func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { if let error = error { // Handle the error appropriate for your application return } if intent.status == .requiresCapture { // The intent is ready to be captured. } else { // Handle the intent.status as appropriate. } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # Android > This is a Android for when terminal-card-present-integration is terminal and terminal-sdk-platform is android and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=android&reader-type=bluetooth. Mit dem Terminal SDK kann Ihre Anwendung weiterhin Zahlungen über ein mobiles Lesegerät ohne Netzwerkverbindung einziehen. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Um den Offline-Modus zu verwenden, muss Ihre Anwendung Version `3.2.0` oder höher des Terminal Android SDK nutzen. Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=bluetooth#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das SDK speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` und die Software Ihres Lesegeräts innerhalb dieser Zeit aktualisiert haben. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | Wenn Sie die Anwendung neu installieren oder einen Vorgang ausführen, der den Festplattenspeicher für das SDK löscht (z. B. das Löschen des Caches Ihrer POS-App in den Einstellungen des POS-Geräts), verlieren Sie alle Zahlungen, die im SDK gespeichert und noch nicht weitergeleitet wurden. Stellen Sie sicher, dass keine Zahlungen gespeichert sind, bevor Sie zerstörerische Aktionen durchführen. ## Offline-Ereignisse verarbeiten [Client-seitig] - [OfflineListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-offline-listener/index.html) - [NetworkStatus (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-network-status/index.html) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie die `OfflineListener`-Schnittstelle und übergeben Sie sie an das Terminal SDK. Sie müssen `OfflineListener` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. #### Kotlin ```kotlin class CustomOfflineListener : OfflineListener { override fun onOfflineStatusChange(offlineStatus: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal::offlineStatus`. } override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent::id` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent::id` may still be null if creating the // PaymentIntent in the backend failed. } override fun onForwardingFailure(e: TerminalException) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` #### Kotlin ```kotlin Terminal.init( context = applicationContext, logLevel = LogLevel.VERBOSE, tokenProvider = CustomConnectionTokenProvider(), listener = CustomTerminalListener(), offlineListener = CustomOfflineListener(), ) ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/create-payment-intent.html) - [CreateConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-create-configuration/index.html) - [OfflineDetails (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-offline-details/index.html) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `id` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Nachdem der `PaymentIntent` in [Schritt 7](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) erfolgreich an Stripe weitergeleitet wurde, verwenden Sie Ihre individuelle Kennung, um sie im Aufruf `OfflineListener::onPaymentIntentForwarded` abzugleichen. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { // Build up parameters for creating a `PaymentIntent` val params = PaymentIntentParameters.Builder() .setAmount(cart.total) .setCurrency(cart.currency).setMetadata(mapOf("unique-id" to UUID.randomUUID().toString())) .build() val createPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "createPaymentIntent succeeded")// If the `PaymentIntent` was created offline, its `id` field will be null. if (paymentIntent.id != null) { Log.d(TAG, "created online") } else { Log.d(TAG, "created offline") } // ... Collect a PaymentMethod } override fun onFailure(e: TerminalException) { Log.e(TAG, "createPaymentIntent failed", e) // Handle errors in your application. } } Terminal.getInstance().createPaymentIntent(params, createPaymentCallback) } } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.offlineStatus.sdk.offlinePaymentsCount` 1. `Terminal.offlineStatus.sdk.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `offlineBehavior`auf `FORCE_OFFLINE` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das SDK von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { // ...build up parameters and callback for creating a `PaymentIntent` // Your app might want to prevent offline payments for too large an amount. // Here, we require a network connection if the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.val offlineBehavior = if (cart.total > 1000000) { OfflineBehavior.REQUIRE_ONLINE } else { OfflineBehavior.PREFER_ONLINE } val createConfig = CreateConfiguration(offlineBehavior) Terminal.getInstance().createPaymentIntent(params, createPaymentCallback, createConfig) } } ``` ## Zahlungsmethode erfassen [Client-seitig] - [onRequestReaderInput (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-listener/on-request-reader-input.html) - [CollectPaymentIntentConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/index.html) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Verwenden Sie die Methode `onRequestReaderInput`, um Kundinnen/Kunden die gültigen Optionen zur Vorlage der Karte anzuzeigen. > Lesegeräte unterstützen die [Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=android#collect-inspect-payment-method) nicht, während sie offline sind. Sie können den Parameter `update PaymentIntent` zwar weiterhin in `CollectPaymentIntentConfiguration` festlegen, aber das Feld `paymentMethod` im PaymentIntent fehlt, wenn das SDK offline betrieben wird. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val collectPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "collectPaymentMethod succeeded") // ... Confirm the payment } override fun onFailure(e: TerminalException) { Log.d(TAG, "collectPaymentMethod failed:", e) } } val collectConfig = CollectPaymentIntentConfiguration.Builder().build() Terminal.getInstance().collectPaymentMethod(paymentIntent, collectPaymentCallback, collectConfig) } } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. In diesem Fall hat der `PaymentIntent` möglicherweise eine `id`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val confirmPaymentIntentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "confirmPaymentIntent succeeded")// If the `PaymentIntent` was confirmed offline, `paymentIntent.offlineDetails` will be defined if (paymentIntent.offlineDetails != null) { Log.d(TAG, "confirmed offline") } else { Log.d(TAG, "confirmed online") } } override fun onFailure(e: TerminalException) { // Handle offline-specific errors in your application (for example, // unsupported payment method). Log.e(TAG, "confirmPaymentIntent failed:", e) } } Terminal.getInstance().confirmPaymentIntent(paymentIntent, confirmPaymentIntentCallback) } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-offline-card-present-details/index.html) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-receipt-details/index.html) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Internet access wiederhergestellt wird, beginnt das SDK automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das SDK versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr POS-Gerät zu früh ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.offlineStatus.sdk.networkStatus` abfragen, um sicherzustellen, dass Ihr POS online ist und Zahlungen weiterleiten kann und `Terminal.offlineStatus.sdk.offlinePaymentsCount` , um zu überprüfen, wie viele Zahlungen an das Terminal-SDK weitergeleitet werden müssen. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `SUCCEEDED` anstelle von `REQUIRES_CAPTURE` . Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineListener::onPaymentIntentForwarded` für jeden PaymentIntent erhält, während das SDK diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `REQUIRES_CAPTURE` ist und `offlineDetails` null ist oder der Wert für `requiresUpload` gleich `false` ist. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val callback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "confirmPaymentIntent succeeded") if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) {val offlineDetails = paymentIntent.offlineDetails if (offlineDetails?.requiresUpload == true) { // Offline payment, wait for `onPaymentIntentForwarded` (see snippet below) } else { // Online payment, can be captured now } } else { // Handle other status results here } } override fun onFailure(e: TerminalException) { // Handle offline-specific errors in your application (for example, // unsupported payment method). Log.e(TAG, "confirmPaymentIntent failed:", e) } } Terminal.getInstance().confirmPaymentIntent(paymentIntent, callback) } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das SDK dieses im `OfflineListener::onPaymentIntentForwarded` weitergeleitet hat: #### Kotlin ```kotlin class CustomOfflineListener : OfflineListener { // ... override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) { if (e != null) { // Handle the error appropriate for your application } else if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) { // The paymentIntent is ready to be captured } else { // Handle other status results here } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # React Native > This is a React Native for when terminal-card-present-integration is terminal and terminal-sdk-platform is react-native and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=react-native&reader-type=bluetooth. Mit dem Terminal SDK kann Ihre Anwendung weiterhin Zahlungen über ein mobiles Lesegerät ohne Netzwerkverbindung einziehen. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=bluetooth#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das SDK speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` und die Software Ihres Lesegeräts innerhalb dieser Zeit aktualisiert haben. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | Wenn Sie die Anwendung neu installieren oder einen Vorgang ausführen, der den Festplattenspeicher für das SDK löscht (z. B. das Löschen des Caches Ihrer POS-App in den Einstellungen des POS-Geräts), verlieren Sie alle Zahlungen, die im SDK gespeichert und noch nicht weitergeleitet wurden. Stellen Sie sicher, dass keine Zahlungen gespeichert sind, bevor Sie zerstörerische Aktionen durchführen. ## Offline-Ereignisse verarbeiten [Client-seitig] - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) - [OfflineStatus (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#OfflineStatus) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie die Offline-Callbacks am `useStripeTerminal`-Hook. ```js const { connectReader, disconnectReader, connectedReader } = useStripeTerminal({ onDidChangeOfflineStatus(status: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. // // You can also check the SDK's current offline status calling // `getOfflineStatus`. }, onDidForwardingFailure(error) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. }, onDidForwardPaymentIntent(paymentIntent, error) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `paymentIntent.id` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `paymentIntent.id` may still be null if creating the // PaymentIntent in the backend failed. }, }); ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#createPaymentIntent) - [CreatePaymentIntentParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#CreatePaymentIntentParams) - [OfflineStatus (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#OfflineStatus) - [OfflineStatusDetails (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#OfflineStatusDetails) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `id` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Nachdem der `PaymentIntent` in [Schritt 7](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) erfolgreich an Stripe weitergeleitet wurde, verwenden Sie Ihre individuelle Kennung, um sie im Aufruf `onDidForwardPaymentIntent` abzugleichen. ```js const _createPaymentIntent = async (cart) => { const {error, paymentIntent} = await createPaymentIntent({ amount: cart.total, currency: cart.currency,metadata: { "unique-id": UUID().uuidString } }); } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `OfflineStatus.sdk.offlinePaymentsCount` 1. `OfflineStatus.sdk.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können `offlineBehavior` auf `force_offline` setzen, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das SDK von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. ```js const _createPaymentIntent = async (cart) => { // Your app might want to prevent offline payments for too large an amount. // Here, we require a network connection if the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.let offlineBehavior: if (cart.total > 1000000) { offlineBehavior = 'require_online' } else { offlineBehavior = 'prefer_online' } const {error, paymentIntent} = await createPaymentIntent({ amount: cart.total, currency: cart.currency,offlineBehavior, }); } ``` ## Zahlungsmethode erfassen [Client-seitig] - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) - [CollectPaymentMethodParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#CollectPaymentMethodParams) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Verwenden Sie die Methode , um Kundinnen/Kunden die gültigen Optionen zur Vorlage der Karte anzuzeigen. > [Die Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=react-native#collect-inspect-payment-method) wird offline nicht unterstützt. Obwohl Sie den Parameter `updatePaymentIntent` weiterhin in `CollectConfiguration` festlegen können, ist das Feld `paymentMethod`für den PaymentIntent nicht vorhanden, wenn das SDK offline arbeitet. ```js const _collectPaymentMethod_ = async () => { const { paymentIntent, error } = await collectPaymentMethod({ paymentIntent: paymentIntent }); if (error) { // Handle errors in your application. } // ... Confirm the payment } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. In diesem Fall hat der `PaymentIntent` möglicherweise eine `id`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. ```js const _confirmPaymentIntent = async () => { const { paymentIntent, error } = await confirmPaymentIntent({ paymentIntent: paymentIntent }); if (error) { // Handle offline-specific errors in your application (for example, // unsupported payment method). } if (paymentIntent.offlineDetails) { console.log('confirmed offline'); } else { console.log('confirmed online'); } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#OfflineCardPresentDetails) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#ReceiptDetails) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Internet access wiederhergestellt wird, beginnt das SDK automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das SDK versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr POS-Gerät zu früh ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `OfflineStatus.sdk.networkStatus` abfragen, um sicherzustellen, dass Ihr POS online ist und Zahlungen weiterleiten kann und `OfflineStatus.sdk.offlinePaymentsCount` , um zu überprüfen, wie viele Zahlungen an das Terminal-SDK weitergeleitet werden müssen. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `succeeded` anstelle von `requiresCapture` . Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `useStripeTerminal` hook’s `onDidForwardPaymentIntent` für jeden PaymentIntent erhält, während das SDK diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `requiresCapture` ist und `OfflineDetails` null ist oder der Wert für `requiresUpload` gleich `false` ist. ```js const _confirmPaymentIntent = async () => { const { paymentIntent, error } = await confirmPaymentIntent({ paymentIntent: paymentIntent }); if (error) { // Handle offline-specific errors in your application (for example, // unsupported payment method). } if (paymentIntent.status == 'requiresCapture') {const offlineDetails = paymentIntent.offlineDetails; if (offlineDetails.requiresUpload === true) { // Offline payment, wait for `onDidForwardPaymentIntent` (see snippet below) } else { // Online payment, can be captured now } } else { // handle other paymentIntent.status results here } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das SDK dieses im `onDidForwardPaymentIntent` weitergeleitet hat: ```js const { connectReader, disconnectReader, connectedReader } = useStripeTerminal({ onDidForwardPaymentIntent(paymentIntent, error) { if (error) { // Handle the error appropriate for your application } else if (paymentIntent.status == 'requires_capture') { // The paymentIntent is ready to be captured } else { // Handle the paymentIntent.status as appropriate. } }, }); ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # iOS > This is a iOS for when terminal-card-present-integration is terminal and terminal-sdk-platform is ios and reader-type is internet. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=ios&reader-type=internet. Das Terminal SDK ermöglicht es Ihrer Anwendung, mit einem intelligenten Lesegerät ohne Internetverbindung weiterhin Zahlungen einzuziehen. Wenn Sie ein separates POS-Gerät mit einem intelligenten Stripe-Lesegerät nutzen, benötigen Sie dennoch ein funktionierendes lokales Netzwerk, damit Ihr POS-Gerät mit dem intelligenten Lesegerät kommunizieren kann. Der Offline-Betrieb mit intelligenten Lesegeräten ist für Szenarien vorgesehen, bei denen Ihr POS und das Lesegerät nicht mit Stripe kommunizieren können, beispielsweise bei einem ISP-Ausfall. Wenn Sie offline ohne ein lokales Netzwerk arbeiten müssen, sollten Sie die [mobilen Lesegeräte](https://docs.stripe.com/terminal/mobile-readers.md) von Stripe Terminal in Betracht ziehen. Mit einer „Apps auf Geräten“-Integration können Sie auch offline arbeiten. Da Ihre POS-Anwendung direkt auf dem intelligenten Lesegerät ausgeführt wird, benötigen Sie kein lokales Netzwerk, um Zahlungen einzuziehen. Sie müssen sich jedoch immer noch in einem lokalen Netzwerk befinden, wenn Ihr Lesegerät zum ersten Mal gestartet wird, auch wenn das Netzwerk keinen Internetzugang hat. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Beim Offline-Betrieb mit einem internetfähigen Lesegerät speichert das Lesegerät erfasste Zahlungsinformationen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Um den Offline-Modus zu verwenden, muss Ihre Anwendung Version `3.3.0` oder höher des Terminal iOS SDK nutzen. Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=internet#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das Lesegerät speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` im selben lokalen Netzwerk eine Verbindung hergestellt haben. Das Lesegerät speichert die `Location`-Informationen lokal, nachdem es online eine Verbindung hergestellt hat, und leitet Konfigurationsinformationen von diesem `Location` ab, während es offline arbeitet. Ihr Lesegerät und Ihr POS-Gerät müssen sich im selben lokalen Netzwerk befinden, das für die Online-Verbindung verwendet wird. Im Offline-Modus können Sie nicht zwischen Netzwerken wechseln. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | ## Offline-Ereignisse verarbeiten [Client-seitig] - [OfflineDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPOfflineDelegate.html) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie das `OfflineDelegate`-Protokoll und übergeben Sie es an das Terminal SDK. Sie müssen `OfflineDelegate` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. #### Swift ```swift import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { func terminal(_ terminal: Terminal, didChangeOfflineStatus offlineStatus: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal.shared.offlineStatus.sdk.networkStatus`. } func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent.stripeId` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent.stripeId` may still be nil if creating the // PaymentIntent in the backend failed. } func terminal(_ terminal: Terminal, didReportForwardingError error: Error) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` #### Swift ```swift import UIKit import StripeTerminal @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { Terminal.initWithTokenProvider(APIClient.shared) Terminal.shared.offlineDelegate = CustomOfflineDelegate() // ... return true } // ... } ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)createPaymentIntent:completion:) - [CreateConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCreateConfiguration.html) - [OfflineDetails (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPOfflineDetails.html) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `stripeId` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Sie können einen [Webhook](https://docs.stripe.com/webhooks.md)-Endpoint einrichten, um `PaymentIntent`-Ereignisse zu empfangen, wenn Offline-Zahlungen an Stripe weitergeleitet werden, und diese mithilfe Ihrer Kennung mit einer `PaymentIntent`-ID zu verknüpfen. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // Populate the correct transaction amount from your application. let amount = UInt(10_00) // Build up parameters for creating a `PaymentIntent` let params = try PaymentIntentParametersBuilder( amount: amount, currency: "usd" ).setMetadata(["offlineId": UUID().uuidString]) .build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { // Handle errors in your application. print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded")// If the `PaymentIntent` was created offline, its `stripeId` field will be nil. if let onlineCreatedId = paymentIntent.stripeId { print("created online"); } else { print("created offline") } } } } } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das Lesegerät eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.offlineStatus.reader.offlinePaymentsCount` 1. `Terminal.offlineStatus.reader.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `offlineBehavior`auf `FORCE_OFFLINE` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das Lesegerät von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // ...build up parameters and callback for creating a `PaymentIntent` // Your app might want to prevent offline payments for too large an amount. // Here, we block the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.let offlineBehavior: SCPOfflineBehavior = { if amount > UInt(1_000_00) { return .requireOnline } else { return .preferOnline } }() let createConfiguration = try CreateConfigurationBuilder().setOfflineBehavior(offlineBehavior).build() Terminal.shared.createPaymentIntent(params, createConfig: createConfiguration) { createResult, createError in // handle success or failure } } } ``` ## Zahlungsmethode erfassen [Client-seitig] - [CollectPaymentIntentConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCollectPaymentIntentConfiguration.html) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Ihr intelligentes Lesegerät zeigt den Kundinnen und Kunden automatisch die verfügbaren Zahlungsoptionen an. > Lesegeräte unterstützen die [Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=ios#collect-inspect-payment-method) nicht, während sie offline sind. Sie können zwar weiterhin den Parameter `initWithUpdatePaymentIntent` in `CollectPaymentIntentConfiguration` verwenden, aber das Feld `paymentMethod` im PaymentIntent fehlt, wenn das SDK offline betrieben wird. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.collectPaymentMethod(paymentIntent) { collectResult, collectError in if let error = collectError { print("collectPaymentMethod failed: \(error)") } else if let paymentIntent = collectResult { print("collectPaymentMethod succeeded") // ... Confirm the payment } } } } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. Wenn dies geschieht, hat der `PaymentIntent` möglicherweise eine `stripeId`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent= confirmResult {print("confirmPaymentIntent succeeded") if let offlineDetails = paymentIntent.offlineDetails { print("confirmed offline"); } else { print("confirmed online") } } } } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPOfflineCardPresentDetails.html) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPReceiptDetails.html) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Netzwerkverbindung wiederhergestellt wird, beginnt das Lesegerät automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das Lesegerät versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr intelligentes Lesegerät zu früh trennen oder ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.offlineStatus.reader.networkStatus` abfragen, um sicherzustellen, dass Ihr Lesegerät online ist und Zahlungen weiterleiten kann, und `Terminal.offlineStatus.reader.offlinePaymentsCount`, um zu überprüfen, wie viele Zahlungen an das Lesegerät weitergeleitet werden müssen. Wenn Ihr intelligentes Lesegerät beschädigt wird oder anderweitig keine Zahlungen entgegennehmen kann, können Ihre gespeicherten Zahlungen oft dennoch weitergeleitet werden. Stellen Sie sicher, dass Sie das intelligente Lesegerät mit Ihrem POS verbinden und den Internetzugang wiederherstellen, damit es sich erneut mit Stripe verbinden kann. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `Succeeded` anstelle von `RequiresCapture`. Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineDelegate.didForwardPayment` für jeden PaymentIntent erhält, während das Lesegerät diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `RequiresCapture` ist und `offlineDetails` null ist oder der Wert für `requiresUpload` gleich `NO` ist. #### Swift ```swift Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent = confirmResult { if intent.status == .requiresCapture {if let offlineDetails = confirmedPaymentIntent.offlineDetails(), offlineDetails.requiresUpload { // Offline payment, wait for `didForwardPaymentIntent` (see snippet below) } else { // Online payment, can be captured now } } // else, handle other intent.status results here } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das Lesegerät dieses im `didForwardPaymentIntent` Ihres OfflineDelegate weitergeleitet hat: #### Swift ```swift import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { // ... func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { if let error = error { // Handle the error appropriate for your application return } if intent.status == .requiresCapture { // The intent is ready to be captured. } else { // Handle the intent.status as appropriate. } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # Android > This is a Android for when terminal-card-present-integration is terminal and terminal-sdk-platform is android and reader-type is internet. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=android&reader-type=internet. Das Terminal SDK ermöglicht es Ihrer Anwendung, mit einem intelligenten Lesegerät ohne Internetverbindung weiterhin Zahlungen einzuziehen. Wenn Sie ein separates POS-Gerät mit einem intelligenten Stripe-Lesegerät nutzen, benötigen Sie dennoch ein funktionierendes lokales Netzwerk, damit Ihr POS-Gerät mit dem intelligenten Lesegerät kommunizieren kann. Der Offline-Betrieb mit intelligenten Lesegeräten ist für Szenarien vorgesehen, bei denen Ihr POS und das Lesegerät nicht mit Stripe kommunizieren können, beispielsweise bei einem ISP-Ausfall. Wenn Sie offline ohne ein lokales Netzwerk arbeiten müssen, sollten Sie die [mobilen Lesegeräte](https://docs.stripe.com/terminal/mobile-readers.md) von Stripe Terminal in Betracht ziehen. Mit einer „Apps auf Geräten“-Integration können Sie auch offline arbeiten. Da Ihre POS-Anwendung direkt auf dem intelligenten Lesegerät ausgeführt wird, benötigen Sie kein lokales Netzwerk, um Zahlungen einzuziehen. Sie müssen sich jedoch immer noch in einem lokalen Netzwerk befinden, wenn Ihr Lesegerät zum ersten Mal gestartet wird, auch wenn das Netzwerk keinen Internetzugang hat. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Beim Offline-Betrieb mit einem internetfähigen Lesegerät speichert das Lesegerät erfasste Zahlungsinformationen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Um den Offline-Modus zu verwenden, muss Ihre Anwendung Version `3.2.0` oder höher des Terminal Android SDK nutzen. Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=internet#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das Lesegerät speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` im selben lokalen Netzwerk eine Verbindung hergestellt haben. Das Lesegerät speichert die `Location`-Informationen lokal, nachdem es online eine Verbindung hergestellt hat, und leitet Konfigurationsinformationen von diesem `Location` ab, während es offline arbeitet. Ihr Lesegerät und Ihr POS-Gerät müssen sich im selben lokalen Netzwerk befinden, das für die Online-Verbindung verwendet wird. Im Offline-Modus können Sie nicht zwischen Netzwerken wechseln. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | ## Offline-Ereignisse verarbeiten [Client-seitig] - [OfflineListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-offline-listener/index.html) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie die `OfflineListener`-Schnittstelle und übergeben Sie sie an das Terminal SDK. Sie müssen `OfflineListener` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. #### Kotlin ```kotlin class CustomOfflineListener : OfflineListener { override fun onOfflineStatusChange(offlineStatus: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal::offlineStatus`. } override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent::id` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent::id` may still be null if creating the // PaymentIntent in the backend failed. } override fun onForwardingFailure(e: TerminalException) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` #### Kotlin ```kotlin Terminal.init( context = applicationContext, logLevel = LogLevel.VERBOSE, tokenProvider = CustomConnectionTokenProvider(), listener = CustomTerminalListener(), offlineListener = CustomOfflineListener(), ) ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/create-payment-intent.html) - [CreateConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-create-configuration/index.html) - [OfflineDetails (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-offline-details/index.html) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `id` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Sie können einen [Webhook](https://docs.stripe.com/webhooks.md)-Endpoint einrichten, um `PaymentIntent`-Ereignisse zu empfangen, wenn Offline-Zahlungen an Stripe weitergeleitet werden, und diese mithilfe Ihrer Kennung mit einer `PaymentIntent`-ID zu verknüpfen. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { // Build up parameters for creating a `PaymentIntent` val params = PaymentIntentParameters.Builder() .setAmount(cart.total) .setCurrency(cart.currency).setMetadata(mapOf("unique-id" to UUID.randomUUID().toString())) .build() val createPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "createPaymentIntent succeeded")// If the `PaymentIntent` was created offline, its `id` field will be null. if (paymentIntent.id != null) { Log.d(TAG, "created online") } else { Log.d(TAG, "created offline") } // ... Collect a PaymentMethod } override fun onFailure(e: TerminalException) { Log.e(TAG, "createPaymentIntent failed", e) // Handle errors in your application. } } Terminal.getInstance().createPaymentIntent(params, createPaymentCallback) } } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das Lesegerät eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.offlineStatus.reader.offlinePaymentsCount` 1. `Terminal.offlineStatus.reader.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `offlineBehavior`auf `FORCE_OFFLINE` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das Lesegerät von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { // ...build up parameters and callback for creating a `PaymentIntent` // Your app might want to prevent offline payments for too large an amount. // Here, we require a network connection if the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.val offlineBehavior = if (cart.total > 1000000) { OfflineBehavior.REQUIRE_ONLINE } else { OfflineBehavior.PREFER_ONLINE } val createConfig = CreateConfiguration(offlineBehavior) Terminal.getInstance().createPaymentIntent(params, createPaymentCallback, createConfig) } } ``` ## Zahlungsmethode erfassen [Client-seitig] - [CollectPaymentIntentConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/index.html) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Ihr intelligentes Lesegerät zeigt den Kundinnen und Kunden automatisch die verfügbaren Zahlungsoptionen an. > Lesegeräte unterstützen die [Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=android#collect-inspect-payment-method) nicht, während sie offline sind. Sie können den Parameter `update PaymentIntent` zwar weiterhin in `CollectPaymentIntentConfiguration` festlegen, aber das Feld `paymentMethod` im PaymentIntent fehlt, wenn das SDK offline betrieben wird. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val collectPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "collectPaymentMethod succeeded") // ... Confirm the payment } override fun onFailure(e: TerminalException) { Log.d(TAG, "collectPaymentMethod failed:", e) } } val collectConfig = CollectPaymentIntentConfiguration.Builder().build() Terminal.getInstance().collectPaymentMethod(paymentIntent, collectPaymentCallback, collectConfig) } } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. In diesem Fall hat der `PaymentIntent` möglicherweise eine `id`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val confirmPaymentIntentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "confirmPaymentIntent succeeded")// If the `PaymentIntent` was confirmed offline, `paymentIntent.offlineDetails` will be defined if (paymentIntent.offlineDetails != null) { Log.d(TAG, "confirmed offline") } else { Log.d(TAG, "confirmed online") } } override fun onFailure(e: TerminalException) { // Handle offline-specific errors in your application (for example, // unsupported payment method). Log.e(TAG, "confirmPaymentIntent failed:", e) } } Terminal.getInstance().confirmPaymentIntent(paymentIntent, confirmPaymentIntentCallback) } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-offline-card-present-details/index.html) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-receipt-details/index.html) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Netzwerkverbindung wiederhergestellt wird, beginnt das Lesegerät automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das Lesegerät versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr intelligentes Lesegerät zu früh trennen oder ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.offlineStatus.reader.networkStatus` abfragen, um sicherzustellen, dass Ihr Lesegerät online ist und Zahlungen weiterleiten kann, und `Terminal.offlineStatus.reader.offlinePaymentsCount`, um zu überprüfen, wie viele Zahlungen an das Lesegerät weitergeleitet werden müssen. Wenn Ihr intelligentes Lesegerät beschädigt wird oder anderweitig keine Zahlungen entgegennehmen kann, können Ihre gespeicherten Zahlungen oft dennoch weitergeleitet werden. Stellen Sie sicher, dass Sie das intelligente Lesegerät mit Ihrem POS verbinden und den Internetzugang wiederherstellen, damit es sich erneut mit Stripe verbinden kann. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `SUCCEEDED` anstelle von `REQUIRES_CAPTURE` . Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineListener::onPaymentIntentForwarded` für jeden PaymentIntent erhält, während das Lesegerät diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `REQUIRES_CAPTURE` ist und `offlineDetails` null ist oder der Wert für `requiresUpload` gleich `false` ist. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val callback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "confirmPaymentIntent succeeded") if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) {val offlineDetails = paymentIntent.offlineDetails if (offlineDetails?.requiresUpload == true) { // Offline payment, wait for `onPaymentIntentForwarded` (see snippet below) } else { // Online payment, can be captured now } } else { // Handle other status results here } } override fun onFailure(e: TerminalException) { // Handle offline-specific errors in your application (for example, // unsupported payment method). Log.e(TAG, "confirmPaymentIntent failed:", e) } } Terminal.getInstance().confirmPaymentIntent(paymentIntent, callback) } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das Lesegerät dieses im `OfflineListener::onPaymentIntentForwarded` weitergeleitet hat: #### Kotlin ```kotlin class CustomOfflineListener : OfflineListener { // ... override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) { if (e != null) { // Handle the error appropriate for your application } else if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) { // The paymentIntent is ready to be captured } else { // Handle other status results here } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # React Native > This is a React Native for when terminal-card-present-integration is terminal and terminal-sdk-platform is react-native and reader-type is internet. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=react-native&reader-type=internet. Das Terminal SDK ermöglicht es Ihrer Anwendung, mit einem intelligenten Lesegerät ohne Internetverbindung weiterhin Zahlungen einzuziehen. Wenn Sie ein separates POS-Gerät mit einem intelligenten Stripe-Lesegerät nutzen, benötigen Sie dennoch ein funktionierendes lokales Netzwerk, damit Ihr POS-Gerät mit dem intelligenten Lesegerät kommunizieren kann. Der Offline-Betrieb mit intelligenten Lesegeräten ist für Szenarien vorgesehen, bei denen Ihr POS und das Lesegerät nicht mit Stripe kommunizieren können, beispielsweise bei einem ISP-Ausfall. Wenn Sie offline ohne ein lokales Netzwerk arbeiten müssen, sollten Sie die [mobilen Lesegeräte](https://docs.stripe.com/terminal/mobile-readers.md) von Stripe Terminal in Betracht ziehen. Mit einer „Apps auf Geräten“-Integration können Sie auch offline arbeiten. Da Ihre POS-Anwendung direkt auf dem intelligenten Lesegerät ausgeführt wird, benötigen Sie kein lokales Netzwerk, um Zahlungen einzuziehen. Sie müssen sich jedoch immer noch in einem lokalen Netzwerk befinden, wenn Ihr Lesegerät zum ersten Mal gestartet wird, auch wenn das Netzwerk keinen Internetzugang hat. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Beim Offline-Betrieb mit einem internetfähigen Lesegerät speichert das Lesegerät erfasste Zahlungsinformationen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=internet#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das Lesegerät speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` im selben lokalen Netzwerk eine Verbindung hergestellt haben. Das Lesegerät speichert die `Location`-Informationen lokal, nachdem es online eine Verbindung hergestellt hat, und leitet Konfigurationsinformationen von diesem `Location` ab, während es offline arbeitet. Ihr Lesegerät und Ihr POS-Gerät müssen sich im selben lokalen Netzwerk befinden, das für die Online-Verbindung verwendet wird. Im Offline-Modus können Sie nicht zwischen Netzwerken wechseln. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | ## Offline-Ereignisse verarbeiten [Client-seitig] - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie die Offline-Callbacks am `useStripeTerminal`-Hook. ```js const { connectReader, disconnectReader, connectedReader } = useStripeTerminal({ onDidChangeOfflineStatus(status: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. // // You can also check the SDK's current offline status calling // `getOfflineStatus`. }, onDidForwardingFailure(error) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. }, onDidForwardPaymentIntent(paymentIntent, error) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `paymentIntent.id` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `paymentIntent.id` may still be null if creating the // PaymentIntent in the backend failed. }, }); ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#createPaymentIntent) - [CreatePaymentIntentParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#CreatePaymentIntentParams) - [OfflineStatus (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#OfflineStatus) - [OfflineStatusDetails (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#OfflineStatusDetails) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `id` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Sie können einen [Webhook](https://docs.stripe.com/webhooks.md)-Endpoint einrichten, um `PaymentIntent`-Ereignisse zu empfangen, wenn Offline-Zahlungen an Stripe weitergeleitet werden, und diese mithilfe Ihrer Kennung mit einer `PaymentIntent`-ID zu verknüpfen. ```js const _createPaymentIntent = async (cart) => { const {error, paymentIntent} = await createPaymentIntent({ amount: cart.total, currency: cart.currency,metadata: { "unique-id": UUID().uuidString } }); } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das Lesegerät eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `OfflineStatus.reader.offlinePaymentsCount` 1. `OfflineStatus.reader.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können `offlineBehavior` auf `force_offline` setzen, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das Lesegerät von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. ```js const _createPaymentIntent = async (cart) => { // Your app might want to prevent offline payments for too large an amount. // Here, we require a network connection if the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.let offlineBehavior: if (cart.total > 1000000) { offlineBehavior = 'require_online' } else { offlineBehavior = 'prefer_online' } const {error, paymentIntent} = await createPaymentIntent({ amount: cart.total, currency: cart.currency,offlineBehavior, }); } ``` ## Zahlungsmethode erfassen [Client-seitig] - [CollectPaymentMethodParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#CollectPaymentMethodParams) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Ihr intelligentes Lesegerät zeigt den Kundinnen und Kunden automatisch die verfügbaren Zahlungsoptionen an. > [Die Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=react-native#collect-inspect-payment-method) wird offline nicht unterstützt. Obwohl Sie den Parameter `updatePaymentIntent` weiterhin in `CollectConfiguration` festlegen können, ist das Feld `paymentMethod`für den PaymentIntent nicht vorhanden, wenn das SDK offline arbeitet. ```js const _collectPaymentMethod_ = async () => { const { paymentIntent, error } = await collectPaymentMethod({ paymentIntent: paymentIntent }); if (error) { // Handle errors in your application. } // ... Confirm the payment } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. In diesem Fall hat der `PaymentIntent` möglicherweise eine `id`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. ```js const _confirmPaymentIntent = async () => { const { paymentIntent, error } = await confirmPaymentIntent({ paymentIntent: paymentIntent }); if (error) { // Handle offline-specific errors in your application (for example, // unsupported payment method). } if (paymentIntent.offlineDetails) { console.log('confirmed offline'); } else { console.log('confirmed online'); } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#OfflineCardPresentDetails) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#ReceiptDetails) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Netzwerkverbindung wiederhergestellt wird, beginnt das Lesegerät automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das Lesegerät versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr intelligentes Lesegerät zu früh trennen oder ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `OfflineStatus.reader.networkStatus` abfragen, um sicherzustellen, dass Ihr Lesegerät online ist und Zahlungen weiterleiten kann, und `OfflineStatus.reader.offlinePaymentsCount` , um zu überprüfen, wie viele Zahlungen an das Lesegerät weitergeleitet werden müssen. Wenn Ihr intelligentes Lesegerät beschädigt wird oder anderweitig keine Zahlungen entgegennehmen kann, können Ihre gespeicherten Zahlungen oft dennoch weitergeleitet werden. Stellen Sie sicher, dass Sie das intelligente Lesegerät mit Ihrem POS verbinden und den Internetzugang wiederherstellen, damit es sich erneut mit Stripe verbinden kann. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `succeeded` anstelle von `requiresCapture` . Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `useStripeTerminal` hook’s `onDidForwardPaymentIntent` für jeden PaymentIntent erhält, während das Lesegerät diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `requiresCapture` ist und `OfflineDetails` null ist oder der Wert für `requiresUpload` gleich `false` ist. ```js const _confirmPaymentIntent = async () => { const { paymentIntent, error } = await confirmPaymentIntent({ paymentIntent: paymentIntent }); if (error) { // Handle offline-specific errors in your application (for example, // unsupported payment method). } if (paymentIntent.status == 'requiresCapture') {const offlineDetails = paymentIntent.offlineDetails; if (offlineDetails.requiresUpload === true) { // Offline payment, wait for `onDidForwardPaymentIntent` (see snippet below) } else { // Online payment, can be captured now } } else { // handle other paymentIntent.status results here } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das Lesegerät dieses im `onDidForwardPaymentIntent` weitergeleitet hat: ```js const { connectReader, disconnectReader, connectedReader } = useStripeTerminal({ onDidForwardPaymentIntent(paymentIntent, error) { if (error) { // Handle the error appropriate for your application } else if (paymentIntent.status == 'requires_capture') { // The paymentIntent is ready to be captured } else { // Handle the paymentIntent.status as appropriate. } }, }); ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # Java > This is a Java for when terminal-card-present-integration is terminal and terminal-sdk-platform is java and reader-type is internet. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=java&reader-type=internet. Das Terminal SDK ermöglicht es Ihrer Anwendung, mit einem intelligenten Lesegerät ohne Internetverbindung weiterhin Zahlungen einzuziehen. Wenn Sie ein separates POS-Gerät mit einem intelligenten Stripe-Lesegerät nutzen, benötigen Sie dennoch ein funktionierendes lokales Netzwerk, damit Ihr POS-Gerät mit dem intelligenten Lesegerät kommunizieren kann. Der Offline-Betrieb mit intelligenten Lesegeräten ist für Szenarien vorgesehen, bei denen Ihr POS und das Lesegerät nicht mit Stripe kommunizieren können, beispielsweise bei einem ISP-Ausfall. Wenn Sie offline ohne ein lokales Netzwerk arbeiten müssen, sollten Sie die [mobilen Lesegeräte](https://docs.stripe.com/terminal/mobile-readers.md) von Stripe Terminal in Betracht ziehen. Mit einer „Apps auf Geräten“-Integration können Sie auch offline arbeiten. Da Ihre POS-Anwendung direkt auf dem intelligenten Lesegerät ausgeführt wird, benötigen Sie kein lokales Netzwerk, um Zahlungen einzuziehen. Sie müssen sich jedoch immer noch in einem lokalen Netzwerk befinden, wenn Ihr Lesegerät zum ersten Mal gestartet wird, auch wenn das Netzwerk keinen Internetzugang hat. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Beim Offline-Betrieb mit einem internetfähigen Lesegerät speichert das Lesegerät erfasste Zahlungsinformationen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=internet#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das Lesegerät speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` im selben lokalen Netzwerk eine Verbindung hergestellt haben. Das Lesegerät speichert die `Location`-Informationen lokal, nachdem es online eine Verbindung hergestellt hat, und leitet Konfigurationsinformationen von diesem `Location` ab, während es offline arbeitet. Ihr Lesegerät und Ihr POS-Gerät müssen sich im selben lokalen Netzwerk befinden, das für die Online-Verbindung verwendet wird. Im Offline-Modus können Sie nicht zwischen Netzwerken wechseln. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | ## Offline-Ereignisse verarbeiten [Client-seitig] - [OfflineListener (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.callable/-offline-listener/index.html) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie die `OfflineListener`-Schnittstelle und übergeben Sie sie an das Terminal SDK. Sie müssen `OfflineListener` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. ```java public class CustomOfflineListener implements OfflineListener { @Override public void onOfflineStatusChange(@NotNull OfflineStatus offlineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal::offlineStatus`. } @Override public void onPaymentIntentForwarded(@NotNull PaymentIntent paymentIntent, @Nullable TerminalException e) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent::getId` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent::getId` may still be null if creating the // PaymentIntent in the backend failed. } @Override public void onForwardingFailure(@NotNull TerminalException e) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` ```java Terminal.init( new CustomConnectionTokenProvider(), new CustomTerminalListener(), getApplicationInfo(), LogLevel.VERBOSE, new CustomOfflineListener() ); ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (Java)](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/create-payment-intent.html) - [CreateConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-create-configuration/index.html) - [OfflineDetails (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-offline-details/index.html) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `id` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Sie können einen [Webhook](https://docs.stripe.com/webhooks.md)-Endpoint einrichten, um `PaymentIntent`-Ereignisse zu empfangen, wenn Offline-Zahlungen an Stripe weitergeleitet werden, und diese mithilfe Ihrer Kennung mit einer `PaymentIntent`-ID zu verknüpfen. ```java HashMap metadata = new HashMap<> (); metadata.put("unique-id", UUID.randomUUID().toString()); final PaymentIntentParameters params = new PaymentIntentParameters.Builder() .setAmount(cart.getTotal()) .setCurrency(cart.getCurrency()).setMetadata(metadata) .build(); final PaymentIntentCallback createPaymentCallback = new PaymentIntentCallback() { @Override public void onSuccess(@NotNull PaymentIntent paymentIntent) { System.out.println("createPaymentIntent succeeded");// If the `PaymentIntent` was created offline, its `id` field will be null. if (paymentIntent.getId() != null) { System.out.println("created online"); } else { System.out.println("created offline"); } // ... Collect a PaymentMethod } @Override public void onFailure(@NotNull TerminalException e) { // Handle errors in your application. } }; Terminal.getInstance().createPaymentIntent(params, null, createPaymentCallback); ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das Lesegerät eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.offlineStatus.reader.offlinePaymentsCount` 1. `Terminal.offlineStatus.reader.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `offlineBehavior`auf `FORCE_OFFLINE` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das Lesegerät von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. ```java // Your app might want to prevent offline payments for too large an amount. // Here, we block the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable. OfflineBehavior offlineBehavior = cart.getTotal() > 1000000 ? offlineBehavior = OfflineBehavior.REQUIRE_ONLINE : OfflineBehavior.PREFER_ONLINE; final CreateConfiguration createConfig = new CreateConfiguration(offlineBehavior); Terminal.getInstance().createPaymentIntent(params, createConfig, createPaymentCallback); ``` ## Zahlungsmethode erfassen [Client-seitig] - [CollectPaymentIntentConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/index.html) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Ihr intelligentes Lesegerät zeigt den Kundinnen und Kunden automatisch die verfügbaren Zahlungsoptionen an. > Die [Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=java#collect-inspect-payment-method) wird nicht unterstützt, während sie offline sind. Sie können die Methode `updatePaymentIntent` zwar weiterhin in `CollectPaymentIntentConfiguration` verwenden, aber das Feld `paymentMethod` im PaymentIntent fehlt, wenn das SDK offline betrieben wird. ```java final PaymentIntentCallback collectPaymentCallback = new PaymentIntentCallback() { @Override public void onSuccess(@NotNull PaymentIntent paymentIntent) { System.out.println("collectPaymentMethod succeeded"); // ... Confirm the payment } @Override public void onFailure(@NotNull TerminalException e) { e.printStackTrace(); } }; final CollectPaymentIntentConfiguration collectConfig = new CollectPaymentIntentConfiguration.Builder().build(); Terminal.getInstance().collectPaymentMethod(paymentIntent, collectConfig, collectPaymentCallback); ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. In diesem Fall hat der `PaymentIntent` möglicherweise eine `id`, die nicht Null ist. Wenn er offline bestätigt wurde, werden `offlineDetails` definiert und ausgefüllt. ```java final PaymentIntentCallback confirmPaymentIntentCallback = new PaymentIntentCallback() { @Override public void onSuccess(@NotNull PaymentIntent paymentIntent) { System.out.println("confirmPaymentIntent succeeded"); // If the `PaymentIntent` was confirmed offline, `paymentIntent.getOfflineDetails()` will be definedif (paymentIntent.getOfflineDetails() != null) { System.out.println("confirmed offline"); } else { System.out.println("confirmed online"); } } @Override public void onFailure(@NotNull TerminalException e) { // Handle offline-specific errors in your application (for example, // unsupported payment method). e.printStackTrace(); } }; Terminal.getInstance().confirmPaymentIntent(paymentIntent, confirmPaymentIntentCallback); ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-offline-card-present-details/index.html) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-receipt-details/index.html) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Netzwerkverbindung wiederhergestellt wird, beginnt das Lesegerät automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das Lesegerät versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr intelligentes Lesegerät zu früh trennen oder ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.offlineStatus.reader.networkStatus` abfragen, um sicherzustellen, dass Ihr Lesegerät online ist und Zahlungen weiterleiten kann, und `Terminal.offlineStatus.reader.offlinePaymentsCount`, um zu überprüfen, wie viele Zahlungen an das Lesegerät weitergeleitet werden müssen. Wenn Ihr intelligentes Lesegerät beschädigt wird oder anderweitig keine Zahlungen entgegennehmen kann, können Ihre gespeicherten Zahlungen oft dennoch weitergeleitet werden. Stellen Sie sicher, dass Sie das intelligente Lesegerät mit Ihrem POS verbinden und den Internetzugang wiederherstellen, damit es sich erneut mit Stripe verbinden kann. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `SUCCEEDED` anstelle von `REQUIRES_CAPTURE` . Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineListener.OnPaymentIntentForwarded` für jeden PaymentIntent erhält, während das Lesegerät diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `REQUIRES_CAPTURE` ist und `offlineDetails` null ist oder der Wert für `requiresUpload` gleich `false` ist. ```java final PaymentIntentCallback confirmPaymentIntentCallback = new PaymentIntentCallback() { @Override public void onSuccess(@NotNull PaymentIntent paymentIntent) { System.out.println("confirmPaymentIntent succeeded"); if (paymentIntent.getStatus() == PaymentIntentStatus.REQUIRES_CAPTURE) {OfflineDetails offlineDetails = paymentIntent.getOfflineDetails(); if (offlineDetails != null && offlineDetails.getRequiresUpload()) { // Offline payment, wait for `onPaymentIntentForwarded` (see snippet below) } else { // Online payment, can be captured now } } else { // Handle other status results here } } @Override public void onFailure(@NotNull TerminalException e) { // Handle offline-specific errors in your application (for example, // unsupported payment method). } }; Terminal.getInstance().confirmPaymentIntent(paymentIntent, confirmPaymentIntentCallback); ``` Erfassen Sie eine Offline-Zahlung, nachdem das Lesegerät dieses im `OfflineListener::onPaymentIntentForwarded` weitergeleitet hat: ```java public class CustomOfflineListener implements OfflineListener { // ... @Override public void onPaymentIntentForwarded(@NotNull PaymentIntent paymentIntent, @Nullable TerminalException e) { if (e != null) { // Handle the error appropriate for your application } else if (paymentIntent.getStatus() == PaymentIntentStatus.REQUIRES_CAPTURE) { // The paymentIntent is ready to be captured } else { // Handle other status results here } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # .NET > This is a .NET for when terminal-card-present-integration is terminal and terminal-sdk-platform is dotnet and reader-type is internet. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=dotnet&reader-type=internet. Das Terminal SDK ermöglicht es Ihrer Anwendung, mit einem intelligenten Lesegerät ohne Internetverbindung weiterhin Zahlungen einzuziehen. Wenn Sie ein separates POS-Gerät mit einem intelligenten Stripe-Lesegerät nutzen, benötigen Sie dennoch ein funktionierendes lokales Netzwerk, damit Ihr POS-Gerät mit dem intelligenten Lesegerät kommunizieren kann. Der Offline-Betrieb mit intelligenten Lesegeräten ist für Szenarien vorgesehen, bei denen Ihr POS und das Lesegerät nicht mit Stripe kommunizieren können, beispielsweise bei einem ISP-Ausfall. Wenn Sie offline ohne ein lokales Netzwerk arbeiten müssen, sollten Sie die [mobilen Lesegeräte](https://docs.stripe.com/terminal/mobile-readers.md) von Stripe Terminal in Betracht ziehen. Mit einer „Apps auf Geräten“-Integration können Sie auch offline arbeiten. Da Ihre POS-Anwendung direkt auf dem intelligenten Lesegerät ausgeführt wird, benötigen Sie kein lokales Netzwerk, um Zahlungen einzuziehen. Sie müssen sich jedoch immer noch in einem lokalen Netzwerk befinden, wenn Ihr Lesegerät zum ersten Mal gestartet wird, auch wenn das Netzwerk keinen Internetzugang hat. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Beim Offline-Betrieb mit einem internetfähigen Lesegerät speichert das Lesegerät erfasste Zahlungsinformationen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Verwenden Sie ein [Konfigurations](https://docs.stripe.com/api/terminal/configuration.md)-Objekt oder das [Dashboard](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=dashboard#update-the-default-configuration-for-the-account), um den Offline-Modus für die [unterstützten](https://docs.stripe.com/terminal/features/operate-offline/overview.md?reader-type=internet#availability) Geräte an Ihrem `Location` zu aktivieren. ```curl curl https://api.stripe.com/v1/terminal/configurations \ -u "<>:" \ -d "offline[enabled]=true" ``` Nachdem Sie den Offline-Modus für ein `Configuration`-Objekt aktiviert haben, können Sie es einem `Location` [zuweisen](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#create-a-configuration-for-an-individual-location). Sie können den Offline-Modus auch standardmäßig für alle `Locations` aktivieren, indem Sie das [standardmäßige](https://docs.stripe.com/terminal/fleet/configurations-overview.md?dashboard-or-api=api#retrieve-the-account-default-configuration) `Configuration`-Objekt für Ihr Konto aktualisieren. Es kann mehrere Minuten dauern, bis Änderungen der Configuration API auf Ihr SDK und Lesegerät übertragen werden, und es kann erforderlich sein, dass Sie die Verbindung mit Ihrem Lesegerät trennen und wiederherstellen müssen, damit die Änderungen wirksam werden. ## Offline mit einem Lesegerät verbinden Das Lesegerät speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` im selben lokalen Netzwerk eine Verbindung hergestellt haben. Das Lesegerät speichert die `Location`-Informationen lokal, nachdem es online eine Verbindung hergestellt hat, und leitet Konfigurationsinformationen von diesem `Location` ab, während es offline arbeitet. Ihr Lesegerät und Ihr POS-Gerät müssen sich im selben lokalen Netzwerk befinden, das für die Online-Verbindung verwendet wird. Im Offline-Modus können Sie nicht zwischen Netzwerken wechseln. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass der von Ihnen verwendete `Location` für den Offline-Modus [konfiguriert](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) ist. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Die Software des Lesegeräts wurde seit mindestens 30 Tagen nicht mehr aktualisiert. Stellen Sie eine Verbindung zum Lesegerät her, wenn Sie online sind, um es zu aktualisieren. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | ## Offline-Ereignisse verarbeiten [Client-seitig] Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie die `IOfflineListener`-Schnittstelle und übergeben Sie sie an das Terminal SDK. Sie müssen `IOfflineListener` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. ```csharp using TerminalSdk.Api; namespace StripeExampleApi; public class CustomOfflineListener : IOfflineListener { public void OnOfflineStatusChange(OfflineStatus offlineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the reader's network status at `offlineStatus.Reader.NetworkStatus`. // // You can also check the reader's current offline status using // `Terminal.OfflineStatus`. } public void OnPaymentIntentForwarded(PaymentIntent paymentIntent, TerminalException? e) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `paymentIntent.Id` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent.Id` may still be null if creating the // PaymentIntent in the backend failed. } public void OnForwardingFailure(TerminalException e) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` ```csharp Terminal.InitTerminal( new CustomConnectionTokenProvider(), new CustomTerminalListener(), new CustomOfflineListener(), new ApplicationInformation.Builder() .SetName("Terminal Test Console") .SetVersion("0.0.0.1") .SetDataDirectory(new DirectoryInfo("C:\\TerminalSDK")) .Build() ); ``` ## PaymentIntent offline erstellen [Client-seitig] Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `CreatePaymentIntentAsync` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `Id` Null. Wir empfehlen, den Metadaten](/payments/payment-intents#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Sie können einen [Webhook](https://docs.stripe.com/webhooks.md)-Endpoint einrichten, um `PaymentIntent`-Ereignisse zu empfangen, wenn Offline-Zahlungen an Stripe weitergeleitet werden, und diese mithilfe Ihrer Kennung mit einer `PaymentIntent`-ID zu verknüpfen. ```csharp // Build up parameters for creating a `PaymentIntent` var paymentIntentParameters = new PaymentIntentParameters.Builder() .SetAmount(cart.Total) .SetCurrency(cart.Currency).SetMetadata(new Dictionary() { { "unique-id", Guid.NewGuid().ToString() } }) .Build(); try { var paymentIntent = await Terminal.Instance.CreatePaymentIntentAsync(paymentIntentParameters, null); _logger.LogDebug("CreatePaymentIntentAsync succeeded");// If the `PaymentIntent` was created offline, its `Id` field will be null. if (paymentIntent.Id != null) { _logger.LogDebug("created online"); } else { _logger.LogDebug("created offline"); } // ... Collect a PaymentMethod } catch (TerminalException ex) { _logger.LogError(ex, "CreatePaymentIntentAsync failed"); // Handle errors in your application. } ``` Der Parameter `Terminal.CreatePaymentIntentAsync` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `OfflineBehavior` als `RequireOnline`, `PreferOnline` oder `ForceOffline` festgelegt ist. #### Risikomanagement Das Festlegen von `OfflineBehavior` auf `RequireOnline` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das Lesegerät eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.OfflineStatus.Reader.OfflinePaymentsCount` 1. `Terminal.OfflineStatus.Reader.OfflinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `OfflineBehavior`auf `ForceOffline` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das Lesegerät von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. ```csharp // Your app might want to prevent offline payments for too large an amount. // Here, we require a network connection if the payment amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.var offlineBehavior = OfflineBehavior.PreferOnline; if (cart.total > 1000000) { offlineBehavior = OfflineBehavior.RequireOnline; } var createConfig = new CreateConfiguration.Builder() .SetOfflineBehavior(offlineBehavior) .Build(); var paymentIntent = await Terminal.Instance.CreatePaymentIntentAsync(paymentIntentParameters, createConfig); _logger.LogDebug("CreatePaymentIntentAsync succeeded"); // ...continue transaction ``` ## Zahlungsmethode erfassen [Client-seitig] > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Ihr intelligentes Lesegerät zeigt den Kundinnen und Kunden automatisch die verfügbaren Zahlungsoptionen an. > [Die Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=dotnet#collect-inspect-payment-method) wird im Offline-Modus nicht unterstützt. Obwohl Sie weiterhin die Methode `SetUpdatePaymentIntent` in `CollectConfiguration` verwenden können, fehlt das Feld `paymentMethod` für den PaymentIntent, wenn das SDK offline arbeitet. ```csharp try { var collectConfig = new CollectConfiguration.Builder() .Build(); var collectedPaymentIntent = await Terminal.Instance.CollectPaymentMethodAsync(paymentIntent, collectConfig); _logger.LogDebug("CollectPaymentMethodAsync succeeded"); // ... Confirm the payment } catch (TerminalException ex) { // Handle errors in your application. } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. In diesem Fall hat der `PaymentIntent` möglicherweise eine `Id`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `OfflineDetails` definiert und ausgefüllt. ```csharp try { var confirmedPaymentIntent = await Terminal.Instance.ConfirmPaymentIntentAsync(collectedPaymentIntent); } catch (TerminalException ex) { // Handle offline-specific errors in your application (for example, // unsupported payment method). } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre OfflineCardPresentDetails from the `paymentIntent.OfflineDetails.OfflineCardPresentDetails` -Eigenschaft ab. Dieser Hash enthält eine ReceiptDetails -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Netzwerkverbindung wiederhergestellt wird, beginnt das Lesegerät automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das Lesegerät versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr intelligentes Lesegerät zu früh trennen oder ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.OfflineStatus.Reader.NetworkStatus` abfragen, um sicherzustellen, dass Ihr Lesegerät online ist und Zahlungen weiterleiten kann, und `Terminal.OfflineStatus.Reader.OfflinePaymentsCount` , um zu überprüfen, wie viele Zahlungen an das Lesegerät weitergeleitet werden müssen. Wenn Ihr intelligentes Lesegerät beschädigt wird oder anderweitig keine Zahlungen entgegennehmen kann, können Ihre gespeicherten Zahlungen oft dennoch weitergeleitet werden. Stellen Sie sicher, dass Sie das intelligente Lesegerät mit Ihrem POS verbinden und den Internetzugang wiederherstellen, damit es sich erneut mit Stripe verbinden kann. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `CaptureMethod` auf `Automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `Succeeded` anstelle von `RequiresCapture`. Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineListener.OnPaymentIntentForwarded` für jeden PaymentIntent erhält, während das Lesegerät diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `RequiresCapture` ist und `OfflineDetails` null ist oder der Wert für `RequiresUpload` gleich `false` ist. ```csharp try { var confirmedPaymentIntent = await Terminal.Instance.ConfirmPaymentIntentAsync(collectedPaymentIntent); _logger.LogDebug("ConfirmPaymentIntentAsync succeeded"); if (paymentIntent.status == PaymentIntentStatus.RequiresCapture) {var offlineDetails = paymentIntent.OfflineDetails; if (offlineDetails?.RequiresUpload == true) { // Offline payment, wait for `OnPaymentIntentForwarded` (see snippet below) } else { // Online payment, can be captured now } } else { // handle other paymentIntent.Status results here } } catch (TerminalException ex) { // Handle offline-specific errors in your application (for example, // unsupported payment method). _logger.LogError(ex, "ConfirmPaymentIntentAsync failed"); } ``` Erfassen Sie eine Offline-Zahlung, nachdem das Lesegerät dieses im `IOfflineListener.OnPaymentIntentForwarded` weitergeleitet hat: ```csharp using TerminalSdk.Api; namespace StripeExampleApi; public class CustomOfflineListener : IOfflineListener { public void OnPaymentIntentForwarded(PaymentIntent paymentIntent, TerminalException? e) { if (e != null) { // Handle the error appropriate for your application } else if (paymentIntent.Status == PaymentIntentStatus.RequiresCapture) { // The paymentIntent is ready to be captured } else { // Handle the paymentIntent.Status as appropriate. } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # iOS > This is a iOS for when terminal-card-present-integration is terminal and terminal-sdk-platform is ios and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=ios&reader-type=simulated. Mit dem Terminal SDK kann Ihre Anwendung weiterhin Zahlungen über ein simuliertes Lesegerät ohne Netzwerkverbindung einziehen. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Um den Offline-Modus zu verwenden, muss Ihre Anwendung Version `3.3.0` oder höher des Terminal iOS SDK nutzen. Konfigurieren Sie das simulierte Lesegerät, um den Offline-Modus zu aktivieren. #### Swift ``` let simulatorConfiguration = Terminal.shared.simulatorConfiguration simulatorConfiguration.offlineEnabled = true ``` ## Offline mit einem Lesegerät verbinden Das SDK speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` und die Software Ihres Lesegeräts innerhalb dieser Zeit aktualisiert haben. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass Sie den Offline-Modus in der `SimulatorConfiguration` für Ihr simuliertes Lesegerät aktiviert haben. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Sie haben den Wert `SimulateReaderUpdate` in der `SimulatorConfiguration` des SDK auf `SimulateReaderUpdateRequiredForOffline` festgelegt. Verwenden Sie einen anderen Wert, um eine Offline-Verbindung zuzulassen. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | ## Offline-Ereignisse verarbeiten [Client-seitig] - [OfflineDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPOfflineDelegate.html) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie das `OfflineDelegate`-Protokoll und übergeben Sie es an das Terminal SDK. Sie müssen `OfflineDelegate` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. #### Swift ```swift import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { func terminal(_ terminal: Terminal, didChangeOfflineStatus offlineStatus: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal.shared.offlineStatus.sdk.networkStatus`. } func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent.stripeId` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent.stripeId` may still be nil if creating the // PaymentIntent in the backend failed. } func terminal(_ terminal: Terminal, didReportForwardingError error: Error) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` #### Swift ```swift import UIKit import StripeTerminal @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { Terminal.initWithTokenProvider(APIClient.shared) Terminal.shared.offlineDelegate = CustomOfflineDelegate() // ... return true } // ... } ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)createPaymentIntent:completion:) - [CreateConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCreateConfiguration.html) - [OfflineDetails (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPOfflineDetails.html) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `stripeId` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Nachdem der `PaymentIntent` in [Schritt 7](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) erfolgreich an Stripe weitergeleitet wurde, verwenden Sie Ihre individuelle Kennung, um sie im Aufruf `OfflineDelegate.didForwardPaymentIntent` abzugleichen. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // Populate the correct transaction amount from your application. let amount = UInt(10_00) // Build up parameters for creating a `PaymentIntent` let params = try PaymentIntentParametersBuilder( amount: amount, currency: "usd" ).setMetadata(["offlineId": UUID().uuidString]) .build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { // Handle errors in your application. print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded")// If the `PaymentIntent` was created offline, its `stripeId` field will be nil. if let onlineCreatedId = paymentIntent.stripeId { print("created online"); } else { print("created offline") } } } } } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.offlineStatus.sdk.offlinePaymentsCount` 1. `Terminal.offlineStatus.sdk.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `offlineBehavior`auf `FORCE_OFFLINE` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das SDK von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() throws { // ...build up parameters and callback for creating a `PaymentIntent` // Your app might want to prevent offline payments for too large an amount. // Here, we block the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.let offlineBehavior: SCPOfflineBehavior = { if amount > UInt(1_000_00) { return .requireOnline } else { return .preferOnline } }() let createConfiguration = try CreateConfigurationBuilder().setOfflineBehavior(offlineBehavior).build() Terminal.shared.createPaymentIntent(params, createConfig: createConfiguration) { createResult, createError in // handle success or failure } } } ``` ## Zahlungsmethode erfassen [Client-seitig] - [CollectPaymentIntentConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCollectPaymentIntentConfiguration.html) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Verwenden Sie die Methode `didRequestReaderInput`, um Kundinnen/Kunden die gültigen Optionen zur Vorlage der Karte anzuzeigen. > Lesegeräte unterstützen die [Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=ios#collect-inspect-payment-method) nicht, während sie offline sind. Sie können zwar weiterhin den Parameter `initWithUpdatePaymentIntent` in `CollectPaymentIntentConfiguration` verwenden, aber das Feld `paymentMethod` im PaymentIntent fehlt, wenn das SDK offline betrieben wird. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.collectPaymentMethod(paymentIntent) { collectResult, collectError in if let error = collectError { print("collectPaymentMethod failed: \(error)") } else if let paymentIntent = collectResult { print("collectPaymentMethod succeeded") // ... Confirm the payment } } } } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. Wenn dies geschieht, hat der `PaymentIntent` möglicherweise eine `stripeId`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. Das simulierte Lesegerät kann so konfiguriert werden, dass es eine simulierte Testkarte verwendet, mit der Sie während der Bestätigung verschiedene Offline-spezifische Abläufe testen können. Sie können beispielsweise Folgendes tun: - Verwenden Sie die simulierte Interac-Testkartennummer, um auf Fehler zu testen, während Sie einen `PaymentIntent` offline für nicht unterstützte Zahlungsmethoden bestätigen - Verwenden Sie eine Testkartennummer, die [zu einer abgelehnten Zahlung führt](https://docs.stripe.com/terminal/references/testing.md#test-cards-for-specific-error-cases), um auf Fehler bei der Weiterleitung eines gespeicherten `PaymentIntent` zu testen Eine vollständige Liste der verfügbaren Optionen finden Sie unter [Stripe Terminal testen](https://docs.stripe.com/terminal/references/testing.md). #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // Action for a "Checkout" button func checkoutAction() { Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent= confirmResult {print("confirmPaymentIntent succeeded") if let offlineDetails = paymentIntent.offlineDetails { print("confirmed offline"); } else { print("confirmed online") } } } } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPOfflineCardPresentDetails.html) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPReceiptDetails.html) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Internet access wiederhergestellt wird, beginnt das SDK automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das SDK versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr POS-Gerät zu früh ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.offlineStatus.sdk.networkStatus` abfragen, um sicherzustellen, dass Ihr POS online ist und Zahlungen weiterleiten kann und `Terminal.offlineStatus.sdk.offlinePaymentsCount` , um zu überprüfen, wie viele Zahlungen an das Terminal-SDK weitergeleitet werden müssen. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `Succeeded` anstelle von `RequiresCapture`. Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineDelegate.didForwardPayment` für jeden PaymentIntent erhält, während das SDK diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `RequiresCapture` ist und `offlineDetails` null ist oder der Wert für `requiresUpload` gleich `NO` ist. #### Swift ```swift Terminal.shared.confirmPaymentIntent(paymentIntent) { confirmResult, confirmError in if let error = confirmError { // Handle offline-specific errors in your application (for example, // unsupported payment method). print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent = confirmResult { if intent.status == .requiresCapture {if let offlineDetails = confirmedPaymentIntent.offlineDetails(), offlineDetails.requiresUpload { // Offline payment, wait for `didForwardPaymentIntent` (see snippet below) } else { // Online payment, can be captured now } } // else, handle other intent.status results here } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das SDK dieses im `didForwardPaymentIntent` Ihres OfflineDelegate weitergeleitet hat: #### Swift ```swift import StripeTerminal class CustomOfflineDelegate: OfflineDelegate { // ... func terminal(_ terminal: Terminal, didForwardPaymentIntent intent: PaymentIntent, error: Error?) { if let error = error { // Handle the error appropriate for your application return } if intent.status == .requiresCapture { // The intent is ready to be captured. } else { // Handle the intent.status as appropriate. } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde. # Android > This is a Android for when terminal-card-present-integration is terminal and terminal-sdk-platform is android and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments?terminal-card-present-integration=terminal&terminal-sdk-platform=android&reader-type=simulated. Mit dem Terminal SDK kann Ihre Anwendung weiterhin Zahlungen über ein simuliertes Lesegerät ohne Netzwerkverbindung einziehen. > Beim Offline-Betrieb werden die Zahlungsinformationen zum Zeitpunkt des Verkaufs erfasst, und erst nachdem die Verbindung wiederhergestellt und die Zahlung weitergeleitet wurde, wird versucht, die Autorisierung durchzuführen. Als Nutzer/in übernehmen Sie alle mit einer Offline-Transaktion verbundenen Ablehnungs- und Manipulationsrisiken. Wenn Ihr manipuliertes Lesegerät keine Zahlungen an Stripe weiterleiten kann oder der Kartenaussteller die Transaktion ablehnt, gibt es keine Möglichkeit, die Gelder zurückzuerhalten. Und Sie erhalten möglicherweise keine Zahlung von den Kundinnen und Kunden für bereits bereitgestellte Waren oder Dienstleistungen. > > Um die Wahrscheinlichkeit zu verringern, dass Zahlungen von Ausstellern abgelehnt werden, sollten Sie: > > - Stellen Sie die Internetverbindung so schnell wie möglich wieder her, um die Zahlungen an Stripe zu erfassen. - Beschränken Sie Transaktionen, wenn sie einen bestimmten Betrag überschreiten. - [Lassen Sie alle Offline-Zahlungen fehlschlagen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#managing-risk), wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag übersteigt. ## Zahlungen offline einziehen Offline-Zahlungen umfassen dieselben Schritte wie Online-Zahlungen: Zahlung erstellen, einziehen, verarbeiten und erfassen. Ihr Gerät kann in jedem Schritt des Prozesses von online zu offline wechseln. 1. [Offline-Modus aktivieren](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#enable-offline-mode) 1. [Offline mit einem Lesegerät verbinden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#connect-while-offline) 1. [Offline-Events verarbeiten](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#handle-offline-events) 1. [Payment Intent offline erstellen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#create-payment-intent) 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#collect-payment-method) 1. [Zahlung bestätigen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#confirm-payment) 1. [Warten, bis Zahlungen weitergeleitet werden](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#capture-payment) 1. (Optional) [Offline-Zahlungen prüfen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#examine-offline) ## Offline-Modus aktivieren Um den Offline-Modus zu verwenden, muss Ihre Anwendung Version `3.2.0` oder höher des Terminal Android SDK nutzen. Konfigurieren Sie das simulierte Lesegerät, um den Offline-Modus zu aktivieren. #### Kotlin ``` val simulatorConfig = SimulatorConfiguration( offlineEnabled = true ); Terminal.getInstance().setSimulatorConfiguration(simulatorConfig); ``` ## Offline mit einem Lesegerät verbinden Das SDK speichert die erforderlichen Informationen zum `Location` nach der Online-Verbindung lokal. Bei nachfolgenden Offline-Verbindungen werden die gespeicherten Konfigurationsinformationen von diesem `Location` verwendet. Um Zahlungen mit einem intelligenten Lesegerät einzuziehen, während Sie offline sind, müssen Sie zuvor innerhalb der letzten 30 Tage mit einem mobilen Lesegerät desselben Typs, am selben `Location` und die Software Ihres Lesegeräts innerhalb dieser Zeit aktualisiert haben. Wenn Sie im Offline-Modus versuchen, eine Verbindung zu einem Lesegerät herzustellen, und diese Anforderungen nicht erfüllen, schlägt die Anfrage mit einem Fehler fehl. | Fehler | Auflösung | | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Das SDK ist nicht mit dem Internet verbunden** | Stellen Sie sicher, dass Sie den Offline-Modus in der `SimulatorConfiguration` für Ihr simuliertes Lesegerät aktiviert haben. Andernfalls stellen Sie eine Verbindung zu einem beliebigen Lesegerät her, während Sie online sind, und stellen Sie dann eine Verbindung zu einem Lesegerät desselben Typs her, während Sie offline sind. | | **Das ausgewählte Lesegerät benötigt ein Software-Update, bevor Offline-Zahlungen eingezogen werden können.** | Sie haben den Wert `SimulateReaderUpdate` in der `SimulatorConfiguration` des SDK auf `REQUIRED_FOR_OFFLINE` festgelegt. Verwenden Sie einen anderen Wert, um eine Offline-Verbindung zuzulassen. | | **Das ausgewählte Lesegerät muss an diesem Standort erst online gekoppelt werden, bevor Offline-Zahlungen eingezogen werden können.** | Sie versuchen, eine Verbindung mit einem Lesegerätetyp herzustellen, mit dem Ihr POS zuvor noch nicht im Online-Modus verbunden wurde. Sie müssen sich zuerst mit diesem Lesegerät oder einem Lesegerät desselben Typs verbinden, während Sie online sind. Wenn Sie sich offline verbinden möchten, können Sie sich mit einem Lesegerätetyp verbinden, mit dem Ihr POS online zuvor bereits eine Verbindung aufgebaut hat. | ## Offline-Ereignisse verarbeiten [Client-seitig] - [OfflineListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-offline-listener/index.html) Damit Ihre Anwendung Updates zum Netzwerkstatus des SDK und zum Status der weitergeleiteten Zahlungen erhalten kann, implementieren Sie die `OfflineListener`-Schnittstelle und übergeben Sie sie an das Terminal SDK. Sie müssen `OfflineListener` festlegen, bevor Sie Zahlungen im Offline-Modus einziehen können. #### Kotlin ```kotlin class CustomOfflineListener : OfflineListener { override fun onOfflineStatusChange(offlineStatus: OfflineStatus) { // Check the value of `offlineStatus` and update your UI accordingly. For instance, // you can check the SDK's network status at `offlineStatus.sdk.networkStatus`. // // You can also check the SDK's current offline status using // `Terminal::offlineStatus`. } override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) { // The PaymentIntent was successfully forwarded, or an error occurred. // Reconcile any local state using the backend-generated `PaymentIntent::id` // and the metadata you supplied when creating the PaymentIntent. // // Note that the `PaymentIntent::id` may still be null if creating the // PaymentIntent in the backend failed. } override fun onForwardingFailure(e: TerminalException) { // A non-specific error occurred while forwarding a PaymentIntent. // Check the error message and your integration implementation to // troubleshoot. } } ``` #### Kotlin ```kotlin Terminal.init( context = applicationContext, logLevel = LogLevel.VERBOSE, tokenProvider = CustomConnectionTokenProvider(), listener = CustomTerminalListener(), offlineListener = CustomOfflineListener(), ) ``` ## PaymentIntent offline erstellen [Client-seitig] - [createPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/create-payment-intent.html) - [CreateConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-create-configuration/index.html) - [OfflineDetails (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-offline-details/index.html) Um den Offline-Betrieb zu unterstützen, verwenden Sie den Parameter `createPaymentIntent` des SDK, um PaymentIntent-Objekte zu erstellen. So kann das SDK im Offline-Modus PaymentIntents erstellen und an Stripe weiterleiten, sobald die Verbindung wiederhergestellt ist. Während des Offline-Betriebs haben `PaymentIntent`-Objekte die `id` Null. Wir empfehlen, den [Metadaten](https://docs.stripe.com/payments/payment-intents.md#storing-information-in-metadata) des PaymentIntent eine nutzerdefinierte Kennung hinzuzufügen, um `PaymentIntent`-Objekte abzugleichen, die offline in Ihrer Datenbank erstellt wurden. Nachdem der `PaymentIntent` in [Schritt 7](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md#wait-for-forward) erfolgreich an Stripe weitergeleitet wurde, verwenden Sie Ihre individuelle Kennung, um sie im Aufruf `OfflineListener::onPaymentIntentForwarded` abzugleichen. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { // Build up parameters for creating a `PaymentIntent` val params = PaymentIntentParameters.Builder() .setAmount(cart.total) .setCurrency(cart.currency).setMetadata(mapOf("unique-id" to UUID.randomUUID().toString())) .build() val createPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "createPaymentIntent succeeded")// If the `PaymentIntent` was created offline, its `id` field will be null. if (paymentIntent.id != null) { Log.d(TAG, "created online") } else { Log.d(TAG, "created offline") } // ... Collect a PaymentMethod } override fun onFailure(e: TerminalException) { Log.e(TAG, "createPaymentIntent failed", e) // Handle errors in your application. } } Terminal.getInstance().createPaymentIntent(params, createPaymentCallback) } } ``` Der Parameter `Terminal.createPaymentIntent` akzeptiert den Parameter `CreateConfiguration`. Wenn Sie offline arbeiten, speichert das Terminal SDK standardmäßig alle Offline-Zahlungen und leitet sie dann an das Backend von Stripe weiter, sobald die Verbindung wiederhergestellt ist. Um dieses Verhalten anzupassen, können Sie ein `CreateConfiguration`-Objekt übergeben, wobei das Attribut `offlineBehavior` als `REQUIRE_ONLINE`, `PREFER_ONLINE` oder `FORCE_OFFLINE` festgelegt ist. #### Risikomanagement Das Festlegen von `offlineBehavior` auf `REQUIRE_ONLINE` führt dazu, dass die aktuelle Transaktion fehlschlägt, wenn Sie offline arbeiten. Möglicherweise möchten Sie z. B. Transaktionen über einem bestimmten Betrag oder sämtliche Offline-Transaktionen untersagen, wenn das SDK eine Reihe von Transaktionen gespeichert hat, deren Summe einen bestimmten Betrag überschreitet. Das SDK bietet zwei Eigenschaften, die Ihnen bei der Risikoverwaltung helfen: 1. `Terminal.offlineStatus.sdk.offlinePaymentsCount` 1. `Terminal.offlineStatus.sdk.offlinePaymentAmountsByCurrency` #### Verwaltung der Latenz im Offline-Betrieb Basierend auf Ihrer Netzwerkverbindung bestimmt das Terminal SDK automatisch, ob Zahlungen online oder offline eingezogen werden sollen. Möglicherweise möchten Sie jedoch offline arbeiten, obwohl Sie eine aktive Netzwerkverbindung haben (z. B. wenn Sie Transaktionen schnell erfassen müssen und Ihre Netzwerkverbindung langsam ist). Sie können ein `CreateConfiguration`-Objekt mit `offlineBehavior`auf `FORCE_OFFLINE` gesetzt, um die Offline-Zahlung unabhängig von der Konnektivität einzuziehen. Zahlungen, die offline eingezogen werden, während das SDK von Terminal über eine aktive Netzwerkverbindung verfügt, werden im Hintergrund weitergeleitet. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { // ...build up parameters and callback for creating a `PaymentIntent` // Your app might want to prevent offline payments for too large an amount. // Here, we require a network connection if the payment if the amount is over 1000 usd. // Otherwise, we allow collecting offline if the network connection is unavailable.val offlineBehavior = if (cart.total > 1000000) { OfflineBehavior.REQUIRE_ONLINE } else { OfflineBehavior.PREFER_ONLINE } val createConfig = CreateConfiguration(offlineBehavior) Terminal.getInstance().createPaymentIntent(params, createPaymentCallback, createConfig) } } ``` ## Zahlungsmethode erfassen [Client-seitig] - [CollectPaymentIntentConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/index.html) > Die Zahlungspflicht liegt in Ihrer Verantwortung, wenn Sie Ihr Lesegerät offline betreiben. Da Magnetstreifendaten leicht zu fälschen sind, lässt Stripe diese Option im Offline-Betrieb nicht zu. Das Antippen von Karten wird auch nicht in Märkten unterstützt, in denen eine *starke Kundenauthentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich ist. Der Einzug von Zahlungen im Offline-Modus ähnelt dem [Einziehen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Verwenden Sie die Methode `onRequestReaderInput`, um Kundinnen/Kunden die gültigen Optionen zur Vorlage der Karte anzuzeigen. > Lesegeräte unterstützen die [Überprüfung der Angaben zur Zahlungsmethode vor der Autorisierung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=android#collect-inspect-payment-method) nicht, während sie offline sind. Sie können den Parameter `update PaymentIntent` zwar weiterhin in `CollectPaymentIntentConfiguration` festlegen, aber das Feld `paymentMethod` im PaymentIntent fehlt, wenn das SDK offline betrieben wird. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val collectPaymentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "collectPaymentMethod succeeded") // ... Confirm the payment } override fun onFailure(e: TerminalException) { Log.d(TAG, "collectPaymentMethod failed:", e) } } val collectConfig = CollectPaymentIntentConfiguration.Builder().build() Terminal.getInstance().collectPaymentMethod(paymentIntent, collectPaymentCallback, collectConfig) } } ``` ## Zahlung bestätigen [Client-seitig] Das Bestätigen von Zahlungen im Offline-Modus ähnelt dem [Bestätigen von Zahlungen online](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Der Hauptunterschied besteht darin, dass Ihre Integration offline-spezifische Fehlerfälle handhaben muss, z. B. wenn die Transaktion den von Stripe erzwungenen Offline-Höchstbetrag von 10.000 USD oder den Gegenwert in Ihrer Betriebswährung überschreitet. In einigen Fällen erstellt das SDK möglicherweise online einen `PaymentIntent`, bestätigt diesen jedoch offline. In diesem Fall hat der `PaymentIntent` möglicherweise eine `id`, die nicht Null ist. Wenn er offline bestätigt wurde, wird `offlineDetails` definiert und ausgefüllt. Das simulierte Lesegerät kann so konfiguriert werden, dass es eine simulierte Testkarte verwendet, mit der Sie während der Bestätigung verschiedene Offline-spezifische Abläufe testen können. Sie können beispielsweise Folgendes tun: - Verwenden Sie die simulierte Interac-Testkartennummer, um auf Fehler zu testen, während Sie einen `PaymentIntent` offline für nicht unterstützte Zahlungsmethoden bestätigen - Verwenden Sie eine Testkartennummer, die [zu einer abgelehnten Zahlung führt](https://docs.stripe.com/terminal/references/testing.md#test-cards-for-specific-error-cases), um auf Fehler bei der Weiterleitung eines gespeicherten `PaymentIntent` zu testen Eine vollständige Liste der verfügbaren Optionen finden Sie unter [Stripe Terminal testen](https://docs.stripe.com/terminal/references/testing.md). #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val confirmPaymentIntentCallback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "confirmPaymentIntent succeeded")// If the `PaymentIntent` was confirmed offline, `paymentIntent.offlineDetails` will be defined if (paymentIntent.offlineDetails != null) { Log.d(TAG, "confirmed offline") } else { Log.d(TAG, "confirmed online") } } override fun onFailure(e: TerminalException) { // Handle offline-specific errors in your application (for example, // unsupported payment method). Log.e(TAG, "confirmPaymentIntent failed:", e) } } Terminal.getInstance().confirmPaymentIntent(paymentIntent, confirmPaymentIntentCallback) } } ``` #### Ausstellung von Belegen Möglicherweise benötigen Sie Informationen über die Karte, mit der Sie eine Zahlung offline abschließen können. Beispielsweise müssen Sie möglicherweise einen Beleg für Kundinnen/Kunden erstellen, die diesen zum Zeitpunkt des Kaufs benötigen. Wenn der PaymentIntent offline bestätigt wird, rufen Sie ihre [OfflineCardPresentDetails](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-offline-card-present-details/index.html) from the `paymentIntent.offlineDetails.offlineCardPresentDetails`-Eigenschaft ab. Dieser Hash enthält eine [ReceiptDetails](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-receipt-details/index.html) -Eigenschaft, die Sie zum Generieren eines Belegs verwenden können, sowie weitere Kartendaten wie die Name und Marke der Karteninhaberin/des Karteninhabers. Die Belegfelder `account_type` und `authorization_response_code` sind bei offline verarbeiteten PaymentIntents nicht verfügbar. [Vordefinierte E-Mail-Belege](https://docs.stripe.com/terminal/features/receipts.md#prebuilt) werden erst gesendet, nachdem die Verbindung wiederhergestellt und die Zahlung erfolgreich erfasst wurde. ## Warten Sie, bis die Zahlungen weitergeleitet wurden [Client-seitig] Wenn die Internet access wiederhergestellt wird, beginnt das SDK automatisch mit der Weiterleitung der gespeicherten Offline-Zahlungen. Das SDK versucht, Zahlungen weiterzuleiten, auch wenn sein Netzwerkstatus offline ist. Dies bedeutet, dass der Anbieter Ihres Verbindungs-Tokens möglicherweise eine Anfrage zur Bereitstellung eines Verbindungs-Tokens erhält, auch wenn das Gerät offline ist. Wenn Sie Ihr POS-Gerät zu früh ausschalten, werden Ihre Zahlungen möglicherweise nicht weitergeleitet. Sie können `Terminal.offlineStatus.sdk.networkStatus` abfragen, um sicherzustellen, dass Ihr POS online ist und Zahlungen weiterleiten kann und `Terminal.offlineStatus.sdk.offlinePaymentsCount` , um zu überprüfen, wie viele Zahlungen an das Terminal-SDK weitergeleitet werden müssen. ## Zahlung erfassen Während Sie offline sind, können Sie PaymentIntents erstelle, deren `captureMethod` auf `automatic` gesetzt ist. Nachdem Sie diese PaymentIntents bestätigt haben, haben sie den Status `SUCCEEDED` anstelle von `REQUIRES_CAPTURE` . Stripe erfasst die Zahlungen automatisch, nachdem Sie sie weitergeleitet haben. Wenn Sie sich für die manuelle Erfassung entscheiden, müssen Zahlungen, die erfolgreich weitergeleitet und autorisiert wurden, von Ihrem Backend oder Ihrer Anwendung erfasst werden. - Zum Erfassen von Zahlungen von Ihrem Backend verwenden Sie [Webhooks](https://docs.stripe.com/webhooks.md), um PaymentIntents mit dem Status `requires_capture` zu erstellen. - Um Zahlungen aus Ihrer Anwendung zu erfassen, warten Sie darauf, dass Ihre Anwendung Aufrufe an `OfflineListener::onPaymentIntentForwarded` für jeden PaymentIntent erhält, während das SDK diesen weiterleitet. Ein PaymentIntent ist bereit für die Erfassung, wenn sein Status `REQUIRES_CAPTURE` ist und `offlineDetails` null ist oder der Wert für `requiresUpload` gleich `false` ist. #### Kotlin ```kotlin private const val TAG = "PaymentActivity" class PaymentActivity : AppCompatActivity() { // Action for a "Checkout" button private fun onCheckout(cart: Cart) { val callback: PaymentIntentCallback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { Log.d(TAG, "confirmPaymentIntent succeeded") if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) {val offlineDetails = paymentIntent.offlineDetails if (offlineDetails?.requiresUpload == true) { // Offline payment, wait for `onPaymentIntentForwarded` (see snippet below) } else { // Online payment, can be captured now } } else { // Handle other status results here } } override fun onFailure(e: TerminalException) { // Handle offline-specific errors in your application (for example, // unsupported payment method). Log.e(TAG, "confirmPaymentIntent failed:", e) } } Terminal.getInstance().confirmPaymentIntent(paymentIntent, callback) } } ``` Erfassen Sie eine Offline-Zahlung, nachdem das SDK dieses im `OfflineListener::onPaymentIntentForwarded` weitergeleitet hat: #### Kotlin ```kotlin class CustomOfflineListener : OfflineListener { // ... override fun onPaymentIntentForwarded(paymentIntent: PaymentIntent, e: TerminalException?) { if (e != null) { // Handle the error appropriate for your application } else if (paymentIntent.status == PaymentIntentStatus.REQUIRES_CAPTURE) { // The paymentIntent is ready to be captured } else { // Handle other status results here } } // ... } ``` ## Offline eingezogene Zahlungen prüfen Nach der Autorisierung können Sie die [PaymentIntents](https://docs.stripe.com/payments/payment-intents.md) API verwenden, um Details einer Zahlung offline zu untersuchen. Greifen Sie auf die [Angaben zur Zahlungsmethode](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card_present-offline) für das [neueste Charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge)-Objekt für einen `PaymentIntent` zu, um zu ermitteln, ob die Zahlung offline eingezogen wurde.