# Verwendung digitaler Geldbörsen mit Issuing Erfahren Sie, wie Sie mit Issuing Karten zu digitalen Geldbörsen hinzufügen können. > Token für Digital Wallets sind nur im Live-Modus verfügbar. Um diese Funktionen vollständig testen zu können, müssen Sie für Live-Use-Cases zugelassen sein und echte Karten verwenden. Mit Issuing können Nutzer/innen Karten sowohl manuell als auch über eine App zu digitalen Wallets wie Apple Pay und Google Pay hinzufügen. Stripe unterstützt das Hinzufügen von Karten über zwei Methoden: 1. **Manuelle Bereitstellung:** Karteninhaber/innen geben ihre Kartendaten in die digitale Geldbörse eines Smartphones ein, um diese zu ihrer digitalen Geldbörse hinzuzufügen. 1. **Push-Bereitstellung:** Mit mobilen Anwendungen können Nutzer/innen Karten direkt über die App in ihre digitalen Geldbörsen einzahlen. Wenn eine Karte zu einer digitalen Geldbörse hinzugefügt wird, wird eine tokenisierte Darstellung dieser Karte erstellt. Netzwerk-Token werden getrennt von Karten verwaltet. Weitere Informationen zu Netzwerk-Token und ihrer Funktionsweise finden Sie unter [Token-Verwaltung](https://docs.stripe.com/issuing/controls/token-management.md). ## Manuelle Bereitstellung Karteninhaber/innen können [virtuelle Karten](https://docs.stripe.com/issuing/cards/virtual.md) und [physische Karten](https://docs.stripe.com/issuing/cards/physical.md) von Stripe Issuing manuell zu ihren Geldbörsen von Apple Pay, Google Pay und Samsung Pay hinzufügen. Dazu öffnen die Karteninhaber/innen die Wallet-App auf ihrem Smartphone und geben ihre Kartendaten ein. Stripe sendet dann einen 6-stelligen Verifizierungscode an die `phone_number` oder `email` des/der Karteninhaber/in, der/die mit der Karte verknüpft ist. Die Fehlermeldung `card not supported` (Karte nicht unterstützt) wird angezeigt, wenn für den/die Karteninhaber/in bei der Bereitstellung der Karte keines der Felder festgelegt war. Es ist kein Code erforderlich, um die manuelle Bereitstellung zu implementieren, aber der Einrichtungsprozess kann je nach Anbieter digitaler Geldbörsen und Land, in dem Sie ansässig sind, variieren: ### USA Apple Pay-Wallets erfordern eine Genehmigung durch Apple. Überprüfen Sie die [Einstellungen in Ihrer Digital Wallet](https://dashboard.stripe.com/settings/issuing/digital-wallets), um den Status von Apple Pay in Ihrem Konto anzuzeigen. Gegebenenfalls müssen Sie einen Antrag beantragen, bevor Sie Apple Pay verwenden können. Nach dem Einreichen des Antrags kann die Genehmigung 1 bis 2 Wochen dauern. Für Google Pay und Samsung Pay sind keine zusätzlichen Schritte erforderlich. ### EU und Vereinigtes Königreich Digital Wallet-Integrationen erfordern eine zusätzliche Genehmigung des Stripe-Partnerschaftsteams. Kontaktieren Sie Ihre/n Kundenbetreuer/in oder [wenden Sie sich an Stripe](https://stripe.com/contact/sales), um weitere Informationen zu erhalten. Geldbörsen für Apple Pay erfordern eine zusätzliche Genehmigung. Überprüfen Sie die [Einstellungen in Ihrer digitalen Geldbörse](https://dashboard.stripe.com/settings/issuing/digital-wallets), um den Status von Apple Pay in Ihrem Konto anzuzeigen. Gegebenenfalls müssen Sie eine Berechtigung beantragen, bevor Sie Apple Pay verwenden können. ## Push-Bereitstellung Mit der Push-Bereitstellung können Karteninhaber/innen ihre Stripe Issuing-Karten direkt aus Ihrer App ihren Digital Wallets hinzufügen, indem sie auf eine Schaltfläche „Zu Wallet hinzufügen“ klicken, wie unten abgebildet. Nutzer/innen müssen zunächst manuelle Bereitstellungsschritte durchführen, um die Push-Bereitstellung in den USA zu aktivieren. Zusätzlich zur manuellen Genehmigung der Bereitstellung müssen Sie für die Push-Bereitstellung eine Integration mit dem Stripe SDK durchführen. Dies erfordert sowohl den Genehmigungsprozess über Stripe als auch die Code-Integration mit dem Stripe SDK für jede Plattform, auf der Sie die Push-Bereitstellung unterstützen möchten. Plattformgenehmigungen werden an alle verbundenen Konten weitergegeben. Push-Bereitstellung von Samsung Pay wird von unseren SDKs nicht unterstützt. # iOS > This is a iOS for when platform is ios. View the full page at https://docs.stripe.com/issuing/cards/digital-wallets?platform=ios. ![Eine schwarze Nutzeroberflächen-Schaltfläche mit der Aufschrift „Zu Apple Wallet hinzufügen“. Links neben dem Text befindet sich ein Apple Wallet-Logo. Es handelt sich um eine graue Geldbörse mit leicht versetzt gestapelten blauen, gelben, grünen und roten Karten.](https://b.stripecdn.com/docs-statics-srv/assets/add_to_apple_wallet.fe8cd234760a7478e34f5e91d22677bb.png) ## Zugriff anfordern > Sie müssen Zugriff auf die [manuelle Bereitstellung](https://docs.stripe.com/issuing/cards/digital-wallets.md?platform=android#manual-provisioning) erhalten, bevor Sie die Push-Bereitstellung anfordern können. Für Push-Provisioning ist eine gesonderte Berechtigung von Apple mit der Bezeichnung `com.apple.developer.payment-pass-provisioning` erforderlich. Sie können diese Berechtigung mit einer E-Mail an [support-issuing@stripe.com](mailto:support-issuing@stripe.com) anfordern. In Ihrer E-Mail sollten Sie Folgendes angeben: - **Kartennetzwerk**: Visa oder MasterCard. - **Name der Karte**: Der Name der im Wallet angezeigten Karte. - **Name der Anwendung** – Der Name Ihrer App. - **Entwickler-Team-ID**: In den Einstellungen Ihres Apple-Entwicklerkontos unter [Mitgliedschaft](https://developer.apple.com/account/#/membership) zu finden (zum Beispiel `2A23JCNA5E`). - **ADAM-ID**: Die eindeutige numerische ID Ihrer App. Zu finden in [App Store Connect](https://appstoreconnect.apple.com) oder im Link zum App-Store (zum Beispiel `https://apps.apple.com/app/id123456789`). - **Bundle ID** – Die Paket-ID Ihrer App, den Sie auch in App Store Connect finden (z. B. `com.example.yourapp`). Wenn Sie mehrere Apps (z. B. zu Testzwecken) mit unterschiedlichen Feldern für die oben genannten Attribute haben, müssen Sie den Zugriff für jede dieser Apps anfordern. Nachdem wir Ihre Anfrage genehmigt und umgesetzt haben, wird Ihre App auf der Detailseite einer bereitgestellten Karte in der Wallet-App angezeigt, und das `PKSecureElementPass`-Objekt ist in Ihrer App durch Aufrufen von `PKPassLibrary().passes()` verfügbar. Möglicherweise müssen Sie die Karte entfernen und erneut bereitstellen, damit die Änderung wirksam wird. ## Anspruch prüfen [Clientseitig] Stellen Sie sicher, dass Sie die neueste Version des [Stripe iOS SDK](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=mobile&platform=ios) in Ihrer App integriert haben. Ermitteln Sie, ob das Gerät für Push-Provisioning infrage kommt. 1. Überprüfen Sie, ob der Wert von `wallets[apple_pay][eligible]` in der ausgestellten Karte `true` ist. 1. Rufen Sie `PKPassLibrary().canAddSecureElementPass(primaryAccountIdentifier:)` mit `wallets[primary_account_identifier]` von Ihrer Karte auf und prüfen Sie, ob das Ergebnis `true` ist. Wenn `primary_account_identifier` leer ist, übergeben Sie eine leere Zeichenfolge an `canAddSecureElementPass()`. Rufen Sie diese Werte in Ihrem Backend ab und übergeben Sie sie dann zur Prüfung an Ihre App. > Sie müssen das serverseitige `wallets[apple_pay][eligible]`-Flag und das Ergebnis von `canAddSecureElementPass()` überprüfen, bevor Sie die `PKAddPassButton` anzeigen. Falls Sie die Schaltfläche **Zu Apple Wallet hinzufügen** anzeigen, ohne diese Werte zu überprüfen, lehnt App Review Ihre App möglicherweise ab. #### Swift ```swift import Stripe class MyViewController: UIViewController { @IBOutlet weak var addPassButton: PKAddPassButton! // ... func handleEligibilityResponse(eligible: Bool, primaryAccountIdentifier: String?) { if eligible && PKPassLibrary().canAddSecureElementPass(primaryAccountIdentifier: primaryAccountIdentifier ?? "") { addPassButton.isHidden = false } else { addPassButton.isHidden = true } } } ``` Mehr Kontext finden Sie in den Code-Snippets und Verweisen auf die Beispiel-App bei jedem Schritt. Sehen Sie sich für diesen Schritt an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/ios/Code/ViewController.swift#L201-L218) die Berechtigung prüft . ## Karte bereitstellen [Clientseitig] Wenn der/die Nutzer/in auf `PKAddPassButton` klickt, erstellen und präsentieren Sie einen `PKAddPaymentPassViewController`, der die Nutzeroberfläche von Apple für den Ablauf des Push-Provisioning enthält. `PKAddPaymentPassViewController` kann den `primaryAccountIdentifier` aus dem vorherigen Schritt verwenden, um festzustellen, ob eine Karte bereits auf einem bestimmten Gerät bereitgestellt wurde. Wurde die Karte beispielsweise bereits zu einem iPhone hinzugefügt, bietet die Benutzeroberfläche von Apple an, sie auch zu einer gekoppelten Apple Watch hinzuzufügen. #### Swift ```swift import Stripe class MyViewController: UIViewController { // ... func beginPushProvisioning() { let config = STPPushProvisioningContext.requestConfiguration( withName: "Jenny Rosen", // the cardholder's name description: "RocketRides Card", // optional; a description of your card last4: "4242", // optional; the last 4 digits of the card brand: .visa, // optional; the brand of the card primaryAccountIdentifier: self.primaryAccountIdentifier // the primary_account_identifier value from the previous step ) let controller = PKAddPaymentPassViewController(requestConfiguration: config, delegate: self) self.present(controller!, animated: true, completion: nil) } } ``` Schauen Sie sich für zusätzlichen Kontext an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/ios/Code/ViewController.swift#L280-L288) einen `PKAddPaymentPassViewController` verwendet. Der Initialisierer des `PKAddPaymentPassViewController` nimmt einen Delegaten an, den Sie implementieren müssen. In der Regel kann es sich dabei nur um die Ansichtssteuerung handeln, von der aus Sie die Anwendung anzeigen. Wir stellen eine Klasse mit dem Namen `STPPushProvisioningContext` bereit, die Sie bei der Implementierung dieser Methoden unterstützen soll. #### Swift ```swift class MyViewController: UIViewController { var pushProvisioningContext: STPPushProvisioningContext? = nil // ... } extension MyViewController: PKAddPaymentPassViewControllerDelegate { func addPaymentPassViewController(_ controller: PKAddPaymentPassViewController, generateRequestWithCertificateChain certificates: [Data], nonce: Data, nonceSignature: Data, completionHandler handler: @escaping (PKAddPaymentPassRequest) -> Void) { self.pushProvisioningContext = STPPushProvisioningContext(keyProvider: self) // STPPushProvisioningContext implements this delegate method for you, by retrieving encrypted card details from the Stripe API. self.pushProvisioningContext?.addPaymentPassViewController(controller, generateRequestWithCertificateChain: certificates, nonce: nonce, nonceSignature: nonceSignature, completionHandler: handler); } func addPaymentPassViewController(_ controller: PKAddPaymentPassViewController, didFinishAdding pass: PKPaymentPass?, error: Error?) { // Depending on if `error` is present, show a success or failure screen. self.dismiss(animated: true, completion: nil) } } ``` Schauen Sie sich für zusätzlichen Kontext an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/ios/Code/ViewController.swift#L293-L349) einen `PKAddPaymentPassViewControllerDelegate` implementiert. Sie werden feststellen, dass der Initialisierer von `STPPushProvisioningContext` einen `keyProvider` erwartet. Dies ist die Instanz einer Klasse, die das Protokoll `STPIssuingCardEphemeralKeyProvider` implementiert. Dieses Protokoll definiert eine einzige erforderliche Methode: `createIssuingCardKeyWithAPIVersion:completion`. Zur Implementierung dieser Methode muss ein API-Aufruf an Ihr Backend erfolgen. Ihr Backend erstellt das Objekt „Temporärer Schlüssel“ mithilfe der Stripe-API und gibt es an Ihre App zurück. Ihre App ruft anschließend den angegebenen Abschluss-Handler mit der API-Antwort Ihres Backends auf. #### Swift ```swift extension MyViewController: STPIssuingCardEphemeralKeyProvider { func createIssuingCardKey(withAPIVersion apiVersion: String, completion: @escaping STPJSONResponseCompletionBlock) { // This example uses Alamofire for brevity, but you can make the request however you want AF.request("https://myapi.com/ephemeral_keys", method: .post, parameters: ["api_version": apiVersion]) .responseJSON { response in switch response.result { case .success: if let data = response.data { do { let obj = try JSONSerialization.jsonObject(with: data, options: []) as! [AnyHashable: Any] completion(obj, nil) } catch { completion(nil, error) } } case .failure(let error): completion(nil, error) } } } } ``` Schauen Sie sich für zusätzlichen Kontext an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/ios/Code/ViewController.swift#L379-L394) einen `STPIssuingCardEphemeralKeyProvider` verwendet. ## Backend aktualisieren [Serverseitig] Die Implementierung von Push-Provisioning sieht Methoden vor, bei denen Sie mit Ihrem eigenen Backend kommunizieren müssen, um einen temporären Stripe-Schlüssel zu erstellen und einen JSON-Code davon an Ihre App zurückzugeben. Bei diesen Schlüsseln handelt es sich um kurzlebige API-Zugangsdaten, die Sie zum Abrufen der verschlüsselten Kartendaten für eine einzelne Instanz eines Kartenobjekts verwenden können. Um sicherzustellen, dass das von der Stripe-API zurückgegebene Objekt mit der von Ihnen verwendeten Version des iOS oder Android SDK kompatibel ist, informiert Sie das Stripe SDK über seine bevorzugte API-Version. Sie müssen diese API-Version bei der Erstellung des Schlüssels explizit an unsere API übergeben. #### curl ```bash curl https://api.stripe.com/v1/ephemeral_keys \ -u <>: \ -d "issuing_card"="{{ISSUING_CARD_ID}}" \ -H "Stripe-Version: {{API_VERSION}}" ``` ```json { "id": "ephkey_1G4V6eEEs6YsaMZ2P1diLWdj", "object": "ephemeral_key", "associated_objects": [ { "id": "{{CARD_ID}}", "type": "issuing.card" } ], "created": 1586556828, "expires": 1586560428, "livemode": false, "secret": "ek_test_YWNjdF8xRmdlTjZFRHelWWxwWVo5LEtLWFk0amJ2N0JOa0htU1JzEZkd2RpYkpJdnM_00z2ftxCGG" } ``` Schauen Sie sich für zusätzlichen Kontext an, wie das [Beispiel-Backend](https://github.com/stripe-samples/push-provisioning-samples/blob/main/server/ruby/README.md) einen [temporären Stripe-Schlüssel](https://github.com/stripe-samples/push-provisioning-samples/blob/main/server/ruby/server.rb#L68-L88) erstellt. ## Tests Die Berechtigung `com.apple.developer.payment-pass-provisioning` funktioniert nur mit den Distribution Provisioning Profiles. Das heißt, selbst wenn Sie diese Berechtigung erhalten haben, können Sie den End-to-End-Ablauf von Push-Provisioning nur testen, indem Sie Ihre App mit TestFlight oder dem App Store bereitstellen. Um beim Testen zu helfen, stellen wir eine Mock-Version von `PKAddPaymentPassViewController` namens `STPFakeAddPaymentPassViewController` zur Verfügung, die Sie während des Testens austauschbar verwenden können. Dies funktioniert nur im [Test-Modus](https://docs.stripe.com/testing-use-cases.md#test-versus-live-mode) mit Testkarten. #### Swift ```swift import Stripe class MyViewController: UIViewController { // ... func beginPushProvisioning() { let config = STPPushProvisioningContext.requestConfiguration( withName: "Jenny Rosen", // the cardholder's name description: "RocketRides Card", // optional; a description of your card last4: "4242", // optional; the last 4 digits of the card brand: .visa // optional; the brand of the card )let controller = STPFakeAddPaymentPassViewController(requestConfiguration: config, delegate: self) self.present(controller!, animated: true, completion: nil) } } ``` Um die Beispiel-App zu erstellen, befolgen Sie die Schritte im [Readme](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/ios/README.md). Sie müssen die App nicht erstellen, um die Anweisungen oben zu befolgen. # Android > This is a Android for when platform is android. View the full page at https://docs.stripe.com/issuing/cards/digital-wallets?platform=android. ![Eine schwarze Nutzeroberflächen-Schaltfläche mit der Aufschrift „Zu Google Wallet hinzufügen“. Links neben dem Text befindet sich ein Google Wallet-Logo.](https://b.stripecdn.com/docs-statics-srv/assets/add_to_google_pay_black.2df6c169bbc605123ec73d37dc73a86e.png) ## Zugriff anfordern > Sie müssen Zugriff auf die [manuelle Bereitstellung](https://docs.stripe.com/issuing/cards/digital-wallets.md?platform=android#manual-provisioning) erhalten, bevor Sie die Push-Bereitstellung anfordern können. Stripe stellt einen SDK-Wrapper für eine private Google-Bibliothek für das Push-Provisioning bereit. Gehen Sie wie folgt vor, um Ihre App im Google Pay Store mithilfe von Push-Provisioning bereitstellen zu können: 1. [Zugriff auf Google Pay anfordern](https://developers.google.com/pay/issuers/requesting-access?api=true). Nach Ausfüllen des Formulars können Sie innerhalb weniger Stunden bis zu einem Tag mit der Genehmigung rechnen. 1. Laden Sie nach Erhalt der Genehmigung das [private TapAndPay SDK](https://developers.google.com/pay/issuers/apis/push-provisioning/android/releases) von Google herunter. Die zuletzt getestete Version des TapAndPay SDK ist Version 18. 1. [Fordern Sie Zugriff auf die Push-Provisioning API](https://support.google.com/faqs/contact/pp_api_allowlist) für Ihre App an. Sie müssen Ihre [App-ID](https://developer.android.com/studio/build/application-id) angeben, um zur Zulassungsliste von Google hinzugefügt zu werden. Einzelheiten zu diesem Vorgang finden Sie in der [Dokumentation](https://developers.google.com/pay/issuers/apis/push-provisioning/android/allowlist) von Google. Nachdem der Vorgang abgeschlossen ist, gewährt Google Push-Bereitstellungsberechtigungen. 1. Nachdem Google die Push-Bereitstellungsberechtigungen gewährt hat, [kontaktieren Sie Stripe](mailto:support-issuing@stripe.com) und geben Sie Ihren Anwendungsnamen, Ihre Anwendungs-ID, Ihr Kartennetzwerk und Ihren Kartennamen an, um diesen Schritt abzuschließen. ## App aktualisieren [Clientseitig] So aktualisieren Sie Ihre App: 1. Importieren Sie das [private SDK](https://developers.google.com/pay/issuers/apis/push-provisioning/android/setup) von Google. 1. Importieren Sie das SDK von Stripe. ```java dependencies { [... your dependencies] implementation 'com.stripe:stripe-android-issuing-push-provisioning:1.2.2' } ``` Mehr Kontext finden Sie in den Code-Snippets und Verweisen auf die Beispiel-App bei jedem Schritt. Sehen Sie sich für diesen Schritt an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/android/app/build.gradle.kts#L111-L118) diese SDKs importiert. - Bereiten Sie Ihr Backend für die Erstellung von temporären Schlüsseln für Ihre Karten vor. [Weitere Informationen finden Sie im Abschnitt unten](https://docs.stripe.com/issuing/cards/digital-wallets.md#backend-changes). - Erstellen Sie einen `EphemeralKeyProvider`, der `PushProvisioningEphemeralKeyProvider` erweitert. Da der Anbieter eines temporären Schlüssels an eine andere Aktivität übergeben werden soll, muss dieser auch `Parcelable` implementieren (siehe [Parcelable](https://developer.android.com/reference/android/os/Parcelable)). Schauen Sie sich für zusätzlichen Kontext an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/android/app/src/main/java/com/stripe/android/pushprovisioning/network/BackendPushProvisioningEphemeralKeyProvider.kt#L20-L43) ihren `EphemeralKeyProvider` definiert. - Implementieren Sie die Schaltfläche **Zu Google Pay hinzufügen** [gemäß den Spezifikationen von Google](https://developers.google.com/pay/issuers/apis/push-provisioning/android/branding-guidelines). Die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/android/app/src/main/res/layout/card_picker_item.xml#L19-L25) enthält ein Beispiel für die Einhaltung der Branding-Richtlinien durch die Schaltfläche. > Verlangen Sie, wie von Google [empfohlen](https://developers.google.com/pay/issuers/apis/push-provisioning/android/faq#implementation_questions), nicht, dass Ihre Nutzer/innen die Google Pay App installieren und überprüfen Sie auch nicht automatisch, ob diese vorhanden ist. Die App ist nur ein Frontend und wird nicht benötigt damit Google Pay funktioniert. Nutzer/innen können ihre Karten in ihren Google-Einstellungen in der App „Einstellungen“ verwalten. Google verlangt, dass die Schaltfläche **Zu Google Pay hinzufügen** nur angezeigt wird, wenn noch keine Karte auf dem Gerät der Nutzer/innen vorhanden ist, und dass Nutzer/innen mit Karten, die noch überprüft werden müssen, den abschließenden geführten Aktivierungsprozess durchführen. Prüfen Sie anhand der [Liste der Checkpoints](https://developers.google.com/pay/issuers/apis/push-provisioning/android/test-cases) von Google, ob Ihre Implementierung korrekt ist. Um den Status der Karten Ihrer Nutzer/innen zu überprüfen, verwenden Sie [listTokens()](https://developers.google.com/pay/issuers/apis/push-provisioning/android/reading-wallet#listtokens), um eine Liste aller Ihrer bereits auf dem Gerät vorhandenen Karten abzurufen. Vergleichen Sie den Wert von `getFpanLastFour()` für jedes zurückgegebene Objekt mit der Stripe-Eigenschaft [last4](https://docs.stripe.com/api/issuing/cards/object.md#issuing_card_object-last4)) des [Issued Card-Objekts](https://docs.stripe.com/api/issuing/cards/object.md) für die Karte, die Sie hinzufügen möchten. Verwerfen Sie alle nicht übereinstimmenden Objekte aus der Antwortliste. - Wenn die Ergebnisliste leer ist, bedeutet dies, dass die Karte, die Sie hinzufügen möchten, noch nicht auf dem Gerät vorhanden ist, Sie können mit der Anzeige der Schaltfläche wie unten beschrieben fortfahren. - Wenn die Ergebnisliste ein `TokenInfo`-Objekt enthält, prüfen Sie seinen [TokenState](https://developers.google.com/pay/issuers/apis/push-provisioning/android/enumerated-values#token_status) durch Aufruf von `getTokenState()`. - Wenn der Status `TOKEN_STATE_NEEDS_IDENTITY_VERIFICATION` ist, hat Ihr/e Nutzer/in bereits versucht, die angegebenen Karte zu seinem/ihrem Gerät hinzuzufügen. Zeigen Sie die Schaltfläche **Zu Google Pay hinzufügen** an. Helfen Sie den Nutzer/innen jedoch dabei, diese Situation zu beheben, indem Sie den Listener `onActivityResult` mit der Methode `tokenize()` verbinden, wie in der [Dokumentation von Google](https://developers.google.com/pay/issuers/apis/push-provisioning/android/wallet-operations#resolving_yellow_path) beschrieben. - Bei einem anderen Status ist die Karte bereits auf dem Gerät vorhanden. **Keine Google Pay-Schaltfläche anzeigen.** Stellen Sie Stripe unbedingt Ihre Anwendungs-ID zur Verfügung, bevor Sie mit den internen Tests beginnen. Die Einrichtung kann mehr als eine Woche dauern, und die Folgen einer unvollständigen Einrichtung sind unter anderem inkonsistente Antworten auf diese beiden Methoden. Das Ergebnis von `listTokens()` **enthält nur Karten, die hinzugefügt wurden, nachdem** Stripe die Einrichtung abgeschlossen hat. Wenn ein/e Nutzer/in auf die Schaltfläche klickt, wird die `PushProvisioningActivity` von Stripe mit dem `PushProvisioningActivityStarter` gestartet. ```java new PushProvisioningActivityStarter( this, // The Activity or Fragment you are initiating the push provisioning from new PushProvisioningActivityStarter.Args( "Stripe Card", // The name that will appear on the push provisioning UI ephemeralKeyProvider, // Your instance of EphemeralKeyProvider false // If you want to enable logs or not )).startForResult(); ``` Schauen Sie sich für zusätzlichen Kontext an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/android/app/src/main/java/com/stripe/android/pushprovisioning/MainActivity.kt#L119-L124) `PushProvisioningActivity` einführt. Dadurch wird das Push-Provisioning vorbereitet und die Nutzeroberfläche aufgerufen, um die Karte der Geldbörse hinzuzufügen. Implementieren Sie den Callback in Ihrem `onActivityResult`. ```java protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) { if (requestCode == PushProvisioningActivityStarter.REQUEST_CODE) { if (resultCode == PushProvisioningActivity.RESULT_OK) { PushProvisioningActivityStarter.Result success = PushProvisioningActivityStarter.Result.fromIntent(data); } else if (resultCode == PushProvisioningActivity.RESULT_ERROR) { PushProvisioningActivityStarter.Error error = PushProvisioningActivityStarter.Error.fromIntent(data); } } } ``` Schauen Sie sich für zusätzlichen Kontext an, wie die [Beispiel-App](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/android/app/src/main/java/com/stripe/android/pushprovisioning/MainActivity.kt#L132-L167) `onActivityResult` implementiert. Wenn die Bereitstellung erfolgreich war, erhalten Sie ein `PushProvisioningActivityStarter.Result` mit einer `cardTokenId`, der ID von Google für die Karte in der aktiven Geldbörse. Mit dieser ID können Sie auch die anderen Funktionen der Geldbörse nutzen. Wenn bei der Bereitstellung ein Fehler auftritt, wird ein `PushProvisioningActivityStarter.Error` mit einem `code` und einer `message` zurückgegeben. Bei der `message` handelt es sich um eine entwicklerfreundliche Erläuterung des Fehlers. Der `code` kann die folgenden Werte haben: | Enum | Bedeutung | | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | | **USER\_CANCELED** | Der/die Nutzer/n hat die Bereitstellung abgebrochen. | | **CARD\_CANCELED** | Die Karte wurde deaktiviert oder ist verloren oder gestohlen und kann nicht bereitgestellt werden. | | **EPHEMERAL\_KEY\_ERROR** | Beim Abrufen des temporären Schlüssels ist ein Fehler aufgetreten. | | **TAP\_AND\_PAY\_UNAVAILABLE** | Die TapAndPay-Bibliothek kann nicht verwendet werden, wahrscheinlich wurde die App nicht zu einer Zulassungsliste hinzugefügt. | | **NO\_STABLE\_HARDWARE\_ID** | Dieser Fehler kann im Entwicklungsemulator auftreten. Die App kann die stabile Hardware-ID nicht abrufen. | | **NO\_ACTIVE\_WALLET\_FOUND** | Es ist keine aktive Geldbörse verfügbar. Beachten Sie, dass Emulatoren in der Regel nicht über Google Pay verfügen. | | **PUSH\_PROVISIONING\_ENCRYPTED\_PAYLOAD\_ERROR** | Es gab einen Fehler bei der Verbindung mit den Servern von Stripe, um die verschlüsselte Nutzlast für das Push-Provisioning zu erhalten. | | **UNKNOWN\_ERROR** | Es ist ein unerwarteter Fehler aufgetreten. Die `message` enthält weitere Informationen. | ## Backend aktualisieren [Serverseitig] Die Implementierung von Push-Provisioning sieht Methoden vor, bei denen Sie mit Ihrem eigenen Backend kommunizieren müssen, um einen temporären Stripe-Schlüssel zu erstellen und einen JSON-Code davon an Ihre App zurückzugeben. Bei diesen Schlüsseln handelt es sich um kurzlebige API-Zugangsdaten, die Sie zum Abrufen der verschlüsselten Kartendaten für eine einzelne Instanz eines Kartenobjekts verwenden können. Um sicherzustellen, dass das von der Stripe-API zurückgegebene Objekt mit der von Ihnen verwendeten Version des iOS oder Android SDK kompatibel ist, informiert Sie das Stripe SDK über seine bevorzugte API-Version. Sie müssen diese API-Version bei der Erstellung des Schlüssels explizit an unsere API übergeben. #### curl ```bash curl https://api.stripe.com/v1/ephemeral_keys \ -u <>: \ -d "issuing_card"="{{ISSUING_CARD_ID}}" \ -H "Stripe-Version: {{API_VERSION}}" ``` ```json { "id": "ephkey_1G4V6eEEs6YsaMZ2P1diLWdj", "object": "ephemeral_key", "associated_objects": [ { "id": "{{CARD_ID}}", "type": "issuing.card" } ], "created": 1586556828, "expires": 1586560428, "livemode": false, "secret": "ek_test_YWNjdF8xRmdlTjZFRHelWWxwWVo5LEtLWFk0amJ2N0JOa0htU1JzEZkd2RpYkpJdnM_00z2ftxCGG" } ``` Schauen Sie sich für zusätzlichen Kontext an, wie das [Beispiel-Backend](https://github.com/stripe-samples/push-provisioning-samples/blob/main/server/ruby/README.md) einen [temporären Stripe-Schlüssel](https://github.com/stripe-samples/push-provisioning-samples/blob/main/server/ruby/server.rb#L68-L88) erstellt. ## Tests Alle Tests müssen im Live-Modus mit Live-Karten und auf physischen Geräten durchgeführt werden. Um die Beispiel-App zu erstellen, befolgen Sie die Schritte im [Readme](https://github.com/stripe-samples/push-provisioning-samples/blob/main/client/android/README.md). Sie müssen die App nicht erstellen, um die Anweisungen oben zu befolgen. # React Native > This is a React Native for when platform is react-native. View the full page at https://docs.stripe.com/issuing/cards/digital-wallets?platform=react-native. ![Eine schwarze Nutzeroberflächen-Schaltfläche mit der Aufschrift „Zu Apple Wallet hinzufügen“. Links neben dem Text befindet sich ein Apple Wallet-Logo. Es handelt sich um eine graue Geldbörse mit leicht versetzt gestapelten blauen, gelben, grünen und roten Karten.](https://b.stripecdn.com/docs-statics-srv/assets/add_to_apple_wallet.fe8cd234760a7478e34f5e91d22677bb.png) ![Eine schwarze Nutzeroberflächen-Schaltfläche mit der Aufschrift „Zu Google Wallet hinzufügen“. Links neben dem Text befindet sich ein Google Wallet-Logo.](https://b.stripecdn.com/docs-statics-srv/assets/add_to_google_pay_black.2df6c169bbc605123ec73d37dc73a86e.png) ## Zugriff anfordern > Sie müssen Zugriff auf die [manuelle Bereitstellung](https://docs.stripe.com/issuing/cards/digital-wallets.md?platform=android#manual-provisioning) erhalten, bevor Sie die Push-Bereitstellung anfordern können. ### Zugriff für iOS anfordern Für Push-Provisioning ist eine gesonderte Berechtigung von Apple mit der Bezeichnung `com.apple.developer.payment-pass-provisioning` erforderlich. Sie können diese Berechtigung mit einer E-Mail an [support-issuing@stripe.com](mailto:support-issuing@stripe.com) anfordern. In Ihrer E-Mail sollten Sie Folgendes angeben: - **Kartennetzwerk**: Visa oder MasterCard. - **Name der Karte**: Der Name der im Wallet angezeigten Karte. - **Name der Anwendung** – Der Name Ihrer App. - **Entwickler-Team-ID**: In den Einstellungen Ihres Apple-Entwicklerkontos unter [Mitgliedschaft](https://developer.apple.com/account/#/membership) zu finden. - **ADAM-ID**: Die eindeutige numerische ID Ihrer App. Zu finden in [App Store Connect](https://appstoreconnect.apple.com) oder im Link zum App-Store (zum Beispiel `https://apps.apple.com/app/id123456789`). - **Bundle ID** – Die Paket-ID Ihrer App, den Sie auch in App Store Connect finden (z. B. `com.example.yourapp`). ### Zugriff für Android anfordern Stripe stellt einen SDK-Wrapper für eine private Google-Bibliothek für das Push-Provisioning bereit. Fordern Sie Zugriff auf diese Bibliothek an, um Ihre App im Google Pay Store mithilfe von Push-Provisioning bereitstellen zu können: - [Zugriff auf Google Pay anfordern](https://developers.google.com/pay/issuers/requesting-access?api=true) - [Privates TapAndPay SDK](https://developers.google.com/pay/issuers/apis/push-provisioning/android/releases) von Google herunterladen (die aktuell kompatible Version ist [17.1.2](https://developers.google.com/static/pay/issuers/apis/push-provisioning/android/downloads/tapandpay_sdk.m2repo_2021-07-19_v17.1.2.zip)) - [Stellen Sie eine Anfrage auf Zugriff auf die Push Provisioning API](https://support.google.com/faqs/contact/pp_api_allowlist) für Ihre App. Sie müssen Ihre [Anwendungs-ID](https://developer.android.com/studio/build/application-id) angeben, um zur Zulassungsliste von Google hinzugefügt zu werden. Details zu diesem Prozess finden Sie in der [Dokumentation](https://developers.google.com/pay/issuers/apis/push-provisioning/android/allowlist) von Google. - Geben Sie dieselbe Anwendungs-ID, Ihren App-Namen, Ihr Kartennetzwerk und Ihren Kartennamen an [support-issuing@stripe.com](mailto:support-issuing@stripe.com) weiter. ## Ihre App einrichten [Clientseitig] Das [React Native SDK](https://github.com/stripe/stripe-react-native) ist Open Source und vollständig dokumentiert. Intern werden [native iOS](https://github.com/stripe/stripe-ios) und [Android](https://github.com/stripe/stripe-android) SDKs verwendet. Um das React Native SDK von Stripe zu installieren, führen Sie einen der folgenden Befehle im Verzeichnis Ihres Projekts aus (je nachdem, welchen Paket-Manager Sie verwenden): #### yarn ```bash yarn add @stripe/stripe-react-native ``` #### npm ```bash npm install @stripe/stripe-react-native ``` Installieren Sie als Nächstes einige weitere erforderliche Abhängigkeiten: - Für iOS wechseln Sie in das Verzeichnis **ios** und führen Sie `pod install` aus, um sicherzustellen, dass Sie auch die erforderlichen nativen Dependencies installiert haben. - Für Android müssen keine Abhängigkeiten mehr installiert werden. > Wir empfehlen Ihnen, die [offizielle Anleitung zu TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) zu befolgen, um TypeScript zu unterstützen. ### Stripe Initialisierung Um Stripe in Ihrer React Native-App zu initialisieren, umschließen Sie entweder Ihren Zahlungsbildschirm mit der Komponente `StripeProvider` oder verwenden Sie die Initialisierungsmethode `initStripe`. Nur der [veröffentlichbare API-Schlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) in `publishableKey` ist erforderlich. Das folgende Beispiel zeigt, wie Stripe mithilfe der Komponente `StripeProvider` initialisiert wird. ```jsx import { useState, useEffect } from 'react'; import { StripeProvider } from '@stripe/stripe-react-native'; function App() { const [publishableKey, setPublishableKey] = useState(''); const fetchPublishableKey = async () => { const key = await fetchKey(); // fetch key from your server here setPublishableKey(key); }; useEffect(() => { fetchPublishableKey(); }, []); return ( {/* Your app code here */} ); } ``` > Verwenden Sie Ihre API-[Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. ### Android-spezifische Einrichtung Um die Push-Bereitstellung auf Android zu aktivieren, nachdem Sie Zugriff auf das TapAndPay-SDK erhalten haben (siehe oben), müssen Sie diese [in Ihr natives Android-Projekt einbeziehen](https://developers.google.com/pay/issuers/apis/push-provisioning/android/setup). Anschließend müssen Sie die native Android-Push-Bereitstellungsbibliothek von Stripe importieren, indem Sie Folgendes zu Ihrer Datei `android/app/build.gradle` hinzufügen: #### Groovy ```groovy dependencies { // ...implementation 'com.stripe:stripe-android-issuing-push-provisioning:1.1.0' } ``` ### iOS-spezifische Einrichtung Um die Push-Bereitstellung unter iOS zu aktivieren, müssen Sie, nachdem Stripe bestätigt hat, dass die Berechtigung gewährt wurde, [die Funktion zu Ihrem Bereitstellungsprofil auf App Store Connect hinzufügen](https://developer.apple.com/account/resources/profiles/list). Dann müssen Sie die neue Berechtigung Ihrer Datei `ios/app.config.js` hinzufügen: ``` "entitlements": { "com.apple.developer.payment-pass-provisioning": true } ``` ## Backend aktualisieren [Serverseitig] Die Implementierung von Push-Provisioning sieht Methoden vor, bei denen Sie mit Ihrem eigenen Backend kommunizieren müssen, um einen temporären Stripe-Schlüssel zu erstellen und einen JSON-Code davon an Ihre App zurückzugeben. Bei diesen Schlüsseln handelt es sich um kurzlebige API-Zugangsdaten, die Sie zum Abrufen der verschlüsselten Kartendaten für eine einzelne Instanz eines Kartenobjekts verwenden können. Um sicherzustellen, dass das von der Stripe-API zurückgegebene Objekt mit der von Ihnen verwendeten Version des SDK kompatibel ist, müssen Sie die vom React Nativ SDK exportierte API-Version bei der Erstellung des Schlüssels explizit an unsere API übergeben. #### curl ```bash curl https://api.stripe.com/v1/ephemeral_keys \ -u <>: \ -d "issuing_card"="{{ISSUING_CARD_ID}}" \ -H "Stripe-Version: {{API_VERSION}}" ``` ```json { "id": "ephkey_1G4V6eEEs6YsaMZ2P1diLWdj", "object": "ephemeral_key", "associated_objects": [ { "id": "{{CARD_ID}}", "type": "issuing.card" } ], "created": 1586556828, "expires": 1586560428, "livemode": false, "secret": "ek_test_YWNjdF8xRmdlTjZFRHelWWxwWVo5LEtLWFk0amJ2N0JOa0htU1JzEZkd2RpYkpJdnM_00z2ftxCGG" } ``` Sie sollten auch einen Endpoint erstellen, um die Details der Ausstellungskarte abzurufen, die Sie an die Komponente `` übergeben müssen: ```curl curl https://api.stripe.com/v1/issuing/cards/ISSUING_CARD_ID \ -u "<>:" ``` ## App aktualisieren [Clientseitig] Bestimmen Sie zunächst, ob das Gerät für Push-Provisioning geeignet ist, indem Sie prüfen, ob der Wert von `wallets.apple_pay.eligible` in der ausgestellten Karte (abgerufen vom zweiten Endpoint, den Sie oben in Schritt 3 erstellt haben) `true` ist. Wenn dies der Fall ist, speichern Sie die Kartendaten für die spätere Verwendung in unserer Komponente und fahren Sie fort. Wenn `wallets.apple_pay.eligible` den `Wert false` hat, zeigen Sie die `` unter iOS nicht an. Andernfalls wird Ihre App-Prüfung abgelehnt. Dasselbe gilt für `wallets.google_pay.eligible` für Android. ```javascript import React, {useEffect, useState} from 'react'; import {Constants} from '@stripe/stripe-react-native'; import {View} from 'react-native'; export default function MyScreen() { const [key, setKey] = useState(null);const [card, setCard] = useState(null); useEffect(() => { fetchEphemeralKey();fetchIssuingCard(); }, []); const fetchIssuingCard = async () => { const response = await fetch(`${API_URL}/issuing-card`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ ISSUING_CARD_ID: '{{ISSUING_CARD_ID}}', }), }); const card = await response.json(); if (!card.wallets.apple_pay.eligible) { // Do not show component on iOS. See card.wallets.apple_pay.ineligible_reason for details } else if (!card.wallets.google_pay.eligible) { // Do not show component on Android. See card.wallets.google_pay.ineligible_reason for details } else { setCard(card); } }; const fetchEphemeralKey = async () => { // See above }; return ; } ``` Rufen Sie als Nächstes Ihren vergänglichen Schlüssel vom ersten Endpoint ab, den Sie in Schritt 3 oben erstellt haben, und speichern Sie ihn. ```javascript import React, {useEffect, useState} from 'react'; import {Constants} from '@stripe/stripe-react-native'; import {View} from 'react-native'; export default function MyScreen() { const [key, setKey] = useState(null); useEffect(() => { fetchEphemeralKey(); }, []); const fetchEphemeralKey = async () => { const response = await fetch(`${API_URL}/ephemeral-key`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ ISSUING_CARD_ID: '{{ISSUING_CARD_ID}}', API_VERSION: Constants.API_VERSIONS.ISSUING, }), }); const myKey = await response.json(); setKey(myKey); }; return ; } ``` Sie benötigen keine Serverkommunikation mehr. Als Nächstes müssen Sie ermitteln, ob die Karte zur Geldbörse *hinzugefügt* werden kann. Sie können dies mit der Methode `canAddCardToWallet` überprüfen, die ein Objekt zurückgibt, das das boolesche Feld `canAddCard` enthält. Wenn `canAddCard` auf `false` festgelegt ist, wird `AddToWalletButton` nicht gerendert, da Ihre App ansonsten möglicherweise von Apple abgelehnt wird. Bei Android besteht die Möglichkeit, dass sich die Karte bereits im Wallet befindet, aber in einem schlechten Status feststeckt. Sie können für einen solchen Fall Logik hinzufügen, indem Sie nach einer `token`-Antwort `details` von `canAddCardToWallet` suchen. Wenn diese Antwort nicht null ist und der `token.status` `"TOKEN_STATE_NEEDS_IDENTITY_VERIFICATION"` ist, übergeben Sie diesen `token` an die Props von ``. ```javascript import React, {useEffect, useState} from 'react'; import {Constants, canAddCardToWallet, GooglePayCardToken} from '@stripe/stripe-react-native'; import {View} from 'react-native'; export default function MyScreen() { const [key, setKey] = useState(null); const [card, setCard] = useState(null);const [showAddToWalletButton, setShowAddToWalletButton] = useState(false); const [androidCardToken, setAndroidCardToken] = useState(null); useEffect(() => { fetchEphemeralKey(); fetchIssuingCard(); }, []); const checkIfCanAddCard = async () => { const { canAddCard, details, error } = await canAddCardToWallet({ primaryAccountIdentifier: card?.wallets?.primary_account_identifier, cardLastFour: card.last4, hasPairedAppleWatch: // Pass a boolean indicating whether or not the device has a paired Apple Watch. iOS only. }); if (error) { Alert.alert(error.code, error.message); } else { setShowAddToWalletButton(canAddCard); if (details?.token?.status === 'TOKEN_STATE_NEEDS_IDENTITY_VERIFICATION') { setAndroidCardToken(details.token); } } }; const fetchIssuingCard = async () => { // See aboveawait checkIfCanAddCard(); }; const fetchEphemeralKey = async () => { // See above }; return ; } ``` Jetzt haben wir alle Informationen, die wir brauchen, um die Schaltfläche anzuzeigen: ```javascript import React, {useEffect, useState} from 'react'; import { Constants, canAddCardToWallet, AddToWalletButton, GooglePayCardToken, } from '@stripe/stripe-react-native'; import {View, Image, Alert, StyleSheet} from 'react-native'; import AddToGooglePayPNG from '../assets/Add-to-Google-Pay-Button-dark-no-shadow.png'; export default function MyScreen() { const [key, setKey] = useState(null); const [card, setCard] = useState(null); const [showAddToWalletButton, setShowAddToWalletButton] = useState(false); const [androidCardToken, setAndroidCardToken] = useState(null); useEffect(() => { fetchEphemeralKey(); fetchIssuingCard(); }, []); const canAddCard = async () => { // See above }; const fetchIssuingCard = async () => { // See above }; const fetchEphemeralKey = async () => { // See above }; return ( {showAddToWalletButton && ( { Alert.alert( error ? error.code : 'Success', error ? error.message : 'Card was successfully added to the wallet.', ); }} /> )} ); } const styles = StyleSheet.create({ payButton: { // You may add custom styles to your button, but make sure it complies // with the relevant platform guidelines: // iOS : https://developer.apple.com/wallet/add-to-apple-wallet-guidelines/ // Android : https://developers.google.com/pay/issuers/apis/push-provisioning/android/branding-guidelines }, }); ``` Wenn ein/e Nutzer/in auf die Schaltfläche tippt, wird die Benutzeroberfläche gestartet, um die Karte zum Wallet hinzuzufügen. Implementieren Sie den Callback in Ihrem `onComplete`-Prop. Ist das `error`-Feld nicht null, ist ein Fehler aufgetreten und die Karte wurde nicht Wallet hinzugefügt. Wenn der `error` null ist, wurde die Karte erfolgreich bereitgestellt. ### Stil der Schaltfläche In iOS wird der Stil der Schaltfläche durch die Eigenschaft `iOSButtonStyle` festgelegt. Setzen Sie dieses Prop auf: - `onLightBackground`, wenn Sie die Schaltfläche auf einem hellen oder weißen Hintergrund anzeigen. - `onDarkBackground`, wenn Sie die Schaltfläche auf einem dunklen oder schwarzen Hintergrund anzeigen. Unter Android müssen Sie das tatsächliche Bild-Asset an die Eigenschaft `androidAssetSource` übergeben. Sie können alle möglichen Asset-Optionen [direkt von Google](https://developers.google.com/static/pay/issuers/apis/push-provisioning/android/downloads/add-to-wallet-png.zip) herunterladen. Befolgen Sie bei der Implementierung Ihrer Schaltfläche die [Markenrichtlinien von Google](https://developers.google.com/pay/issuers/apis/push-provisioning/android/branding-guidelines#style). Um Ihr ausgewähltes PNG an die Komponente `AddToWalletButton` zu übergeben, fügen Sie es Ihrem Projekt hinzu, importieren Sie es wie jedes andere Asset und lösen Sie dann die Quelle mit `Image.resolveAssetSource` auf: ```javascript import {Image} from 'react-native'; import AddToGooglePayPNG from '../assets/Add-to-Google-Pay-Button-dark-no-shadow.png'; ... ``` ## Tests ### iOS In iOS können Sie das Push-Provisioning in der Entwicklung, auf Simulatoren und mit Testkarten testen, solange `testEnv={true}` an die `AddToWalletButton`-Komponente übergeben wird. Wenn das `testEnv`-Prop auf `true` gesetzt ist, können Karten nicht zum Wallet des Geräts hinzugefügt werden. In Testumgebungen ist die Berechtigung `com.apple.developer.payment-pass-provisioning` nicht erforderlich. ### Android In Android hat das `testEnv`-Prop keine Auswirkung. Alle Tests müssen im Live-Modus mit Live-Karten und auf physischen Geräten durchgeführt werden. Vergessen Sie nicht, Stripe Ihre Anwendungs-ID mitzuteilen, bevor Sie mit internen Tests beginnen.